astyle

30 files changed, 9423 insertions, 9280 deletions

diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h
index be215010..ff6e13f8 100644
--- a/include/spdlog/async_logger.h
+++ b/include/spdlog/async_logger.h
@@ -1,74 +1,74 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Very fast asynchronous logger (millions of logs per second on an average desktop)
-// Uses pre allocated lockfree queue for maximum throughput even under large number of threads.
-// Creates a single back thread to pop messages from the queue and log them.
-//
-// Upon each log write the logger:
-//    1. Checks if its log level is enough to log the message
-//    2. Push a new copy of the message to a queue (or block the caller until space is available in the queue)
-//    3. will throw spdlog_ex upon log exceptions
-// Upong destruction, logs all remaining messages in the queue before destructing..
-
-#include <spdlog/common.h>
-#include <spdlog/logger.h>
-
-#include <chrono>
-#include <functional>
-#include <string>
-#include <memory>
-
-namespace spdlog
-{
-
-namespace details
-{
-class async_log_helper;
-}
-
-class async_logger :public logger
-{
-public:
-    template<class It>
-    async_logger(const std::string& name,
-                 const It& begin,
-                 const It& end,
-                 size_t queue_size,
-                 const async_overflow_policy overflow_policy =  async_overflow_policy::block_retry,
-                 const std::function<void()>& worker_warmup_cb = nullptr,
-                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());
-
-    async_logger(const std::string& logger_name,
-                 sinks_init_list sinks,
-                 size_t queue_size,
-                 const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
-                 const std::function<void()>& worker_warmup_cb = nullptr,
-                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());
-
-    async_logger(const std::string& logger_name,
-                 sink_ptr single_sink,
-                 size_t queue_size,
-                 const async_overflow_policy overflow_policy =  async_overflow_policy::block_retry,
-                 const std::function<void()>& worker_warmup_cb = nullptr,
-                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());
-
-
-    void flush() override;
-protected:
-    void _log_msg(details::log_msg& msg) override;
-    void _set_formatter(spdlog::formatter_ptr msg_formatter) override;
-    void _set_pattern(const std::string& pattern) override;
-
-private:
-    std::unique_ptr<details::async_log_helper> _async_log_helper;
-};
-}
-
-
-#include <spdlog/details/async_logger_impl.h>
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+// Very fast asynchronous logger (millions of logs per second on an average desktop)

+// Uses pre allocated lockfree queue for maximum throughput even under large number of threads.

+// Creates a single back thread to pop messages from the queue and log them.

+//

+// Upon each log write the logger:

+//    1. Checks if its log level is enough to log the message

+//    2. Push a new copy of the message to a queue (or block the caller until space is available in the queue)

+//    3. will throw spdlog_ex upon log exceptions

+// Upong destruction, logs all remaining messages in the queue before destructing..

+

+#include <spdlog/common.h>

+#include <spdlog/logger.h>

+

+#include <chrono>

+#include <functional>

+#include <string>

+#include <memory>

+

+namespace spdlog

+{

+

+namespace details

+{

+class async_log_helper;

+}

+

+class async_logger :public logger

+{

+public:

+    template<class It>

+    async_logger(const std::string& name,

+                 const It& begin,

+                 const It& end,

+                 size_t queue_size,

+                 const async_overflow_policy overflow_policy =  async_overflow_policy::block_retry,

+                 const std::function<void()>& worker_warmup_cb = nullptr,

+                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());

+

+    async_logger(const std::string& logger_name,

+                 sinks_init_list sinks,

+                 size_t queue_size,

+                 const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,

+                 const std::function<void()>& worker_warmup_cb = nullptr,

+                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());

+

+    async_logger(const std::string& logger_name,

+                 sink_ptr single_sink,

+                 size_t queue_size,

+                 const async_overflow_policy overflow_policy =  async_overflow_policy::block_retry,

+                 const std::function<void()>& worker_warmup_cb = nullptr,

+                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());

+

+

+    void flush() override;

+protected:

+    void _log_msg(details::log_msg& msg) override;

+    void _set_formatter(spdlog::formatter_ptr msg_formatter) override;

+    void _set_pattern(const std::string& pattern) override;

+

+private:

+    std::unique_ptr<details::async_log_helper> _async_log_helper;

+};

+}

+

+

+#include <spdlog/details/async_logger_impl.h>

+

diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index 269c8817..819e888d 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -1,98 +1,98 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <string>
-#include <initializer_list>
-#include <chrono>
-#include <memory>
-#include <exception>
-
-//visual studio does not support noexcept yet
-#ifndef _MSC_VER
-#define SPDLOG_NOEXCEPT noexcept
-#else
-#define SPDLOG_NOEXCEPT throw()
-#endif
-
-
-namespace spdlog
-{
-
-class formatter;
-
-namespace sinks
-{
-class sink;
-}
-
-// Common types across the lib
-using log_clock = std::chrono::system_clock;
-using sink_ptr = std::shared_ptr < sinks::sink >;
-using sinks_init_list = std::initializer_list < sink_ptr >;
-using formatter_ptr = std::shared_ptr<spdlog::formatter>;
-
-
-//Log level enum
-namespace level
-{
-typedef enum
-{
-    trace = 0,
-    debug = 1,
-    info = 2,
-    notice = 3,
-    warn = 4,
-    err = 5,
-    critical = 6,
-    alert = 7,
-    emerg = 8,
-    off = 9
-} level_enum;
-
-static const char* level_names[] { "trace", "debug", "info", "notice", "warning", "error", "critical", "alert", "emerg", "off"};
-
-static const char* short_level_names[] { "T", "D", "I", "N", "W", "E", "C", "A", "M", "O"};
-
-inline const char* to_str(spdlog::level::level_enum l)
-{
-    return level_names[l];
-}
-
-inline const char* to_short_str(spdlog::level::level_enum l)
-{
-    return short_level_names[l];
-}
-} //level
-
-
-//
-// Async overflow policy - block by default.
-//
-enum class async_overflow_policy
-{
-    block_retry, // Block / yield / sleep until message can be enqueued
-    discard_log_msg // Discard the message it enqueue fails
-};
-
-
-//
-// Log exception
-//
-class spdlog_ex : public std::exception
-{
-public:
-    spdlog_ex(const std::string& msg) :_msg(msg) {}
-    const char* what() const SPDLOG_NOEXCEPT override
-    {
-        return _msg.c_str();
-    }
-private:
-    std::string _msg;
-
-};
-
-} //spdlog
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <string>

+#include <initializer_list>

+#include <chrono>

+#include <memory>

+#include <exception>

+

+//visual studio does not support noexcept yet

+#ifndef _MSC_VER

+#define SPDLOG_NOEXCEPT noexcept

+#else

+#define SPDLOG_NOEXCEPT throw()

+#endif

+

+

+namespace spdlog

+{

+

+class formatter;

+

+namespace sinks

+{

+class sink;

+}

+

+// Common types across the lib

+using log_clock = std::chrono::system_clock;

+using sink_ptr = std::shared_ptr < sinks::sink >;

+using sinks_init_list = std::initializer_list < sink_ptr >;

+using formatter_ptr = std::shared_ptr<spdlog::formatter>;

+

+

+//Log level enum

+namespace level

+{

+typedef enum

+{

+    trace = 0,

+    debug = 1,

+    info = 2,

+    notice = 3,

+    warn = 4,

+    err = 5,

+    critical = 6,

+    alert = 7,

+    emerg = 8,

+    off = 9

+} level_enum;

+

+static const char* level_names[] { "trace", "debug", "info", "notice", "warning", "error", "critical", "alert", "emerg", "off"};

+

+static const char* short_level_names[] { "T", "D", "I", "N", "W", "E", "C", "A", "M", "O"};

+

+inline const char* to_str(spdlog::level::level_enum l)

+{

+    return level_names[l];

+}

+

+inline const char* to_short_str(spdlog::level::level_enum l)

+{

+    return short_level_names[l];

+}

+} //level

+

+

+//

+// Async overflow policy - block by default.

+//

+enum class async_overflow_policy

+{

+    block_retry, // Block / yield / sleep until message can be enqueued

+    discard_log_msg // Discard the message it enqueue fails

+};

+

+

+//

+// Log exception

+//

+class spdlog_ex : public std::exception

+{

+public:

+    spdlog_ex(const std::string& msg) :_msg(msg) {}

+    const char* what() const SPDLOG_NOEXCEPT override

+    {

+        return _msg.c_str();

+    }

+private:

+    std::string _msg;

+

+};

+

+} //spdlog

diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h
index 8555ef03..f3cd5179 100644
--- a/include/spdlog/details/async_log_helper.h
+++ b/include/spdlog/details/async_log_helper.h
@@ -1,368 +1,368 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-// async log helper :
-// Process logs asynchronously using a back thread.
-//
-// If the internal queue of log messages reaches its max size,
-// then the client call will block until there is more room.
-//
-// If the back thread throws during logging, a spdlog::spdlog_ex exception
-// will be thrown in client's thread when tries to log the next message
-
-#pragma once
-
-#include <spdlog/common.h>
-#include <spdlog/sinks/sink.h>
-#include <spdlog/details/mpmc_bounded_q.h>
-#include <spdlog/details/log_msg.h>
-#include <spdlog/details/os.h>
-#include <spdlog/formatter.h>
-
-#include <chrono>
-#include <exception>
-#include <functional>
-#include <memory>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace spdlog
-{
-namespace details
-{
-
-class async_log_helper
-{
-    // Async msg to move to/from the queue
-    // Movable only. should never be copied
-    enum class async_msg_type
-    {
-        log,
-        flush,
-        terminate
-    };
-    struct async_msg
-    {
-        std::string logger_name;
-        level::level_enum level;
-        log_clock::time_point time;
-        size_t thread_id;
-        std::string txt;
-        async_msg_type msg_type;
-
-        async_msg() = default;
-        ~async_msg() = default;
-
-
-async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
-        logger_name(std::move(other.logger_name)),
-                    level(std::move(other.level)),
-                    time(std::move(other.time)),
-                    txt(std::move(other.txt)),
-                    msg_type(std::move(other.msg_type))
-        {}
-
-        async_msg(async_msg_type m_type) :msg_type(m_type)
-        {};
-
-        async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT
-        {
-            logger_name = std::move(other.logger_name);
-            level = other.level;
-            time = std::move(other.time);
-            thread_id = other.thread_id;
-            txt = std::move(other.txt);
-            msg_type = other.msg_type;
-            return *this;
-        }
-
-        // never copy or assign. should only be moved..
-        async_msg(const async_msg&) = delete;
-        async_msg& operator=(async_msg& other) = delete;
-
-        // construct from log_msg
-        async_msg(const details::log_msg& m) :
-            logger_name(m.logger_name),
-            level(m.level),
-            time(m.time),
-            thread_id(m.thread_id),
-            txt(m.raw.data(), m.raw.size()),
-            msg_type(async_msg_type::log)
-        {}
-
-
-
-        // copy into log_msg
-        void fill_log_msg(log_msg &msg)
-        {
-            msg.clear();
-            msg.logger_name = logger_name;
-            msg.level = level;
-            msg.time = time;
-            msg.thread_id = thread_id;
-            msg.raw << txt;
-        }
-    };
-
-public:
-
-    using item_type = async_msg;
-    using q_type = details::mpmc_bounded_queue<item_type>;
-
-    using clock = std::chrono::steady_clock;
-
-
-    async_log_helper(formatter_ptr formatter,
-                     const std::vector<sink_ptr>& sinks,
-                     size_t queue_size,
-                     const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
-                     const std::function<void()>& worker_warmup_cb = nullptr,
-                     const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());
-
-    void log(const details::log_msg& msg);
-
-    // stop logging and join the back thread
-    ~async_log_helper();
-
-    void set_formatter(formatter_ptr);
-
-    void flush();
-
-
-private:
-    formatter_ptr _formatter;
-    std::vector<std::shared_ptr<sinks::sink>> _sinks;
-
-    // queue of messages to log
-    q_type _q;
-
-    bool _flush_requested;
-
-    bool _terminate_requested;
-
-
-    // last exception thrown from the worker thread
-    std::shared_ptr<spdlog_ex> _last_workerthread_ex;
-
-    // overflow policy
-    const async_overflow_policy _overflow_policy;
-
-    // worker thread warmup callback - one can set thread priority, affinity, etc
-    const std::function<void()> _worker_warmup_cb;
-
-    // auto periodic sink flush parameter
-    const std::chrono::milliseconds _flush_interval_ms;
-
-    // worker thread
-    std::thread _worker_thread;
-
-    void push_msg(async_msg&& new_msg);
-    // throw last worker thread exception or if worker thread is not active
-
-    void throw_if_bad_worker();
-
-    // worker thread main loop
-    void worker_loop();
-
-    // pop next message from the queue and process it. will set the last_pop to the pop time
-    // return false if termination of the queue is required
-    bool process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush);
-
-    void handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush);
-
-    // sleep,yield or return immediatly using the time passed since last message as a hint
-    static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time);
-
-};
-}
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// async_sink class implementation
-///////////////////////////////////////////////////////////////////////////////
-inline spdlog::details::async_log_helper::async_log_helper(
-    formatter_ptr formatter,
-    const std::vector<sink_ptr>& sinks,
-    size_t queue_size,
-    const async_overflow_policy overflow_policy,
-    const std::function<void()>& worker_warmup_cb,
-    const std::chrono::milliseconds& flush_interval_ms):
-    _formatter(formatter),
-    _sinks(sinks),
-    _q(queue_size),
-    _flush_requested(false),
-    _terminate_requested(false),
-    _overflow_policy(overflow_policy),
-    _worker_warmup_cb(worker_warmup_cb),
-    _flush_interval_ms(flush_interval_ms),
-    _worker_thread(&async_log_helper::worker_loop, this)
-{}
-
-// Send to the worker thread termination message(level=off)
-// and wait for it to finish gracefully
-inline spdlog::details::async_log_helper::~async_log_helper()
-{
-    try
-    {
-        push_msg(async_msg(async_msg_type::terminate));
-        _worker_thread.join();
-    }
-    catch (...) // don't crash in destructor
-    {}
-}
-
-
-//Try to push and block until succeeded
-inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)
-{
-    push_msg(async_msg(msg));
-
-
-}
-
-//Try to push and block until succeeded
-inline void spdlog::details::async_log_helper::push_msg(details::async_log_helper::async_msg&& new_msg)
-{
-    throw_if_bad_worker();
-    if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)
-    {
-        auto last_op_time = details::os::now();
-        auto now = last_op_time;
-        do
-        {
-            now = details::os::now();
-            sleep_or_yield(now, last_op_time);
-        }
-        while (!_q.enqueue(std::move(new_msg)));
-    }
-
-}
-
-inline void spdlog::details::async_log_helper::flush()
-{
-    push_msg(async_msg(async_msg_type::flush));
-}
-
-inline void spdlog::details::async_log_helper::worker_loop()
-{
-    try
-    {
-        if (_worker_warmup_cb) _worker_warmup_cb();
-        auto last_pop = details::os::now();
-        auto last_flush = last_pop;
-        while(process_next_msg(last_pop, last_flush));
-    }
-    catch (const std::exception& ex)
-    {
-        _last_workerthread_ex = std::make_shared<spdlog_ex>(std::string("async_logger worker thread exception: ") + ex.what());
-    }
-    catch (...)
-    {
-        _last_workerthread_ex = std::make_shared<spdlog_ex>("async_logger worker thread exception");
-    }
-}
-
-// process next message in the queue
-// return true if this thread should still be active (no msg with level::off was received)
-inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush)
-{
-
-    async_msg incoming_async_msg;
-    log_msg incoming_log_msg;
-
-    if (_q.dequeue(incoming_async_msg))
-    {
-        last_pop = details::os::now();
-        switch (incoming_async_msg.msg_type)
-        {
-        case async_msg_type::flush:
-            _flush_requested = true;
-            break;
-
-        case async_msg_type::terminate:
-            _flush_requested = true;
-            _terminate_requested = true;
-            break;
-
-        default:
-            incoming_async_msg.fill_log_msg(incoming_log_msg);
-            _formatter->format(incoming_log_msg);
-            for (auto &s : _sinks)
-                s->log(incoming_log_msg);
-        }
-        return true;
-    }
-
-    // Handle empty queue..
-    // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue
-    else
-    {
-        auto now = details::os::now();
-        handle_flush_interval(now, last_flush);
-        sleep_or_yield(now, last_pop);
-        return !_terminate_requested;
-
-    }
-}
-
-inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush)
-{
-    auto should_flush = _flush_requested || (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms);
-    if (should_flush)
-    {
-        for (auto &s : _sinks)
-            s->flush();
-        now = last_flush = details::os::now();
-        _flush_requested = false;
-    }
-}
-inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)
-{
-    _formatter = msg_formatter;
-}
-
-
-// sleep,yield or return immediatly using the time passed since last message as a hint
-inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_clock::time_point& now, const spdlog::log_clock::time_point& last_op_time)
-{
-    using std::chrono::milliseconds;
-    using namespace std::this_thread;
-
-    auto time_since_op = now - last_op_time;
-
-    // spin upto 1 ms
-    if (time_since_op <= milliseconds(1))
-        return;
-
-    // yield upto 10ms
-    if (time_since_op <= milliseconds(10))
-        return yield();
-
-
-    // sleep for half of duration since last op
-    if (time_since_op <= milliseconds(100))
-        return sleep_for(time_since_op / 2);
-
-    return sleep_for(milliseconds(100));
-}
-
-// throw if the worker thread threw an exception or not active
-inline void spdlog::details::async_log_helper::throw_if_bad_worker()
-{
-    if (_last_workerthread_ex)
-    {
-        auto ex = std::move(_last_workerthread_ex);
-        throw *ex;
-    }
-}
-
-
-
-
-
-
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+// async log helper :

+// Process logs asynchronously using a back thread.

+//

+// If the internal queue of log messages reaches its max size,

+// then the client call will block until there is more room.

+//

+// If the back thread throws during logging, a spdlog::spdlog_ex exception

+// will be thrown in client's thread when tries to log the next message

+

+#pragma once

+

+#include <spdlog/common.h>

+#include <spdlog/sinks/sink.h>

+#include <spdlog/details/mpmc_bounded_q.h>

+#include <spdlog/details/log_msg.h>

+#include <spdlog/details/os.h>

+#include <spdlog/formatter.h>

+

+#include <chrono>

+#include <exception>

+#include <functional>

+#include <memory>

+#include <string>

+#include <thread>

+#include <utility>

+#include <vector>

+

+namespace spdlog

+{

+namespace details

+{

+

+class async_log_helper

+{

+    // Async msg to move to/from the queue

+    // Movable only. should never be copied

+    enum class async_msg_type

+    {

+        log,

+        flush,

+        terminate

+    };

+    struct async_msg

+    {

+        std::string logger_name;

+        level::level_enum level;

+        log_clock::time_point time;

+        size_t thread_id;

+        std::string txt;

+        async_msg_type msg_type;

+

+        async_msg() = default;

+        ~async_msg() = default;

+

+

+async_msg(async_msg&& other) SPDLOG_NOEXCEPT:

+        logger_name(std::move(other.logger_name)),

+                    level(std::move(other.level)),

+                    time(std::move(other.time)),

+                    txt(std::move(other.txt)),

+                    msg_type(std::move(other.msg_type))

+        {}

+

+        async_msg(async_msg_type m_type) :msg_type(m_type)

+        {};

+

+        async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT

+        {

+            logger_name = std::move(other.logger_name);

+            level = other.level;

+            time = std::move(other.time);

+            thread_id = other.thread_id;

+            txt = std::move(other.txt);

+            msg_type = other.msg_type;

+            return *this;

+        }

+

+        // never copy or assign. should only be moved..

+        async_msg(const async_msg&) = delete;

+        async_msg& operator=(async_msg& other) = delete;

+

+        // construct from log_msg

+        async_msg(const details::log_msg& m) :

+            logger_name(m.logger_name),

+            level(m.level),

+            time(m.time),

+            thread_id(m.thread_id),

+            txt(m.raw.data(), m.raw.size()),

+            msg_type(async_msg_type::log)

+        {}

+

+

+

+        // copy into log_msg

+        void fill_log_msg(log_msg &msg)

+        {

+            msg.clear();

+            msg.logger_name = logger_name;

+            msg.level = level;

+            msg.time = time;

+            msg.thread_id = thread_id;

+            msg.raw << txt;

+        }

+    };

+

+public:

+

+    using item_type = async_msg;

+    using q_type = details::mpmc_bounded_queue<item_type>;

+

+    using clock = std::chrono::steady_clock;

+

+

+    async_log_helper(formatter_ptr formatter,

+                     const std::vector<sink_ptr>& sinks,

+                     size_t queue_size,

+                     const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,

+                     const std::function<void()>& worker_warmup_cb = nullptr,

+                     const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());

+

+    void log(const details::log_msg& msg);

+

+    // stop logging and join the back thread

+    ~async_log_helper();

+

+    void set_formatter(formatter_ptr);

+

+    void flush();

+

+

+private:

+    formatter_ptr _formatter;

+    std::vector<std::shared_ptr<sinks::sink>> _sinks;

+

+    // queue of messages to log

+    q_type _q;

+

+    bool _flush_requested;

+

+    bool _terminate_requested;

+

+

+    // last exception thrown from the worker thread

+    std::shared_ptr<spdlog_ex> _last_workerthread_ex;

+

+    // overflow policy

+    const async_overflow_policy _overflow_policy;

+

+    // worker thread warmup callback - one can set thread priority, affinity, etc

+    const std::function<void()> _worker_warmup_cb;

+

+    // auto periodic sink flush parameter

+    const std::chrono::milliseconds _flush_interval_ms;

+

+    // worker thread

+    std::thread _worker_thread;

+

+    void push_msg(async_msg&& new_msg);

+    // throw last worker thread exception or if worker thread is not active

+

+    void throw_if_bad_worker();

+

+    // worker thread main loop

+    void worker_loop();

+

+    // pop next message from the queue and process it. will set the last_pop to the pop time

+    // return false if termination of the queue is required

+    bool process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush);

+

+    void handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush);

+

+    // sleep,yield or return immediatly using the time passed since last message as a hint

+    static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time);

+

+};

+}

+}

+

+///////////////////////////////////////////////////////////////////////////////

+// async_sink class implementation

+///////////////////////////////////////////////////////////////////////////////

+inline spdlog::details::async_log_helper::async_log_helper(

+    formatter_ptr formatter,

+    const std::vector<sink_ptr>& sinks,

+    size_t queue_size,

+    const async_overflow_policy overflow_policy,

+    const std::function<void()>& worker_warmup_cb,

+    const std::chrono::milliseconds& flush_interval_ms):

+    _formatter(formatter),

+    _sinks(sinks),

+    _q(queue_size),

+    _flush_requested(false),

+    _terminate_requested(false),

+    _overflow_policy(overflow_policy),

+    _worker_warmup_cb(worker_warmup_cb),

+    _flush_interval_ms(flush_interval_ms),

+    _worker_thread(&async_log_helper::worker_loop, this)

+{}

+

+// Send to the worker thread termination message(level=off)

+// and wait for it to finish gracefully

+inline spdlog::details::async_log_helper::~async_log_helper()

+{

+    try

+    {

+        push_msg(async_msg(async_msg_type::terminate));

+        _worker_thread.join();

+    }

+    catch (...) // don't crash in destructor

+    {}

+}

+

+

+//Try to push and block until succeeded

+inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)

+{

+    push_msg(async_msg(msg));

+

+

+}

+

+//Try to push and block until succeeded

+inline void spdlog::details::async_log_helper::push_msg(details::async_log_helper::async_msg&& new_msg)

+{

+    throw_if_bad_worker();

+    if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)

+    {

+        auto last_op_time = details::os::now();

+        auto now = last_op_time;

+        do

+        {

+            now = details::os::now();

+            sleep_or_yield(now, last_op_time);

+        }

+        while (!_q.enqueue(std::move(new_msg)));

+    }

+

+}

+

+inline void spdlog::details::async_log_helper::flush()

+{

+    push_msg(async_msg(async_msg_type::flush));

+}

+

+inline void spdlog::details::async_log_helper::worker_loop()

+{

+    try

+    {

+        if (_worker_warmup_cb) _worker_warmup_cb();

+        auto last_pop = details::os::now();

+        auto last_flush = last_pop;

+        while(process_next_msg(last_pop, last_flush));

+    }

+    catch (const std::exception& ex)

+    {

+        _last_workerthread_ex = std::make_shared<spdlog_ex>(std::string("async_logger worker thread exception: ") + ex.what());

+    }

+    catch (...)

+    {

+        _last_workerthread_ex = std::make_shared<spdlog_ex>("async_logger worker thread exception");

+    }

+}

+

+// process next message in the queue

+// return true if this thread should still be active (no msg with level::off was received)

+inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush)

+{

+

+    async_msg incoming_async_msg;

+    log_msg incoming_log_msg;

+

+    if (_q.dequeue(incoming_async_msg))

+    {

+        last_pop = details::os::now();

+        switch (incoming_async_msg.msg_type)

+        {

+        case async_msg_type::flush:

+            _flush_requested = true;

+            break;

+

+        case async_msg_type::terminate:

+            _flush_requested = true;

+            _terminate_requested = true;

+            break;

+

+        default:

+            incoming_async_msg.fill_log_msg(incoming_log_msg);

+            _formatter->format(incoming_log_msg);

+            for (auto &s : _sinks)

+                s->log(incoming_log_msg);

+        }

+        return true;

+    }

+

+    // Handle empty queue..

+    // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue

+    else

+    {

+        auto now = details::os::now();

+        handle_flush_interval(now, last_flush);

+        sleep_or_yield(now, last_pop);

+        return !_terminate_requested;

+

+    }

+}

+

+inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush)

+{

+    auto should_flush = _flush_requested || (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms);

+    if (should_flush)

+    {

+        for (auto &s : _sinks)

+            s->flush();

+        now = last_flush = details::os::now();

+        _flush_requested = false;

+    }

+}

+inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)

+{

+    _formatter = msg_formatter;

+}

+

+

+// sleep,yield or return immediatly using the time passed since last message as a hint

+inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_clock::time_point& now, const spdlog::log_clock::time_point& last_op_time)

+{

+    using std::chrono::milliseconds;

+    using namespace std::this_thread;

+

+    auto time_since_op = now - last_op_time;

+

+    // spin upto 1 ms

+    if (time_since_op <= milliseconds(1))

+        return;

+

+    // yield upto 10ms

+    if (time_since_op <= milliseconds(10))

+        return yield();

+

+

+    // sleep for half of duration since last op

+    if (time_since_op <= milliseconds(100))

+        return sleep_for(time_since_op / 2);

+

+    return sleep_for(milliseconds(100));

+}

+

+// throw if the worker thread threw an exception or not active

+inline void spdlog::details::async_log_helper::throw_if_bad_worker()

+{

+    if (_last_workerthread_ex)

+    {

+        auto ex = std::move(_last_workerthread_ex);

+        throw *ex;

+    }

+}

+

+

+

+

+

+

+

diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h
index 140d45f4..9b4da68b 100644
--- a/include/spdlog/details/async_logger_impl.h
+++ b/include/spdlog/details/async_logger_impl.h
@@ -1,74 +1,74 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Async Logger implementation
-// Use an async_sink (queue per logger) to perform the logging in a worker thread
-
-#include <spdlog/details/async_log_helper.h>
-#include <spdlog/async_logger.h>
-
-#include <string>
-#include <functional>
-#include <chrono>
-#include <memory>
-
-template<class It>
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
-        const It& begin,
-        const It& end,
-        size_t queue_size,
-        const  async_overflow_policy overflow_policy,
-        const std::function<void()>& worker_warmup_cb,
-        const std::chrono::milliseconds& flush_interval_ms) :
-    logger(logger_name, begin, end),
-    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms))
-{
-}
-
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
-        sinks_init_list sinks,
-        size_t queue_size,
-        const  async_overflow_policy overflow_policy,
-        const std::function<void()>& worker_warmup_cb,
-        const std::chrono::milliseconds& flush_interval_ms) :
-    async_logger(logger_name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms) {}
-
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
-        sink_ptr single_sink,
-        size_t queue_size,
-        const  async_overflow_policy overflow_policy,
-        const std::function<void()>& worker_warmup_cb,
-        const std::chrono::milliseconds& flush_interval_ms) :
-    async_logger(logger_name,
-{
-    single_sink
-}, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms) {}
-
-
-inline void spdlog::async_logger::flush()
-{
-
-    _async_log_helper->flush();
-}
-
-inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter)
-{
-    _formatter = msg_formatter;
-    _async_log_helper->set_formatter(_formatter);
-}
-
-inline void spdlog::async_logger::_set_pattern(const std::string& pattern)
-{
-    _formatter = std::make_shared<pattern_formatter>(pattern);
-    _async_log_helper->set_formatter(_formatter);
-}
-
-
-inline void spdlog::async_logger::_log_msg(details::log_msg& msg)
-{
-    _async_log_helper->log(msg);
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+// Async Logger implementation

+// Use an async_sink (queue per logger) to perform the logging in a worker thread

+

+#include <spdlog/details/async_log_helper.h>

+#include <spdlog/async_logger.h>

+

+#include <string>

+#include <functional>

+#include <chrono>

+#include <memory>

+

+template<class It>

+inline spdlog::async_logger::async_logger(const std::string& logger_name,

+        const It& begin,

+        const It& end,

+        size_t queue_size,

+        const  async_overflow_policy overflow_policy,

+        const std::function<void()>& worker_warmup_cb,

+        const std::chrono::milliseconds& flush_interval_ms) :

+    logger(logger_name, begin, end),

+    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms))

+{

+}

+

+inline spdlog::async_logger::async_logger(const std::string& logger_name,

+        sinks_init_list sinks,

+        size_t queue_size,

+        const  async_overflow_policy overflow_policy,

+        const std::function<void()>& worker_warmup_cb,

+        const std::chrono::milliseconds& flush_interval_ms) :

+    async_logger(logger_name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms) {}

+

+inline spdlog::async_logger::async_logger(const std::string& logger_name,

+        sink_ptr single_sink,

+        size_t queue_size,

+        const  async_overflow_policy overflow_policy,

+        const std::function<void()>& worker_warmup_cb,

+        const std::chrono::milliseconds& flush_interval_ms) :

+    async_logger(logger_name,

+{

+    single_sink

+}, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms) {}

+

+

+inline void spdlog::async_logger::flush()

+{

+

+    _async_log_helper->flush();

+}

+

+inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter)

+{

+    _formatter = msg_formatter;

+    _async_log_helper->set_formatter(_formatter);

+}

+

+inline void spdlog::async_logger::_set_pattern(const std::string& pattern)

+{

+    _formatter = std::make_shared<pattern_formatter>(pattern);

+    _async_log_helper->set_formatter(_formatter);

+}

+

+

+inline void spdlog::async_logger::_log_msg(details::log_msg& msg)

+{

+    _async_log_helper->log(msg);

+}

diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h
index e563d006..c08f2830 100644
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -1,142 +1,142 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Helper class for file sink
-// When failing to open a file, retry several times(5) with small delay between the tries(10 ms)
-// Can be set to auto flush on every line
-// Throw spdlog_ex exception on errors
-
-#include <spdlog/details/os.h>
-#include <spdlog/details/log_msg.h>
-
-#include <chrono>
-#include <cstdio>
-#include <string>
-#include <thread>
-
-namespace spdlog
-{
-namespace details
-{
-
-class file_helper
-{
-public:
-    const int open_tries = 5;
-    const int open_interval = 10;
-
-    explicit file_helper(bool force_flush) :
-        _fd(nullptr),
-        _force_flush(force_flush)
-    {}
-
-    file_helper(const file_helper&) = delete;
-    file_helper& operator=(const file_helper&) = delete;
-
-    ~file_helper()
-    {
-        close();
-    }
-
-
-    void open(const std::string& fname, bool truncate = false)
-    {
-
-        close();
-        const char* mode = truncate ? "wb" : "ab";
-        _filename = fname;
-        for (int tries = 0; tries < open_tries; ++tries)
-        {
-            if (!os::fopen_s(&_fd, fname, mode))
-                return;
-
-            std::this_thread::sleep_for(std::chrono::milliseconds(open_interval));
-        }
-
-        throw spdlog_ex("Failed opening file " + fname + " for writing");
-    }
-
-    void reopen(bool truncate)
-    {
-        if (_filename.empty())
-            throw spdlog_ex("Failed re opening file - was not opened before");
-        open(_filename, truncate);
-
-    }
-
-    void flush()
-    {
-        std::fflush(_fd);
-    }
-
-    void close()
-    {
-        if (_fd)
-        {
-            std::fclose(_fd);
-            _fd = nullptr;
-        }
-    }
-
-    void write(const log_msg& msg)
-    {
-
-        size_t msg_size = msg.formatted.size();
-        auto data = msg.formatted.data();
-        if (std::fwrite(data, 1, msg_size, _fd) != msg_size)
-            throw spdlog_ex("Failed writing to file " + _filename);
-
-        if (_force_flush)
-            std::fflush(_fd);
-
-    }
-
-    long size()
-    {
-        if (!_fd)
-            throw spdlog_ex("Cannot use size() on closed file " + _filename);
-
-        auto pos = ftell(_fd);
-        if (fseek(_fd, 0, SEEK_END) != 0)
-            throw spdlog_ex("fseek failed on file " + _filename);
-
-        auto file_size = ftell(_fd);
-
-        if(fseek(_fd, pos, SEEK_SET) !=0)
-            throw spdlog_ex("fseek failed on file " + _filename);
-
-        if (file_size == -1)
-            throw spdlog_ex("ftell failed on file " + _filename);
-
-
-        return file_size;
-
-
-    }
-
-    const std::string& filename() const
-    {
-        return _filename;
-    }
-
-    static bool file_exists(const std::string& name)
-    {
-
-        return os::file_exists(name);
-    }
-
-
-
-private:
-    FILE* _fd;
-    std::string _filename;
-    bool _force_flush;
-
-
-};
-}
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+// Helper class for file sink

+// When failing to open a file, retry several times(5) with small delay between the tries(10 ms)

+// Can be set to auto flush on every line

+// Throw spdlog_ex exception on errors

+

+#include <spdlog/details/os.h>

+#include <spdlog/details/log_msg.h>

+

+#include <chrono>

+#include <cstdio>

+#include <string>

+#include <thread>

+

+namespace spdlog

+{

+namespace details

+{

+

+class file_helper

+{

+public:

+    const int open_tries = 5;

+    const int open_interval = 10;

+

+    explicit file_helper(bool force_flush) :

+        _fd(nullptr),

+        _force_flush(force_flush)

+    {}

+

+    file_helper(const file_helper&) = delete;

+    file_helper& operator=(const file_helper&) = delete;

+

+    ~file_helper()

+    {

+        close();

+    }

+

+

+    void open(const std::string& fname, bool truncate = false)

+    {

+

+        close();

+        const char* mode = truncate ? "wb" : "ab";

+        _filename = fname;

+        for (int tries = 0; tries < open_tries; ++tries)

+        {

+            if (!os::fopen_s(&_fd, fname, mode))

+                return;

+

+            std::this_thread::sleep_for(std::chrono::milliseconds(open_interval));

+        }

+

+        throw spdlog_ex("Failed opening file " + fname + " for writing");

+    }

+

+    void reopen(bool truncate)

+    {

+        if (_filename.empty())

+            throw spdlog_ex("Failed re opening file - was not opened before");

+        open(_filename, truncate);

+

+    }

+

+    void flush()

+    {

+        std::fflush(_fd);

+    }

+

+    void close()

+    {

+        if (_fd)

+        {

+            std::fclose(_fd);

+            _fd = nullptr;

+        }

+    }

+

+    void write(const log_msg& msg)

+    {

+

+        size_t msg_size = msg.formatted.size();

+        auto data = msg.formatted.data();

+        if (std::fwrite(data, 1, msg_size, _fd) != msg_size)

+            throw spdlog_ex("Failed writing to file " + _filename);

+

+        if (_force_flush)

+            std::fflush(_fd);

+

+    }

+

+    long size()

+    {

+        if (!_fd)

+            throw spdlog_ex("Cannot use size() on closed file " + _filename);

+

+        auto pos = ftell(_fd);

+        if (fseek(_fd, 0, SEEK_END) != 0)

+            throw spdlog_ex("fseek failed on file " + _filename);

+

+        auto file_size = ftell(_fd);

+

+        if(fseek(_fd, pos, SEEK_SET) !=0)

+            throw spdlog_ex("fseek failed on file " + _filename);

+

+        if (file_size == -1)

+            throw spdlog_ex("ftell failed on file " + _filename);

+

+

+        return file_size;

+

+

+    }

+

+    const std::string& filename() const

+    {

+        return _filename;

+    }

+

+    static bool file_exists(const std::string& name)

+    {

+

+        return os::file_exists(name);

+    }

+

+

+

+private:

+    FILE* _fd;

+    std::string _filename;

+    bool _force_flush;

+

+

+};

+}

+}

diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc
index bbc856a2..cd246e4e 100644
--- a/include/spdlog/details/format.cc
+++ b/include/spdlog/details/format.cc
@@ -1,1066 +1,1066 @@
-/*
-Formatting library for C++
-
-Copyright (c) 2012 - 2015, Victor Zverovich
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-this list of conditions and the following disclaimer in the documentation
-and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include "format.h"
-
-#include <string.h>
-
-#include <cctype>
-#include <cerrno>
-#include <climits>
-#include <cmath>
-#include <cstdarg>
-#include <cstddef>  // for std::ptrdiff_t
-
-#if defined(_WIN32) && defined(__MINGW32__)
-# include <cstring>
-#endif
-
-#if FMT_USE_WINDOWS_H
-# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#  include <windows.h>
-# else
-#  define NOMINMAX
-#  include <windows.h>
-#  undef NOMINMAX
-# endif
-#endif
-
-using fmt::internal::Arg;
-
-#if FMT_EXCEPTIONS
-# define FMT_TRY try
-# define FMT_CATCH(x) catch (x)
-#else
-# define FMT_TRY if (true)
-# define FMT_CATCH(x) if (false)
-#endif
-
-#ifdef FMT_HEADER_ONLY
-# define FMT_FUNC inline
-#else
-# define FMT_FUNC
-#endif
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127)  // conditional expression is constant
-# 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)
-#endif
-
-// Dummy implementations of strerror_r and strerror_s called if corresponding
-// system functions are not available.
-static inline fmt::internal::Null<> strerror_r(int, char *, ...)
-{
-	return fmt::internal::Null<>();
-}
-static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...)
-{
-	return fmt::internal::Null<>();
-}
-
-namespace fmt {
-	namespace {
-
-#ifndef _MSC_VER
-# define FMT_SNPRINTF snprintf
-#else  // _MSC_VER
-		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
-#endif  // _MSC_VER
-
-#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-# define FMT_SWPRINTF snwprintf
-#else
-# define FMT_SWPRINTF swprintf
-#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-
-		// Checks if a value fits in int - used to avoid warnings about comparing
-		// signed and unsigned integers.
-		template <bool IsSigned>
-		struct IntChecker
-		{
-			template <typename T>
-			static bool fits_in_int(T value)
-			{
-				unsigned max = INT_MAX;
-				return value <= max;
-			}
-			static bool fits_in_int(bool)
-			{
-				return true;
-			}
-		};
-
-		template <>
-		struct IntChecker<true>
-		{
-			template <typename T>
-			static bool fits_in_int(T value)
-			{
-				return value >= INT_MIN && value <= INT_MAX;
-			}
-			static bool fits_in_int(int)
-			{
-				return true;
-			}
-		};
-
-		const char RESET_COLOR[] = "\x1b[0m";
-
-		typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
-
-		// Portable thread-safe version of strerror.
-		// Sets buffer to point to a string describing the error code.
-		// This can be either a pointer to a string stored in buffer,
-		// or a pointer to some static immutable string.
-		// Returns one of the following values:
-		//   0      - success
-		//   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
-		{
-			FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");
-
-			class StrError
-			{
-			private:
-				int error_code_;
-				char *&buffer_;
-				std::size_t buffer_size_;
-
-				// A noop assignment operator to avoid bogus warnings.
-				void operator=(const StrError &)
-				{}
-
-				// Handle the result of XSI-compliant version of strerror_r.
-				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)
-				{
-					// If the buffer is full then the message is probably truncated.
-					if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
-						return ERANGE;
-					buffer_ = message;
-					return 0;
-				}
-
-				// Handle the case when strerror_r is not available.
-				int handle(fmt::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)
-				{
-					// If the buffer is full then the message is probably truncated.
-					return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
-						ERANGE : result;
-				}
-
-				// Fallback to strerror if strerror_r and strerror_s are not available.
-				int fallback(fmt::internal::Null<>)
-				{
-					errno = 0;
-					buffer_ = strerror(error_code_);
-					return errno;
-				}
-
-			public:
-				StrError(int err_code, char *&buf, std::size_t buf_size)
-					: error_code_(err_code), buffer_(buf), buffer_size_(buf_size)
-				{}
-
-				int run()
-				{
-					strerror_r(0, 0, "");  // Suppress a warning about unused strerror_r.
-					return handle(strerror_r(error_code_, buffer_, buffer_size_));
-				}
-			};
-			return StrError(error_code, buffer, buffer_size).run();
-		}
-
-		void format_error_code(fmt::Writer &out, int error_code,
-			fmt::StringRef 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.
-			out.clear();
-			static const char SEP[] = ": ";
-			static const char ERROR_STR[] = "error ";
-			// Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-			std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-			typedef fmt::internal::IntTraits<int>::MainType MainType;
-			MainType abs_value = static_cast<MainType>(error_code);
-			if (internal::is_negative(error_code)) {
-				abs_value = 0 - abs_value;
-				++error_code_size;
-			}
-			error_code_size += fmt::internal::count_digits(abs_value);
-			if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)
-				out << message << SEP;
-			out << ERROR_STR << error_code;
-			assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);
-		}
-
-		void report_error(FormatFunc func,
-			int error_code, fmt::StringRef message) FMT_NOEXCEPT
-		{
-			fmt::MemoryWriter full_message;
-			func(full_message, error_code, message);
-			// Use Writer::data instead of Writer::c_str to avoid potential memory
-			// allocation.
-			std::fwrite(full_message.data(), full_message.size(), 1, stderr);
-			std::fputc('\n', stderr);
-		}
-
-		// IsZeroInt::visit(arg) returns true iff arg is a zero integer.
-		class IsZeroInt: public fmt::internal::ArgVisitor<IsZeroInt, bool>
-		{
-		public:
-			template <typename T>
-			bool visit_any_int(T value)
-			{
-				return value == 0;
-			}
-		};
-
-		// Checks if an argument is a valid printf width specifier and sets
-		// left alignment if it is negative.
-		class WidthHandler: public fmt::internal::ArgVisitor<WidthHandler, unsigned>
-		{
-		private:
-			fmt::FormatSpec &spec_;
-
-			FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
-
-		public:
-			explicit WidthHandler(fmt::FormatSpec &spec): spec_(spec)
-			{}
-
-			void report_unhandled_arg()
-			{
-				FMT_THROW(fmt::FormatError("width is not integer"));
-			}
-
-			template <typename T>
-			unsigned visit_any_int(T value)
-			{
-				typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType;
-				UnsignedType width = static_cast<UnsignedType>(value);
-				if (fmt::internal::is_negative(value)) {
-					spec_.align_ = fmt::ALIGN_LEFT;
-					width = 0 - width;
-				}
-				if (width > INT_MAX)
-					FMT_THROW(fmt::FormatError("number is too big"));
-				return static_cast<unsigned>(width);
-			}
-		};
-
-		class PrecisionHandler:
-			public fmt::internal::ArgVisitor<PrecisionHandler, int>
-		{
-		public:
-			void report_unhandled_arg()
-			{
-				FMT_THROW(fmt::FormatError("precision is not integer"));
-			}
-
-			template <typename T>
-			int visit_any_int(T value)
-			{
-				if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-					FMT_THROW(fmt::FormatError("number is too big"));
-				return static_cast<int>(value);
-			}
-		};
-
-		template <typename T, typename U>
-		struct is_same
-		{
-			enum
-			{
-				value = 0
-			};
-		};
-
-		template <typename T>
-		struct is_same<T, T>
-		{
-			enum
-			{
-				value = 1
-			};
-		};
-
-		// An argument visitor that converts an integer argument to T for printf,
-		// if T is an integral type. 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 = void>
-		class ArgConverter: public fmt::internal::ArgVisitor<ArgConverter<T>, void>
-		{
-		private:
-			fmt::internal::Arg &arg_;
-			wchar_t type_;
-
-			FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
-
-		public:
-			ArgConverter(fmt::internal::Arg &arg, wchar_t type)
-				: arg_(arg), type_(type)
-			{}
-
-			void visit_bool(bool value)
-			{
-				if (type_ != 's')
-					visit_any_int(value);
-			}
-
-			template <typename U>
-			void visit_any_int(U value)
-			{
-				bool is_signed = type_ == 'd' || type_ == 'i';
-				using fmt::internal::Arg;
-				typedef typename fmt::internal::Conditional<
-					is_same<T, void>::value, U, T>::type TargetType;
-				if (sizeof(TargetType) <= sizeof(int)) {
-					// Extra casts are used to silence warnings.
-					if (is_signed) {
-						arg_.type = Arg::INT;
-						arg_.int_value = static_cast<int>(static_cast<TargetType>(value));
-					}
-					else {
-						arg_.type = Arg::UINT;
-						typedef typename fmt::internal::MakeUnsigned<TargetType>::Type Unsigned;
-						arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));
-					}
-				}
-				else {
-					if (is_signed) {
-						arg_.type = Arg::LONG_LONG;
-						// 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_.long_long_value = static_cast<fmt::LongLong>(value);
-					}
-					else {
-						arg_.type = Arg::ULONG_LONG;
-						arg_.ulong_long_value =
-							static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
-					}
-				}
-			}
-		};
-
-		// Converts an integer argument to char for printf.
-		class CharConverter: public fmt::internal::ArgVisitor<CharConverter, void>
-		{
-		private:
-			fmt::internal::Arg &arg_;
-
-			FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
-
-		public:
-			explicit CharConverter(fmt::internal::Arg &arg): arg_(arg)
-			{}
-
-			template <typename T>
-			void visit_any_int(T value)
-			{
-				arg_.type = Arg::CHAR;
-				arg_.int_value = static_cast<char>(value);
-			}
-		};
-
-		// Write the content of w to os.
-		void write(std::ostream &os, fmt::Writer &w)
-		{
-			const char *data = w.data();
-			typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
-			UnsignedStreamSize size = w.size();
-			UnsignedStreamSize max_size =
-				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;
-				size -= n;
-			} while (size != 0);
-		}
-	}  // namespace
-
-	namespace internal {
-
-		template <typename Char>
-		class PrintfArgFormatter:
-			public ArgFormatterBase<PrintfArgFormatter<Char>, Char>
-		{
-
-			void write_null_pointer()
-			{
-				this->spec().type_ = 0;
-				this->write("(nil)");
-			}
-
-			typedef ArgFormatterBase<PrintfArgFormatter<Char>, Char> Base;
-
-		public:
-			PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
-				: ArgFormatterBase<PrintfArgFormatter<Char>, Char>(w, s)
-			{}
-
-			void visit_bool(bool value)
-			{
-				FormatSpec &fmt_spec = this->spec();
-				if (fmt_spec.type_ != 's')
-					return this->visit_any_int(value);
-				fmt_spec.type_ = 0;
-				this->write(value);
-			}
-
-			void visit_char(int value)
-			{
-				const FormatSpec &fmt_spec = this->spec();
-				BasicWriter<Char> &w = this->writer();
-				if (fmt_spec.type_ && fmt_spec.type_ != 'c')
-					w.write_int(value, fmt_spec);
-				typedef typename BasicWriter<Char>::CharPtr CharPtr;
-				CharPtr out = CharPtr();
-				if (fmt_spec.width_ > 1) {
-					Char fill = ' ';
-					out = w.grow_buffer(fmt_spec.width_);
-					if (fmt_spec.align_ != ALIGN_LEFT) {
-						std::fill_n(out, fmt_spec.width_ - 1, fill);
-						out += fmt_spec.width_ - 1;
-					}
-					else {
-						std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
-					}
-				}
-				else {
-					out = w.grow_buffer(1);
-				}
-				*out = static_cast<Char>(value);
-			}
-
-			void visit_cstring(const char *value)
-			{
-				if (value)
-					Base::visit_cstring(value);
-				else if (this->spec().type_ == 'p')
-					write_null_pointer();
-				else
-					this->write("(null)");
-			}
-
-			void visit_pointer(const void *value)
-			{
-				if (value)
-					return Base::visit_pointer(value);
-				this->spec().type_ = 0;
-				write_null_pointer();
-			}
-
-			void visit_custom(Arg::CustomValue c)
-			{
-				BasicFormatter<Char> formatter(ArgList(), this->writer());
-				const Char format_str[] = { '}', 0 };
-				const Char *format = format_str;
-				c.format(&formatter, c.value, &format);
-			}
-		};
-	}  // namespace internal
-}  // namespace fmt
-
-FMT_FUNC void fmt::SystemError::init(
-	int err_code, CStringRef format_str, ArgList args)
-{
-	error_code_ = err_code;
-	MemoryWriter w;
-	internal::format_system_error(w, err_code, format(format_str, args));
-	std::runtime_error &base = *this;
-	base = std::runtime_error(w.str());
-}
-
-template <typename T>
-int fmt::internal::CharTraits<char>::format_float(
-	char *buffer, std::size_t size, const char *format,
-	unsigned width, int precision, T value)
-{
-	if (width == 0) {
-		return precision < 0 ?
-			FMT_SNPRINTF(buffer, size, format, value) :
-			FMT_SNPRINTF(buffer, size, format, precision, value);
-	}
-	return precision < 0 ?
-		FMT_SNPRINTF(buffer, size, format, width, value) :
-		FMT_SNPRINTF(buffer, size, format, width, precision, value);
-}
-
-template <typename T>
-int fmt::internal::CharTraits<wchar_t>::format_float(
-	wchar_t *buffer, std::size_t size, const wchar_t *format,
-	unsigned width, int precision, T value)
-{
-	if (width == 0) {
-		return precision < 0 ?
-			FMT_SWPRINTF(buffer, size, format, value) :
-			FMT_SWPRINTF(buffer, size, format, precision, value);
-	}
-	return precision < 0 ?
-		FMT_SWPRINTF(buffer, size, format, width, value) :
-		FMT_SWPRINTF(buffer, size, format, width, precision, value);
-}
-
-template <typename T>
-const char fmt::internal::BasicData<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 * 1000000000
-
-template <typename T>
-const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
-	0, FMT_POWERS_OF_10(1)
-};
-
-template <typename T>
-const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
-	0,
-	FMT_POWERS_OF_10(1),
-	FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),
-	// Multiply several constants instead of using a single long long constant
-	// to avoid warnings about C++98 not supporting long long.
-	fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10
-};
-
-FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type)
-{
-	(void)type;
-	if (std::isprint(static_cast<unsigned char>(code))) {
-		FMT_THROW(fmt::FormatError(
-			fmt::format("unknown format code '{}' for {}", code, type)));
-	}
-	FMT_THROW(fmt::FormatError(
-		fmt::format("unknown format code '\\x{:02x}' for {}",
-			static_cast<unsigned>(code), type)));
-}
-
-#if FMT_USE_WINDOWS_H
-
-FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s)
-{
-	static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
-	if (s.size() > INT_MAX)
-		FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
-	int s_size = static_cast<int>(s.size());
-	int length = MultiByteToWideChar(
-		CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);
-	if (length == 0)
-		FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
-	buffer_.resize(length + 1);
-	length = MultiByteToWideChar(
-		CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
-	if (length == 0)
-		FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
-	buffer_[length] = 0;
-}
-
-FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s)
-{
-	if (int error_code = convert(s)) {
-		FMT_THROW(WindowsError(error_code,
-			"cannot convert string from UTF-16 to UTF-8"));
-	}
-}
-
-FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s)
-{
-	if (s.size() > INT_MAX)
-		return ERROR_INVALID_PARAMETER;
-	int s_size = static_cast<int>(s.size());
-	int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);
-	if (length == 0)
-		return GetLastError();
-	buffer_.resize(length + 1);
-	length = WideCharToMultiByte(
-		CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);
-	if (length == 0)
-		return GetLastError();
-	buffer_[length] = 0;
-	return 0;
-}
-
-FMT_FUNC void fmt::WindowsError::init(
-	int err_code, CStringRef format_str, ArgList args)
-{
-	error_code_ = err_code;
-	MemoryWriter w;
-	internal::format_windows_error(w, err_code, format(format_str, args));
-	std::runtime_error &base = *this;
-	base = std::runtime_error(w.str());
-}
-
-FMT_FUNC void fmt::internal::format_windows_error(
-	fmt::Writer &out, int error_code,
-	fmt::StringRef message) FMT_NOEXCEPT
-{
-	FMT_TRY{
-		MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;
-	buffer.resize(INLINE_BUFFER_SIZE);
-	for (;;) {
-		wchar_t *system_message = &buffer[0];
-		int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-			0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-			system_message, static_cast<uint32_t>(buffer.size()), 0);
-		if (result != 0) {
-			UTF16ToUTF8 utf8_message;
-			if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
-				out << message << ": " << utf8_message;
-				return;
-			}
-			break;
-		}
-		if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-			break;  // Can't get error message, report error code instead.
-		buffer.resize(buffer.size() * 2);
-	}
-	} FMT_CATCH(...)
-	{}
-	fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
-}
-
-#endif  // FMT_USE_WINDOWS_H
-
-FMT_FUNC void fmt::internal::format_system_error(
-	fmt::Writer &out, int error_code,
-	fmt::StringRef message) FMT_NOEXCEPT
-{
-	FMT_TRY{
-		MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
-	buffer.resize(INLINE_BUFFER_SIZE);
-	for (;;) {
-		char *system_message = &buffer[0];
-		int result = safe_strerror(error_code, system_message, buffer.size());
-		if (result == 0) {
-			out << message << ": " << system_message;
-			return;
-		}
-		if (result != ERANGE)
-			break;  // Can't get error message, report error code instead.
-		buffer.resize(buffer.size() * 2);
-	}
-	} FMT_CATCH(...)
-	{}
-	fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
-}
-
-template <typename Char>
-void fmt::internal::ArgMap<Char>::init(const ArgList &args)
-{
-	if (!map_.empty())
-		return;
-	typedef internal::NamedArg<Char> NamedArg;
-	const NamedArg *named_arg = 0;
-	bool use_values =
-		args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
-	if (use_values) {
-		for (unsigned i = 0;/*nothing*/; ++i) {
-			internal::Arg::Type arg_type = args.type(i);
-			switch (arg_type) {
-			case internal::Arg::NONE:
-				return;
-			case internal::Arg::NAMED_ARG:
-				named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
-				map_.push_back(Pair(named_arg->name, *named_arg));
-				break;
-			default:
-				/*nothing*/;
-			}
-		}
-		return;
-	}
-	for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
-		internal::Arg::Type arg_type = args.type(i);
-		if (arg_type == internal::Arg::NAMED_ARG) {
-			named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
-			map_.push_back(Pair(named_arg->name, *named_arg));
-		}
-	}
-	for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
-		switch (args.args_[i].type) {
-		case internal::Arg::NONE:
-			return;
-		case internal::Arg::NAMED_ARG:
-			named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
-			map_.push_back(Pair(named_arg->name, *named_arg));
-			break;
-		default:
-			/*nothing*/;
-		}
-	}
-}
-
-template <typename Char>
-void fmt::internal::FixedBuffer<Char>::grow(std::size_t)
-{
-	FMT_THROW(std::runtime_error("buffer overflow"));
-}
-
-FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
-	unsigned arg_index, const char *&error)
-{
-	Arg arg = args_[arg_index];
-	switch (arg.type) {
-	case Arg::NONE:
-		error = "argument index out of range";
-		break;
-	case Arg::NAMED_ARG:
-		arg = *static_cast<const internal::Arg*>(arg.pointer);
-		break;
-	default:
-		/*nothing*/;
-	}
-	return arg;
-}
-
-template <typename Char>
-void fmt::internal::PrintfFormatter<Char>::parse_flags(
-	FormatSpec &spec, const Char *&s)
-{
-	for (;;) {
-		switch (*s++) {
-		case '-':
-			spec.align_ = ALIGN_LEFT;
-			break;
-		case '+':
-			spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
-			break;
-		case '0':
-			spec.fill_ = '0';
-			break;
-		case ' ':
-			spec.flags_ |= SIGN_FLAG;
-			break;
-		case '#':
-			spec.flags_ |= HASH_FLAG;
-			break;
-		default:
-			--s;
-			return;
-		}
-	}
-}
-
-template <typename Char>
-Arg fmt::internal::PrintfFormatter<Char>::get_arg(
-	const Char *s, unsigned arg_index)
-{
-	(void)s;
-	const char *error = 0;
-	Arg arg = arg_index == UINT_MAX ?
-		next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
-	if (error)
-		FMT_THROW(FormatError(!*s ? "invalid format string" : error));
-	return arg;
-}
-
-template <typename Char>
-unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
-	const Char *&s, FormatSpec &spec)
-{
-	unsigned arg_index = UINT_MAX;
-	Char c = *s;
-	if (c >= '0' && c <= '9') {
-		// Parse an argument index (if followed by '$') or a width possibly
-		// preceded with '0' flag(s).
-		unsigned value = parse_nonnegative_int(s);
-		if (*s == '$') {  // value is an argument index
-			++s;
-			arg_index = value;
-		}
-		else {
-			if (c == '0')
-				spec.fill_ = '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;
-				return arg_index;
-			}
-		}
-	}
-	parse_flags(spec, s);
-	// Parse width.
-	if (*s >= '0' && *s <= '9') {
-		spec.width_ = parse_nonnegative_int(s);
-	}
-	else if (*s == '*') {
-		++s;
-		spec.width_ = WidthHandler(spec).visit(get_arg(s));
-	}
-	return arg_index;
-}
-
-template <typename Char>
-void fmt::internal::PrintfFormatter<Char>::format(
-	BasicWriter<Char> &writer, BasicCStringRef<Char> format_str)
-{
-	const Char *start = format_str.c_str();
-	const Char *s = start;
-	while (*s) {
-		Char c = *s++;
-		if (c != '%') continue;
-		if (*s == c) {
-			write(writer, start, s);
-			start = ++s;
-			continue;
-		}
-		write(writer, start, s - 1);
-
-		FormatSpec spec;
-		spec.align_ = ALIGN_RIGHT;
-
-		// Parse argument index, flags and width.
-		unsigned arg_index = parse_header(s, spec);
-
-		// Parse precision.
-		if (*s == '.') {
-			++s;
-			if ('0' <= *s && *s <= '9') {
-				spec.precision_ = static_cast<int>(parse_nonnegative_int(s));
-			}
-			else if (*s == '*') {
-				++s;
-				spec.precision_ = PrecisionHandler().visit(get_arg(s));
-			}
-		}
-
-		Arg arg = get_arg(s, arg_index);
-		if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg))
-			spec.flags_ &= ~to_unsigned<int>(HASH_FLAG);
-		if (spec.fill_ == '0') {
-			if (arg.type <= Arg::LAST_NUMERIC_TYPE)
-				spec.align_ = ALIGN_NUMERIC;
-			else
-				spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
-		}
-
-		// Parse length and convert the argument to the required type.
-		switch (*s++) {
-		case 'h':
-			if (*s == 'h')
-				ArgConverter<signed char>(arg, *++s).visit(arg);
-			else
-				ArgConverter<short>(arg, *s).visit(arg);
-			break;
-		case 'l':
-			if (*s == 'l')
-				ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
-			else
-				ArgConverter<long>(arg, *s).visit(arg);
-			break;
-		case 'j':
-			ArgConverter<intmax_t>(arg, *s).visit(arg);
-			break;
-		case 'z':
-			ArgConverter<std::size_t>(arg, *s).visit(arg);
-			break;
-		case 't':
-			ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
-			break;
-		case 'L':
-			// printf produces garbage when 'L' is omitted for long double, no
-			// need to do the same.
-			break;
-		default:
-			--s;
-			ArgConverter<void>(arg, *s).visit(arg);
-		}
-
-		// Parse type.
-		if (!*s)
-			FMT_THROW(FormatError("invalid format string"));
-		spec.type_ = static_cast<char>(*s++);
-		if (arg.type <= Arg::LAST_INTEGER_TYPE) {
-			// Normalize type.
-			switch (spec.type_) {
-			case 'i': case 'u':
-				spec.type_ = 'd';
-				break;
-			case 'c':
-				// TODO: handle wchar_t
-				CharConverter(arg).visit(arg);
-				break;
-			}
-		}
-
-		start = s;
-
-		// Format argument.
-		internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);
-	}
-	write(writer, start, s);
-}
-
-FMT_FUNC void fmt::report_system_error(
-	int error_code, fmt::StringRef message) FMT_NOEXCEPT
-{
-	// 'fmt::' is for bcc32.
-	fmt::report_error(internal::format_system_error, error_code, message);
-}
-
-#if FMT_USE_WINDOWS_H
-FMT_FUNC void fmt::report_windows_error(
-	int error_code, fmt::StringRef message) FMT_NOEXCEPT
-{
-	// 'fmt::' is for bcc32.
-	fmt::report_error(internal::format_windows_error, error_code, message);
-}
-#endif
-
-FMT_FUNC void fmt::print(std::FILE *f, CStringRef format_str, ArgList args)
-{
-	MemoryWriter w;
-	w.write(format_str, args);
-	std::fwrite(w.data(), 1, w.size(), f);
-}
-
-FMT_FUNC void fmt::print(CStringRef format_str, ArgList args)
-{
-	print(stdout, format_str, args);
-}
-
-FMT_FUNC void fmt::print(std::ostream &os, CStringRef format_str,
-	ArgList args)
-{
-	MemoryWriter w;
-	w.write(format_str, args);
-	write(os, w);
-}
-
-FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args)
-{
-	char escape[] = "\x1b[30m";
-	escape[3] = static_cast<char>('0' + c);
-	std::fputs(escape, stdout);
-	print(format, args);
-	std::fputs(RESET_COLOR, stdout);
-}
-
-FMT_FUNC int fmt::fprintf(std::FILE *f, CStringRef format, ArgList args)
-{
-	MemoryWriter w;
-	printf(w, format, args);
-	std::size_t size = w.size();
-	return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
-}
-
-FMT_FUNC int fmt::fprintf(std::ostream &os, CStringRef format, ArgList args)
-{
-	MemoryWriter w;
-	printf(w, format, args);
-	write(os, w);
-	return static_cast<int>(w.size());
-}
-
-#ifndef FMT_HEADER_ONLY
-
-template struct fmt::internal::BasicData<void>;
-
-// Explicit instantiations for char.
-
-template void fmt::internal::FixedBuffer<char>::grow(std::size_t);
-
-template void fmt::internal::ArgMap<char>::init(const fmt::ArgList &args);
-
-template void fmt::internal::PrintfFormatter<char>::format(
-	BasicWriter<char> &writer, CStringRef format);
-
-template int fmt::internal::CharTraits<char>::format_float(
-	char *buffer, std::size_t size, const char *format,
-	unsigned width, int precision, double value);
-
-template int fmt::internal::CharTraits<char>::format_float(
-	char *buffer, std::size_t size, const char *format,
-	unsigned width, int precision, long double value);
-
-// Explicit instantiations for wchar_t.
-
-template void fmt::internal::FixedBuffer<wchar_t>::grow(std::size_t);
-
-template void fmt::internal::ArgMap<wchar_t>::init(const fmt::ArgList &args);
-
-template void fmt::internal::PrintfFormatter<wchar_t>::format(
-	BasicWriter<wchar_t> &writer, WCStringRef format);
-
-template int fmt::internal::CharTraits<wchar_t>::format_float(
-	wchar_t *buffer, std::size_t size, const wchar_t *format,
-	unsigned width, int precision, double value);
-
-template int fmt::internal::CharTraits<wchar_t>::format_float(
-	wchar_t *buffer, std::size_t size, const wchar_t *format,
-	unsigned width, int precision, long double value);
-
-#endif  // FMT_HEADER_ONLY
-
-#ifdef _MSC_VER
-# pragma warning(pop)
+/*

+Formatting library for C++

+

+Copyright (c) 2012 - 2015, Victor Zverovich

+All rights reserved.

+

+Redistribution and use in source and binary forms, with or without

+modification, are permitted provided that the following conditions are met:

+

+1. Redistributions of source code must retain the above copyright notice, this

+list of conditions and the following disclaimer.

+2. Redistributions in binary form must reproduce the above copyright notice,

+this list of conditions and the following disclaimer in the documentation

+and/or other materials provided with the distribution.

+

+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR

+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+*/

+

+#include "format.h"

+

+#include <string.h>

+

+#include <cctype>

+#include <cerrno>

+#include <climits>

+#include <cmath>

+#include <cstdarg>

+#include <cstddef>  // for std::ptrdiff_t

+

+#if defined(_WIN32) && defined(__MINGW32__)

+# include <cstring>

+#endif

+

+#if FMT_USE_WINDOWS_H

+# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)

+#  include <windows.h>

+# else

+#  define NOMINMAX

+#  include <windows.h>

+#  undef NOMINMAX

+# endif

+#endif

+

+using fmt::internal::Arg;

+

+#if FMT_EXCEPTIONS

+# define FMT_TRY try

+# define FMT_CATCH(x) catch (x)

+#else

+# define FMT_TRY if (true)

+# define FMT_CATCH(x) if (false)

+#endif

+

+#ifdef FMT_HEADER_ONLY

+# define FMT_FUNC inline

+#else

+# define FMT_FUNC

+#endif

+

+#ifdef _MSC_VER

+# pragma warning(push)

+# pragma warning(disable: 4127)  // conditional expression is constant

+# 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)

+#endif

+

+// Dummy implementations of strerror_r and strerror_s called if corresponding

+// system functions are not available.

+static inline fmt::internal::Null<> strerror_r(int, char *, ...)

+{

+	return fmt::internal::Null<>();

+}

+static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...)

+{

+	return fmt::internal::Null<>();

+}

+

+namespace fmt {

+	namespace {

+

+#ifndef _MSC_VER

+# define FMT_SNPRINTF snprintf

+#else  // _MSC_VER

+		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

+#endif  // _MSC_VER

+

+#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)

+# define FMT_SWPRINTF snwprintf

+#else

+# define FMT_SWPRINTF swprintf

+#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)

+

+		// Checks if a value fits in int - used to avoid warnings about comparing

+		// signed and unsigned integers.

+		template <bool IsSigned>

+		struct IntChecker

+		{

+			template <typename T>

+			static bool fits_in_int(T value)

+			{

+				unsigned max = INT_MAX;

+				return value <= max;

+			}

+			static bool fits_in_int(bool)

+			{

+				return true;

+			}

+		};

+

+		template <>

+		struct IntChecker<true>

+		{

+			template <typename T>

+			static bool fits_in_int(T value)

+			{

+				return value >= INT_MIN && value <= INT_MAX;

+			}

+			static bool fits_in_int(int)

+			{

+				return true;

+			}

+		};

+

+		const char RESET_COLOR[] = "\x1b[0m";

+

+		typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef);

+

+		// Portable thread-safe version of strerror.

+		// Sets buffer to point to a string describing the error code.

+		// This can be either a pointer to a string stored in buffer,

+		// or a pointer to some static immutable string.

+		// Returns one of the following values:

+		//   0      - success

+		//   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

+		{

+			FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");

+

+			class StrError

+			{

+			private:

+				int error_code_;

+				char *&buffer_;

+				std::size_t buffer_size_;

+

+				// A noop assignment operator to avoid bogus warnings.

+				void operator=(const StrError &)

+				{}

+

+				// Handle the result of XSI-compliant version of strerror_r.

+				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)

+				{

+					// If the buffer is full then the message is probably truncated.

+					if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)

+						return ERANGE;

+					buffer_ = message;

+					return 0;

+				}

+

+				// Handle the case when strerror_r is not available.

+				int handle(fmt::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)

+				{

+					// If the buffer is full then the message is probably truncated.

+					return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?

+						ERANGE : result;

+				}

+

+				// Fallback to strerror if strerror_r and strerror_s are not available.

+				int fallback(fmt::internal::Null<>)

+				{

+					errno = 0;

+					buffer_ = strerror(error_code_);

+					return errno;

+				}

+

+			public:

+				StrError(int err_code, char *&buf, std::size_t buf_size)

+					: error_code_(err_code), buffer_(buf), buffer_size_(buf_size)

+				{}

+

+				int run()

+				{

+					strerror_r(0, 0, "");  // Suppress a warning about unused strerror_r.

+					return handle(strerror_r(error_code_, buffer_, buffer_size_));

+				}

+			};

+			return StrError(error_code, buffer, buffer_size).run();

+		}

+

+		void format_error_code(fmt::Writer &out, int error_code,

+			fmt::StringRef 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.

+			out.clear();

+			static const char SEP[] = ": ";

+			static const char ERROR_STR[] = "error ";

+			// Subtract 2 to account for terminating null characters in SEP and ERROR_STR.

+			std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;

+			typedef fmt::internal::IntTraits<int>::MainType MainType;

+			MainType abs_value = static_cast<MainType>(error_code);

+			if (internal::is_negative(error_code)) {

+				abs_value = 0 - abs_value;

+				++error_code_size;

+			}

+			error_code_size += fmt::internal::count_digits(abs_value);

+			if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)

+				out << message << SEP;

+			out << ERROR_STR << error_code;

+			assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);

+		}

+

+		void report_error(FormatFunc func,

+			int error_code, fmt::StringRef message) FMT_NOEXCEPT

+		{

+			fmt::MemoryWriter full_message;

+			func(full_message, error_code, message);

+			// Use Writer::data instead of Writer::c_str to avoid potential memory

+			// allocation.

+			std::fwrite(full_message.data(), full_message.size(), 1, stderr);

+			std::fputc('\n', stderr);

+		}

+

+		// IsZeroInt::visit(arg) returns true iff arg is a zero integer.

+		class IsZeroInt: public fmt::internal::ArgVisitor<IsZeroInt, bool>

+		{

+		public:

+			template <typename T>

+			bool visit_any_int(T value)

+			{

+				return value == 0;

+			}

+		};

+

+		// Checks if an argument is a valid printf width specifier and sets

+		// left alignment if it is negative.

+		class WidthHandler: public fmt::internal::ArgVisitor<WidthHandler, unsigned>

+		{

+		private:

+			fmt::FormatSpec &spec_;

+

+			FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);

+

+		public:

+			explicit WidthHandler(fmt::FormatSpec &spec): spec_(spec)

+			{}

+

+			void report_unhandled_arg()

+			{

+				FMT_THROW(fmt::FormatError("width is not integer"));

+			}

+

+			template <typename T>

+			unsigned visit_any_int(T value)

+			{

+				typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType;

+				UnsignedType width = static_cast<UnsignedType>(value);

+				if (fmt::internal::is_negative(value)) {

+					spec_.align_ = fmt::ALIGN_LEFT;

+					width = 0 - width;

+				}

+				if (width > INT_MAX)

+					FMT_THROW(fmt::FormatError("number is too big"));

+				return static_cast<unsigned>(width);

+			}

+		};

+

+		class PrecisionHandler:

+			public fmt::internal::ArgVisitor<PrecisionHandler, int>

+		{

+		public:

+			void report_unhandled_arg()

+			{

+				FMT_THROW(fmt::FormatError("precision is not integer"));

+			}

+

+			template <typename T>

+			int visit_any_int(T value)

+			{

+				if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))

+					FMT_THROW(fmt::FormatError("number is too big"));

+				return static_cast<int>(value);

+			}

+		};

+

+		template <typename T, typename U>

+		struct is_same

+		{

+			enum

+			{

+				value = 0

+			};

+		};

+

+		template <typename T>

+		struct is_same<T, T>

+		{

+			enum

+			{

+				value = 1

+			};

+		};

+

+		// An argument visitor that converts an integer argument to T for printf,

+		// if T is an integral type. 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 = void>

+		class ArgConverter: public fmt::internal::ArgVisitor<ArgConverter<T>, void>

+		{

+		private:

+			fmt::internal::Arg &arg_;

+			wchar_t type_;

+

+			FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);

+

+		public:

+			ArgConverter(fmt::internal::Arg &arg, wchar_t type)

+				: arg_(arg), type_(type)

+			{}

+

+			void visit_bool(bool value)

+			{

+				if (type_ != 's')

+					visit_any_int(value);

+			}

+

+			template <typename U>

+			void visit_any_int(U value)

+			{

+				bool is_signed = type_ == 'd' || type_ == 'i';

+				using fmt::internal::Arg;

+				typedef typename fmt::internal::Conditional<

+					is_same<T, void>::value, U, T>::type TargetType;

+				if (sizeof(TargetType) <= sizeof(int)) {

+					// Extra casts are used to silence warnings.

+					if (is_signed) {

+						arg_.type = Arg::INT;

+						arg_.int_value = static_cast<int>(static_cast<TargetType>(value));

+					}

+					else {

+						arg_.type = Arg::UINT;

+						typedef typename fmt::internal::MakeUnsigned<TargetType>::Type Unsigned;

+						arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));

+					}

+				}

+				else {

+					if (is_signed) {

+						arg_.type = Arg::LONG_LONG;

+						// 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_.long_long_value = static_cast<fmt::LongLong>(value);

+					}

+					else {

+						arg_.type = Arg::ULONG_LONG;

+						arg_.ulong_long_value =

+							static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);

+					}

+				}

+			}

+		};

+

+		// Converts an integer argument to char for printf.

+		class CharConverter: public fmt::internal::ArgVisitor<CharConverter, void>

+		{

+		private:

+			fmt::internal::Arg &arg_;

+

+			FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);

+

+		public:

+			explicit CharConverter(fmt::internal::Arg &arg): arg_(arg)

+			{}

+

+			template <typename T>

+			void visit_any_int(T value)

+			{

+				arg_.type = Arg::CHAR;

+				arg_.int_value = static_cast<char>(value);

+			}

+		};

+

+		// Write the content of w to os.

+		void write(std::ostream &os, fmt::Writer &w)

+		{

+			const char *data = w.data();

+			typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;

+			UnsignedStreamSize size = w.size();

+			UnsignedStreamSize max_size =

+				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;

+				size -= n;

+			} while (size != 0);

+		}

+	}  // namespace

+

+	namespace internal {

+

+		template <typename Char>

+		class PrintfArgFormatter:

+			public ArgFormatterBase<PrintfArgFormatter<Char>, Char>

+		{

+

+			void write_null_pointer()

+			{

+				this->spec().type_ = 0;

+				this->write("(nil)");

+			}

+

+			typedef ArgFormatterBase<PrintfArgFormatter<Char>, Char> Base;

+

+		public:

+			PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)

+				: ArgFormatterBase<PrintfArgFormatter<Char>, Char>(w, s)

+			{}

+

+			void visit_bool(bool value)

+			{

+				FormatSpec &fmt_spec = this->spec();

+				if (fmt_spec.type_ != 's')

+					return this->visit_any_int(value);

+				fmt_spec.type_ = 0;

+				this->write(value);

+			}

+

+			void visit_char(int value)

+			{

+				const FormatSpec &fmt_spec = this->spec();

+				BasicWriter<Char> &w = this->writer();

+				if (fmt_spec.type_ && fmt_spec.type_ != 'c')

+					w.write_int(value, fmt_spec);

+				typedef typename BasicWriter<Char>::CharPtr CharPtr;

+				CharPtr out = CharPtr();

+				if (fmt_spec.width_ > 1) {

+					Char fill = ' ';

+					out = w.grow_buffer(fmt_spec.width_);

+					if (fmt_spec.align_ != ALIGN_LEFT) {

+						std::fill_n(out, fmt_spec.width_ - 1, fill);

+						out += fmt_spec.width_ - 1;

+					}

+					else {

+						std::fill_n(out + 1, fmt_spec.width_ - 1, fill);

+					}

+				}

+				else {

+					out = w.grow_buffer(1);

+				}

+				*out = static_cast<Char>(value);

+			}

+

+			void visit_cstring(const char *value)

+			{

+				if (value)

+					Base::visit_cstring(value);

+				else if (this->spec().type_ == 'p')

+					write_null_pointer();

+				else

+					this->write("(null)");

+			}

+

+			void visit_pointer(const void *value)

+			{

+				if (value)

+					return Base::visit_pointer(value);

+				this->spec().type_ = 0;

+				write_null_pointer();

+			}

+

+			void visit_custom(Arg::CustomValue c)

+			{

+				BasicFormatter<Char> formatter(ArgList(), this->writer());

+				const Char format_str[] = { '}', 0 };

+				const Char *format = format_str;

+				c.format(&formatter, c.value, &format);

+			}

+		};

+	}  // namespace internal

+}  // namespace fmt

+

+FMT_FUNC void fmt::SystemError::init(

+	int err_code, CStringRef format_str, ArgList args)

+{

+	error_code_ = err_code;

+	MemoryWriter w;

+	internal::format_system_error(w, err_code, format(format_str, args));

+	std::runtime_error &base = *this;

+	base = std::runtime_error(w.str());

+}

+

+template <typename T>

+int fmt::internal::CharTraits<char>::format_float(

+	char *buffer, std::size_t size, const char *format,

+	unsigned width, int precision, T value)

+{

+	if (width == 0) {

+		return precision < 0 ?

+			FMT_SNPRINTF(buffer, size, format, value) :

+			FMT_SNPRINTF(buffer, size, format, precision, value);

+	}

+	return precision < 0 ?

+		FMT_SNPRINTF(buffer, size, format, width, value) :

+		FMT_SNPRINTF(buffer, size, format, width, precision, value);

+}

+

+template <typename T>

+int fmt::internal::CharTraits<wchar_t>::format_float(

+	wchar_t *buffer, std::size_t size, const wchar_t *format,

+	unsigned width, int precision, T value)

+{

+	if (width == 0) {

+		return precision < 0 ?

+			FMT_SWPRINTF(buffer, size, format, value) :

+			FMT_SWPRINTF(buffer, size, format, precision, value);

+	}

+	return precision < 0 ?

+		FMT_SWPRINTF(buffer, size, format, width, value) :

+		FMT_SWPRINTF(buffer, size, format, width, precision, value);

+}

+

+template <typename T>

+const char fmt::internal::BasicData<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 * 1000000000

+

+template <typename T>

+const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {

+	0, FMT_POWERS_OF_10(1)

+};

+

+template <typename T>

+const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {

+	0,

+	FMT_POWERS_OF_10(1),

+	FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),

+	// Multiply several constants instead of using a single long long constant

+	// to avoid warnings about C++98 not supporting long long.

+	fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10

+};

+

+FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type)

+{

+	(void)type;

+	if (std::isprint(static_cast<unsigned char>(code))) {

+		FMT_THROW(fmt::FormatError(

+			fmt::format("unknown format code '{}' for {}", code, type)));

+	}

+	FMT_THROW(fmt::FormatError(

+		fmt::format("unknown format code '\\x{:02x}' for {}",

+			static_cast<unsigned>(code), type)));

+}

+

+#if FMT_USE_WINDOWS_H

+

+FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s)

+{

+	static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";

+	if (s.size() > INT_MAX)

+		FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));

+	int s_size = static_cast<int>(s.size());

+	int length = MultiByteToWideChar(

+		CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);

+	if (length == 0)

+		FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));

+	buffer_.resize(length + 1);

+	length = MultiByteToWideChar(

+		CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);

+	if (length == 0)

+		FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));

+	buffer_[length] = 0;

+}

+

+FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s)

+{

+	if (int error_code = convert(s)) {

+		FMT_THROW(WindowsError(error_code,

+			"cannot convert string from UTF-16 to UTF-8"));

+	}

+}

+

+FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s)

+{

+	if (s.size() > INT_MAX)

+		return ERROR_INVALID_PARAMETER;

+	int s_size = static_cast<int>(s.size());

+	int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);

+	if (length == 0)

+		return GetLastError();

+	buffer_.resize(length + 1);

+	length = WideCharToMultiByte(

+		CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);

+	if (length == 0)

+		return GetLastError();

+	buffer_[length] = 0;

+	return 0;

+}

+

+FMT_FUNC void fmt::WindowsError::init(

+	int err_code, CStringRef format_str, ArgList args)

+{

+	error_code_ = err_code;

+	MemoryWriter w;

+	internal::format_windows_error(w, err_code, format(format_str, args));

+	std::runtime_error &base = *this;

+	base = std::runtime_error(w.str());

+}

+

+FMT_FUNC void fmt::internal::format_windows_error(

+	fmt::Writer &out, int error_code,

+	fmt::StringRef message) FMT_NOEXCEPT

+{

+	FMT_TRY{

+		MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;

+	buffer.resize(INLINE_BUFFER_SIZE);

+	for (;;) {

+		wchar_t *system_message = &buffer[0];

+		int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,

+			0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

+			system_message, static_cast<uint32_t>(buffer.size()), 0);

+		if (result != 0) {

+			UTF16ToUTF8 utf8_message;

+			if (utf8_message.convert(system_message) == ERROR_SUCCESS) {

+				out << message << ": " << utf8_message;

+				return;

+			}

+			break;

+		}

+		if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)

+			break;  // Can't get error message, report error code instead.

+		buffer.resize(buffer.size() * 2);

+	}

+	} FMT_CATCH(...)

+	{}

+	fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.

+}

+

+#endif  // FMT_USE_WINDOWS_H

+

+FMT_FUNC void fmt::internal::format_system_error(

+	fmt::Writer &out, int error_code,

+	fmt::StringRef message) FMT_NOEXCEPT

+{

+	FMT_TRY{

+		MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;

+	buffer.resize(INLINE_BUFFER_SIZE);

+	for (;;) {

+		char *system_message = &buffer[0];

+		int result = safe_strerror(error_code, system_message, buffer.size());

+		if (result == 0) {

+			out << message << ": " << system_message;

+			return;

+		}

+		if (result != ERANGE)

+			break;  // Can't get error message, report error code instead.

+		buffer.resize(buffer.size() * 2);

+	}

+	} FMT_CATCH(...)

+	{}

+	fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.

+}

+

+template <typename Char>

+void fmt::internal::ArgMap<Char>::init(const ArgList &args)

+{

+	if (!map_.empty())

+		return;

+	typedef internal::NamedArg<Char> NamedArg;

+	const NamedArg *named_arg = 0;

+	bool use_values =

+		args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;

+	if (use_values) {

+		for (unsigned i = 0;/*nothing*/; ++i) {

+			internal::Arg::Type arg_type = args.type(i);

+			switch (arg_type) {

+			case internal::Arg::NONE:

+				return;

+			case internal::Arg::NAMED_ARG:

+				named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);

+				map_.push_back(Pair(named_arg->name, *named_arg));

+				break;

+			default:

+				/*nothing*/;

+			}

+		}

+		return;

+	}

+	for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {

+		internal::Arg::Type arg_type = args.type(i);

+		if (arg_type == internal::Arg::NAMED_ARG) {

+			named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);

+			map_.push_back(Pair(named_arg->name, *named_arg));

+		}

+	}

+	for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {

+		switch (args.args_[i].type) {

+		case internal::Arg::NONE:

+			return;

+		case internal::Arg::NAMED_ARG:

+			named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);

+			map_.push_back(Pair(named_arg->name, *named_arg));

+			break;

+		default:

+			/*nothing*/;

+		}

+	}

+}

+

+template <typename Char>

+void fmt::internal::FixedBuffer<Char>::grow(std::size_t)

+{

+	FMT_THROW(std::runtime_error("buffer overflow"));

+}

+

+FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(

+	unsigned arg_index, const char *&error)

+{

+	Arg arg = args_[arg_index];

+	switch (arg.type) {

+	case Arg::NONE:

+		error = "argument index out of range";

+		break;

+	case Arg::NAMED_ARG:

+		arg = *static_cast<const internal::Arg*>(arg.pointer);

+		break;

+	default:

+		/*nothing*/;

+	}

+	return arg;

+}

+

+template <typename Char>

+void fmt::internal::PrintfFormatter<Char>::parse_flags(

+	FormatSpec &spec, const Char *&s)

+{

+	for (;;) {

+		switch (*s++) {

+		case '-':

+			spec.align_ = ALIGN_LEFT;

+			break;

+		case '+':

+			spec.flags_ |= SIGN_FLAG | PLUS_FLAG;

+			break;

+		case '0':

+			spec.fill_ = '0';

+			break;

+		case ' ':

+			spec.flags_ |= SIGN_FLAG;

+			break;

+		case '#':

+			spec.flags_ |= HASH_FLAG;

+			break;

+		default:

+			--s;

+			return;

+		}

+	}

+}

+

+template <typename Char>

+Arg fmt::internal::PrintfFormatter<Char>::get_arg(

+	const Char *s, unsigned arg_index)

+{

+	(void)s;

+	const char *error = 0;

+	Arg arg = arg_index == UINT_MAX ?

+		next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);

+	if (error)

+		FMT_THROW(FormatError(!*s ? "invalid format string" : error));

+	return arg;

+}

+

+template <typename Char>

+unsigned fmt::internal::PrintfFormatter<Char>::parse_header(

+	const Char *&s, FormatSpec &spec)

+{

+	unsigned arg_index = UINT_MAX;

+	Char c = *s;

+	if (c >= '0' && c <= '9') {

+		// Parse an argument index (if followed by '$') or a width possibly

+		// preceded with '0' flag(s).

+		unsigned value = parse_nonnegative_int(s);

+		if (*s == '$') {  // value is an argument index

+			++s;

+			arg_index = value;

+		}

+		else {

+			if (c == '0')

+				spec.fill_ = '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;

+				return arg_index;

+			}

+		}

+	}

+	parse_flags(spec, s);

+	// Parse width.

+	if (*s >= '0' && *s <= '9') {

+		spec.width_ = parse_nonnegative_int(s);

+	}

+	else if (*s == '*') {

+		++s;

+		spec.width_ = WidthHandler(spec).visit(get_arg(s));

+	}

+	return arg_index;

+}

+

+template <typename Char>

+void fmt::internal::PrintfFormatter<Char>::format(

+	BasicWriter<Char> &writer, BasicCStringRef<Char> format_str)

+{

+	const Char *start = format_str.c_str();

+	const Char *s = start;

+	while (*s) {

+		Char c = *s++;

+		if (c != '%') continue;

+		if (*s == c) {

+			write(writer, start, s);

+			start = ++s;

+			continue;

+		}

+		write(writer, start, s - 1);

+

+		FormatSpec spec;

+		spec.align_ = ALIGN_RIGHT;

+

+		// Parse argument index, flags and width.

+		unsigned arg_index = parse_header(s, spec);

+

+		// Parse precision.

+		if (*s == '.') {

+			++s;

+			if ('0' <= *s && *s <= '9') {

+				spec.precision_ = static_cast<int>(parse_nonnegative_int(s));

+			}

+			else if (*s == '*') {

+				++s;

+				spec.precision_ = PrecisionHandler().visit(get_arg(s));

+			}

+		}

+

+		Arg arg = get_arg(s, arg_index);

+		if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg))

+			spec.flags_ &= ~to_unsigned<int>(HASH_FLAG);

+		if (spec.fill_ == '0') {

+			if (arg.type <= Arg::LAST_NUMERIC_TYPE)

+				spec.align_ = ALIGN_NUMERIC;

+			else

+				spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.

+		}

+

+		// Parse length and convert the argument to the required type.

+		switch (*s++) {

+		case 'h':

+			if (*s == 'h')

+				ArgConverter<signed char>(arg, *++s).visit(arg);

+			else

+				ArgConverter<short>(arg, *s).visit(arg);

+			break;

+		case 'l':

+			if (*s == 'l')

+				ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);

+			else

+				ArgConverter<long>(arg, *s).visit(arg);

+			break;

+		case 'j':

+			ArgConverter<intmax_t>(arg, *s).visit(arg);

+			break;

+		case 'z':

+			ArgConverter<std::size_t>(arg, *s).visit(arg);

+			break;

+		case 't':

+			ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);

+			break;

+		case 'L':

+			// printf produces garbage when 'L' is omitted for long double, no

+			// need to do the same.

+			break;

+		default:

+			--s;

+			ArgConverter<void>(arg, *s).visit(arg);

+		}

+

+		// Parse type.

+		if (!*s)

+			FMT_THROW(FormatError("invalid format string"));

+		spec.type_ = static_cast<char>(*s++);

+		if (arg.type <= Arg::LAST_INTEGER_TYPE) {

+			// Normalize type.

+			switch (spec.type_) {

+			case 'i': case 'u':

+				spec.type_ = 'd';

+				break;

+			case 'c':

+				// TODO: handle wchar_t

+				CharConverter(arg).visit(arg);

+				break;

+			}

+		}

+

+		start = s;

+

+		// Format argument.

+		internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);

+	}

+	write(writer, start, s);

+}

+

+FMT_FUNC void fmt::report_system_error(

+	int error_code, fmt::StringRef message) FMT_NOEXCEPT

+{

+	// 'fmt::' is for bcc32.

+	fmt::report_error(internal::format_system_error, error_code, message);

+}

+

+#if FMT_USE_WINDOWS_H

+FMT_FUNC void fmt::report_windows_error(

+	int error_code, fmt::StringRef message) FMT_NOEXCEPT

+{

+	// 'fmt::' is for bcc32.

+	fmt::report_error(internal::format_windows_error, error_code, message);

+}

+#endif

+

+FMT_FUNC void fmt::print(std::FILE *f, CStringRef format_str, ArgList args)

+{

+	MemoryWriter w;

+	w.write(format_str, args);

+	std::fwrite(w.data(), 1, w.size(), f);

+}

+

+FMT_FUNC void fmt::print(CStringRef format_str, ArgList args)

+{

+	print(stdout, format_str, args);

+}

+

+FMT_FUNC void fmt::print(std::ostream &os, CStringRef format_str,

+	ArgList args)

+{

+	MemoryWriter w;

+	w.write(format_str, args);

+	write(os, w);

+}

+

+FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args)

+{

+	char escape[] = "\x1b[30m";

+	escape[3] = static_cast<char>('0' + c);

+	std::fputs(escape, stdout);

+	print(format, args);

+	std::fputs(RESET_COLOR, stdout);

+}

+

+FMT_FUNC int fmt::fprintf(std::FILE *f, CStringRef format, ArgList args)

+{

+	MemoryWriter w;

+	printf(w, format, args);

+	std::size_t size = w.size();

+	return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);

+}

+

+FMT_FUNC int fmt::fprintf(std::ostream &os, CStringRef format, ArgList args)

+{

+	MemoryWriter w;

+	printf(w, format, args);

+	write(os, w);

+	return static_cast<int>(w.size());

+}

+

+#ifndef FMT_HEADER_ONLY

+

+template struct fmt::internal::BasicData<void>;

+

+// Explicit instantiations for char.

+

+template void fmt::internal::FixedBuffer<char>::grow(std::size_t);

+

+template void fmt::internal::ArgMap<char>::init(const fmt::ArgList &args);

+

+template void fmt::internal::PrintfFormatter<char>::format(

+	BasicWriter<char> &writer, CStringRef format);

+

+template int fmt::internal::CharTraits<char>::format_float(

+	char *buffer, std::size_t size, const char *format,

+	unsigned width, int precision, double value);

+

+template int fmt::internal::CharTraits<char>::format_float(

+	char *buffer, std::size_t size, const char *format,

+	unsigned width, int precision, long double value);

+

+// Explicit instantiations for wchar_t.

+

+template void fmt::internal::FixedBuffer<wchar_t>::grow(std::size_t);

+

+template void fmt::internal::ArgMap<wchar_t>::init(const fmt::ArgList &args);

+

+template void fmt::internal::PrintfFormatter<wchar_t>::format(

+	BasicWriter<wchar_t> &writer, WCStringRef format);

+

+template int fmt::internal::CharTraits<wchar_t>::format_float(

+	wchar_t *buffer, std::size_t size, const wchar_t *format,

+	unsigned width, int precision, double value);

+

+template int fmt::internal::CharTraits<wchar_t>::format_float(

+	wchar_t *buffer, std::size_t size, const wchar_t *format,

+	unsigned width, int precision, long double value);

+

+#endif  // FMT_HEADER_ONLY

+

+#ifdef _MSC_VER

+# pragma warning(pop)

 #endif
\ No newline at end of file
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index 5fe2bef2..f78ece8a 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -1,4360 +1,4500 @@
-/*
-Formatting library for C++
-
-Copyright (c) 2012 - 2015, Victor Zverovich
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-this list of conditions and the following disclaimer in the documentation
-and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef FMT_FORMAT_H_
-#define FMT_FORMAT_H_
-
-
-//Added to spdlog version for header only usage
-#define FMT_HEADER_ONLY
-
-//Added to spdlog version in order to avoid including windows.h
-#if !defined (FMT_USE_WINDOWS_H)
-#define FMT_USE_WINDOWS_H 0
-#endif
-
-#include <cassert>
-#include <cmath>
-#include <cstdio>
-#include <cstring>
-#include <limits>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <vector>
-#include <utility>
-
-#ifndef FMT_USE_IOSTREAMS
-# define FMT_USE_IOSTREAMS 1
-#endif
-
-#if FMT_USE_IOSTREAMS
-# include <ostream>
-#endif
-
-#ifdef _SECURE_SCL
-# define FMT_SECURE_SCL _SECURE_SCL
-#else
-# define FMT_SECURE_SCL 0
-#endif
-
-#if FMT_SECURE_SCL
-# include <iterator>
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER <= 1500
-typedef unsigned __int32 uint32_t;
-typedef unsigned __int64 uint64_t;
-typedef __int64          intmax_t;
-#else
-#include <stdint.h>
-#endif
-
-#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-# ifdef FMT_EXPORT
-#  define FMT_API __declspec(dllexport)
-# elif defined(FMT_SHARED)
-#  define FMT_API __declspec(dllimport)
-# endif
-#endif
-#ifndef FMT_API
-# define FMT_API
-#endif
-
-#ifdef __GNUC__
-# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-# define FMT_GCC_EXTENSION __extension__
-# if FMT_GCC_VERSION >= 406
-#  pragma GCC diagnostic push
-// Disable the warning about "long long" which is sometimes reported even
-// when using __extension__.
-#  pragma GCC diagnostic ignored "-Wlong-long"
-// Disable the warning about declaration shadowing because it affects too
-// many valid cases.
-#  pragma GCC diagnostic ignored "-Wshadow"
-// Disable the warning about implicit conversions that may change the sign of
-// an integer; silencing it otherwise would require many explicit casts.
-#  pragma GCC diagnostic ignored "-Wsign-conversion"
-# endif
-# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
-#  define FMT_HAS_GXX_CXX11 1
-# endif
-#else
-# define FMT_GCC_EXTENSION
-#endif
-
-#if defined(__clang__) && !defined(__INTEL_COMPILER)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdocumentation"
-#endif
-
-#ifdef __GNUC_LIBSTD__
-# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
-#endif
-
-#ifdef __has_feature
-# define FMT_HAS_FEATURE(x) __has_feature(x)
-#else
-# define FMT_HAS_FEATURE(x) 0
-#endif
-
-#ifdef __has_builtin
-# define FMT_HAS_BUILTIN(x) __has_builtin(x)
-#else
-# define FMT_HAS_BUILTIN(x) 0
-#endif
-
-#ifdef __has_cpp_attribute
-# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-# define FMT_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-#ifndef FMT_USE_VARIADIC_TEMPLATES
-// Variadic templates are available in GCC since version 4.4
-// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++
-// since version 2013.
-# define FMT_USE_VARIADIC_TEMPLATES \
-   (FMT_HAS_FEATURE(cxx_variadic_templates) || \
-       (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800)
-#endif
-
-#ifndef FMT_USE_RVALUE_REFERENCES
-// Don't use rvalue references when compiling with clang and an old libstdc++
-// as the latter doesn't provide std::move.
-# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402
-#  define FMT_USE_RVALUE_REFERENCES 0
-# else
-#  define FMT_USE_RVALUE_REFERENCES \
-    (FMT_HAS_FEATURE(cxx_rvalue_references) || \
-        (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600)
-# endif
-#endif
-
-#if FMT_USE_RVALUE_REFERENCES
-# include <utility>  // for std::move
-#endif
-
-// Check if exceptions are disabled.
-#if defined(__GNUC__) && !defined(__EXCEPTIONS)
-# define FMT_EXCEPTIONS 0
-#endif
-#if defined(_MSC_VER) && !_HAS_EXCEPTIONS
-# define FMT_EXCEPTIONS 0
-#endif
-#ifndef FMT_EXCEPTIONS
-# define FMT_EXCEPTIONS 1
-#endif
-
-#ifndef FMT_THROW
-# if FMT_EXCEPTIONS
-#  define FMT_THROW(x) throw x
-# else
-#  define FMT_THROW(x) assert(false)
-# endif
-#endif
-
-// Define FMT_USE_NOEXCEPT to make C++ Format use noexcept (C++11 feature).
-#ifndef FMT_USE_NOEXCEPT
-# define FMT_USE_NOEXCEPT 0
-#endif
-
-#ifndef FMT_NOEXCEPT
-# if FMT_EXCEPTIONS
-#  if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
-    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
-    _MSC_VER >= 1900
-#   define FMT_NOEXCEPT noexcept
-#  else
-#   define FMT_NOEXCEPT throw()
-#  endif
-# else
-#  define FMT_NOEXCEPT
-# endif
-#endif
-
-// A macro to disallow the copy constructor and operator= functions
-// This should be used in the private: declarations for a class
-#ifndef FMT_USE_DELETED_FUNCTIONS
-# define FMT_USE_DELETED_FUNCTIONS 0
-#endif
-
-#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \
-  (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800
-# define FMT_DELETED_OR_UNDEFINED  = delete
-# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
-    TypeName(const TypeName&) = delete; \
-    TypeName& operator=(const TypeName&) = delete
-#else
-# define FMT_DELETED_OR_UNDEFINED
-# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
-    TypeName(const TypeName&); \
-    TypeName& operator=(const TypeName&)
-#endif
-
-#ifndef FMT_USE_USER_DEFINED_LITERALS
-// All compilers which support UDLs also support variadic templates. This
-// makes the fmt::literals implementation easier. However, an explicit check
-// for variadic templates is added here just in case.
-# define FMT_USE_USER_DEFINED_LITERALS \
-   FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
-   (FMT_HAS_FEATURE(cxx_user_literals) || \
-       (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1900)
-#endif
-
-#ifndef FMT_ASSERT
-# define FMT_ASSERT(condition, message) assert((condition) && message)
-#endif
-
-
-#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
-# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
-#endif
-
-#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
-# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
-#endif
-
-// Some compilers masquerade as both MSVC and GCC-likes or 
-// otherwise support __builtin_clz and __builtin_clzll, so
-// only define FMT_BUILTIN_CLZ using the MSVC intrinsics
-// if the clz and clzll builtins are not available.
-#if defined(_MSC_VER) && !defined(FMT_BUILTIN_CLZLL)
-# include <intrin.h>  // _BitScanReverse, _BitScanReverse64
-
-namespace fmt {
-	namespace internal {
-# pragma intrinsic(_BitScanReverse)
-		inline uint32_t clz(uint32_t x)
-		{
-			unsigned long r = 0;
-			_BitScanReverse(&r, x);
-
-			assert(x != 0);
-			// Static analysis complains about using uninitialized data
-			// "r", but the only way that can happen is if "x" is 0, 
-			// which the callers guarantee to not happen.
-# pragma warning(suppress: 6102)
-			return 31 - r;
-		}
-# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
-
-# ifdef _WIN64
-#  pragma intrinsic(_BitScanReverse64)
-# endif
-
-		inline uint32_t clzll(uint64_t x)
-		{
-			unsigned long r = 0;
-# ifdef _WIN64
-			_BitScanReverse64(&r, x);
-# else
-			// Scan the high 32 bits.
-			if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
-				return 63 - (r + 32);
-
-			// Scan the low 32 bits.
-			_BitScanReverse(&r, static_cast<uint32_t>(x));
-# endif
-
-			assert(x != 0);
-			// Static analysis complains about using uninitialized data
-			// "r", but the only way that can happen is if "x" is 0, 
-			// which the callers guarantee to not happen.
-# pragma warning(suppress: 6102)
-			return 63 - r;
-		}
-# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
-	}
-}
-#endif
-
-namespace fmt {
-	namespace internal {
-		struct DummyInt
-		{
-			int data[2];
-			operator int() const
-			{
-				return 0;
-			}
-		};
-		typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;
-
-		// Dummy implementations of system functions such as signbit and ecvt called
-		// if the latter are not available.
-		inline DummyInt signbit(...)
-		{
-			return DummyInt();
-		}
-		inline DummyInt _ecvt_s(...)
-		{
-			return DummyInt();
-		}
-		inline DummyInt isinf(...)
-		{
-			return DummyInt();
-		}
-		inline DummyInt _finite(...)
-		{
-			return DummyInt();
-		}
-		inline DummyInt isnan(...)
-		{
-			return DummyInt();
-		}
-		inline DummyInt _isnan(...)
-		{
-			return DummyInt();
-		}
-
-		// A helper function to suppress bogus "conditional expression is constant"
-		// warnings.
-		template <typename T>
-		inline T check(T value)
-		{
-			return value;
-		}
-	}
-}  // namespace fmt
-
-namespace std {
-	// Standard permits specialization of std::numeric_limits. This specialization
-	// is used to resolve ambiguity between isinf and std::isinf in glibc:
-	// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891
-	// and the same for isnan and signbit.
-	template <>
-	class numeric_limits<fmt::internal::DummyInt>:
-		public std::numeric_limits<int>
-	{
-	public:
-		// Portable version of isinf.
-		template <typename T>
-		static bool isinfinity(T x)
-		{
-			using namespace fmt::internal;
-			// The resolution "priority" is:
-			// isinf macro > std::isinf > ::isinf > fmt::internal::isinf
-			if (check(sizeof(isinf(x)) == sizeof(bool) ||
-				sizeof(isinf(x)) == sizeof(int))) {
-				return isinf(x) != 0;
-			}
-			return !_finite(static_cast<double>(x));
-		}
-
-		// Portable version of isnan.
-		template <typename T>
-		static bool isnotanumber(T x)
-		{
-			using namespace fmt::internal;
-			if (check(sizeof(isnan(x)) == sizeof(bool) ||
-				sizeof(isnan(x)) == sizeof(int))) {
-				return isnan(x) != 0;
-			}
-			return _isnan(static_cast<double>(x)) != 0;
-		}
-
-		// Portable version of signbit.
-		static bool isnegative(double x)
-		{
-			using namespace fmt::internal;
-			if (check(sizeof(signbit(x)) == sizeof(int)))
-				return signbit(x) != 0;
-			if (x < 0) return true;
-			if (!isnotanumber(x)) return false;
-			int dec = 0, sign = 0;
-			char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
-			_ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
-			return sign != 0;
-		}
-	};
-}  // namespace std
-
-namespace fmt {
-
-	// Fix the warning about long long on older versions of GCC
-	// that don't support the diagnostic pragma.
-	FMT_GCC_EXTENSION typedef long long LongLong;
-	FMT_GCC_EXTENSION typedef unsigned long long ULongLong;
-
-#if FMT_USE_RVALUE_REFERENCES
-	using std::move;
-#endif
-
-	template <typename Char>
-	class BasicWriter;
-
-	typedef BasicWriter<char> Writer;
-	typedef BasicWriter<wchar_t> WWriter;
-
-	namespace internal {
-		template <typename Char>
-		class BasicArgFormatter;
-	}
-
-	template <typename CharType,
-		typename ArgFormatter = internal::BasicArgFormatter<CharType> >
-	class BasicFormatter;
-
-	template <typename Char, typename T>
-	void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value);
-
-	/**
-	\rst
-	A string reference. It can be constructed from a C string or ``std::string``.
-
-	You can use one of the following typedefs for common character types:
-
-	+------------+-------------------------+
-	| Type       | Definition              |
-	+============+=========================+
-	| StringRef  | BasicStringRef<char>    |
-	+------------+-------------------------+
-	| WStringRef | BasicStringRef<wchar_t> |
-	+------------+-------------------------+
-
-	This class is most useful as a parameter type to allow passing
-	different types of strings to a function, for example::
-
-	template <typename... Args>
-	std::string format(StringRef format_str, const Args & ... args);
-
-	format("{}", 42);
-	format(std::string("{}"), 42);
-	\endrst
-	*/
-	template <typename Char>
-	class BasicStringRef
-	{
-	private:
-		const Char *data_;
-		std::size_t size_;
-
-	public:
-		/** Constructs a string reference object from a C string and a size. */
-		BasicStringRef(const Char *s, std::size_t size): data_(s), size_(size)
-		{}
-
-		/**
-		\rst
-		Constructs a string reference object from a C string computing
-		the size with ``std::char_traits<Char>::length``.
-		\endrst
-		*/
-		BasicStringRef(const Char *s)
-			: data_(s), size_(std::char_traits<Char>::length(s))
-		{}
-
-		/**
-		\rst
-		Constructs a string reference from an ``std::string`` object.
-		\endrst
-		*/
-		BasicStringRef(const std::basic_string<Char> &s)
-			: data_(s.c_str()), size_(s.size())
-		{}
-
-		/**
-		\rst
-		Converts a string reference to an ``std::string`` object.
-		\endrst
-		*/
-		std::basic_string<Char> to_string() const
-		{
-			return std::basic_string<Char>(data_, size_);
-		}
-
-		/** Returns a pointer to the string data. */
-		const Char *data() const
-		{
-			return data_;
-		}
-
-		/** Returns the string size. */
-		std::size_t size() const
-		{
-			return size_;
-		}
-
-		// Lexicographically compare this string reference to other.
-		int compare(BasicStringRef other) const
-		{
-			std::size_t size = size_ < other.size_ ? size_ : other.size_;
-			int result = std::char_traits<Char>::compare(data_, other.data_, size);
-			if (result == 0)
-				result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-			return result;
-		}
-
-		friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
-		{
-			return lhs.compare(rhs) == 0;
-		}
-		friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
-		{
-			return lhs.compare(rhs) != 0;
-		}
-		friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)
-		{
-			return lhs.compare(rhs) < 0;
-		}
-		friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)
-		{
-			return lhs.compare(rhs) <= 0;
-		}
-		friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)
-		{
-			return lhs.compare(rhs) > 0;
-		}
-		friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)
-		{
-			return lhs.compare(rhs) >= 0;
-		}
-	};
-
-	typedef BasicStringRef<char> StringRef;
-	typedef BasicStringRef<wchar_t> WStringRef;
-
-	/**
-	\rst
-	A reference to a null terminated string. It can be constructed from a C
-	string or ``std::string``.
-
-	You can use one of the following typedefs for common character types:
-
-	+-------------+--------------------------+
-	| Type        | Definition               |
-	+=============+==========================+
-	| CStringRef  | BasicCStringRef<char>    |
-	+-------------+--------------------------+
-	| WCStringRef | BasicCStringRef<wchar_t> |
-	+-------------+--------------------------+
-
-	This class is most useful as a parameter type to allow passing
-	different types of strings to a function, for example::
-
-	template <typename... Args>
-	std::string format(CStringRef format_str, const Args & ... args);
-
-	format("{}", 42);
-	format(std::string("{}"), 42);
-	\endrst
-	*/
-	template <typename Char>
-	class BasicCStringRef
-	{
-	private:
-		const Char *data_;
-
-	public:
-		/** Constructs a string reference object from a C string. */
-		BasicCStringRef(const Char *s): data_(s)
-		{}
-
-		/**
-		\rst
-		Constructs a string reference from an ``std::string`` object.
-		\endrst
-		*/
-		BasicCStringRef(const std::basic_string<Char> &s): data_(s.c_str())
-		{}
-
-		/** Returns the pointer to a C string. */
-		const Char *c_str() const
-		{
-			return data_;
-		}
-	};
-
-	typedef BasicCStringRef<char> CStringRef;
-	typedef BasicCStringRef<wchar_t> WCStringRef;
-
-	/**
-	A formatting error such as invalid format string.
-	*/
-	class FormatError: public std::runtime_error
-	{
-	public:
-		explicit FormatError(CStringRef message)
-			: std::runtime_error(message.c_str())
-		{}
-	};
-
-	namespace internal {
-
-		// MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
-		template <typename T>
-		struct MakeUnsigned
-		{
-			typedef T Type;
-		};
-
-#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
-  template <> \
-  struct MakeUnsigned<T> { typedef U Type; }
-
-		FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char);
-		FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);
-		FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short);
-		FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);
-		FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);
-		FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);
-
-		// Casts nonnegative integer to unsigned.
-		template <typename Int>
-		inline typename MakeUnsigned<Int>::Type to_unsigned(Int value)
-		{
-			FMT_ASSERT(value >= 0, "negative value");
-			return static_cast<typename MakeUnsigned<Int>::Type>(value);
-		}
-
-		// The number of characters to store in the MemoryBuffer object itself
-		// to avoid dynamic memory allocation.
-		enum
-		{
-			INLINE_BUFFER_SIZE = 500
-		};
-
-#if FMT_SECURE_SCL
-		// Use checked iterator to avoid warnings on MSVC.
-		template <typename T>
-		inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size)
-		{
-			return stdext::checked_array_iterator<T*>(ptr, size);
-		}
-#else
-		template <typename T>
-		inline T *make_ptr(T *ptr, std::size_t)
-		{
-			return ptr;
-		}
-#endif
-	}  // namespace internal
-
-	   /**
-	   \rst
-	   A buffer supporting a subset of ``std::vector``'s operations.
-	   \endrst
-	   */
-	template <typename T>
-	class Buffer
-	{
-	private:
-		FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
-
-	protected:
-		T *ptr_;
-		std::size_t size_;
-		std::size_t capacity_;
-
-		Buffer(T *ptr = 0, std::size_t capacity = 0)
-			: ptr_(ptr), size_(0), capacity_(capacity)
-		{}
-
-		/**
-		\rst
-		Increases the buffer capacity to hold at least *size* elements updating
-		``ptr_`` and ``capacity_``.
-		\endrst
-		*/
-		virtual void grow(std::size_t size) = 0;
-
-	public:
-		virtual ~Buffer()
-		{}
-
-		/** Returns the size of this buffer. */
-		std::size_t size() const
-		{
-			return size_;
-		}
-
-		/** Returns the capacity of this buffer. */
-		std::size_t capacity() const
-		{
-			return capacity_;
-		}
-
-		/**
-		Resizes the buffer. If T is a POD type new elements may not be initialized.
-		*/
-		void resize(std::size_t new_size)
-		{
-			if (new_size > capacity_)
-				grow(new_size);
-			size_ = new_size;
-		}
-
-		/**
-		\rst
-		Reserves space to store at least *capacity* elements.
-		\endrst
-		*/
-		void reserve(std::size_t capacity)
-		{
-			if (capacity > capacity_)
-				grow(capacity);
-		}
-
-		void clear() FMT_NOEXCEPT
-		{
-			size_ = 0;
-		}
-
-		void push_back(const T &value)
-		{
-			if (size_ == capacity_)
-				grow(size_ + 1);
-			ptr_[size_++] = value;
-		}
-
-		/** Appends data to the end of the buffer. */
-		template <typename U>
-		void append(const U *begin, const U *end);
-
-		T &operator[](std::size_t index)
-		{
-			return ptr_[index];
-		}
-		const T &operator[](std::size_t index) const
-		{
-			return ptr_[index];
-		}
-	};
-
-	template <typename T>
-	template <typename U>
-	void Buffer<T>::append(const U *begin, const U *end)
-	{
-		std::size_t new_size = size_ + internal::to_unsigned(end - begin);
-		if (new_size > capacity_)
-			grow(new_size);
-		std::uninitialized_copy(begin, end,
-			internal::make_ptr(ptr_, capacity_) + size_);
-		size_ = new_size;
-	}
-
-	namespace internal {
-
-		// A memory buffer for trivially copyable/constructible types with the first SIZE
-		// elements stored in the object itself.
-		template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
-		class MemoryBuffer: private Allocator, public Buffer<T>
-		{
-		private:
-			T data_[SIZE];
-
-			// Deallocate memory allocated by the buffer.
-			void deallocate()
-			{
-				if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
-			}
-
-		protected:
-			void grow(std::size_t size);
-
-		public:
-			explicit MemoryBuffer(const Allocator &alloc = Allocator())
-				: Allocator(alloc), Buffer<T>(data_, SIZE)
-			{}
-			~MemoryBuffer()
-			{
-				deallocate();
-			}
-
-#if FMT_USE_RVALUE_REFERENCES
-		private:
-			// Move data from other to this buffer.
-			void move(MemoryBuffer &other)
-			{
-				Allocator &this_alloc = *this, &other_alloc = other;
-				this_alloc = std::move(other_alloc);
-				this->size_ = other.size_;
-				this->capacity_ = other.capacity_;
-				if (other.ptr_ == other.data_) {
-					this->ptr_ = data_;
-					std::uninitialized_copy(other.data_, other.data_ + this->size_,
-						make_ptr(data_, this->capacity_));
-				}
-				else {
-					this->ptr_ = other.ptr_;
-					// Set pointer to the inline array so that delete is not called
-					// when deallocating.
-					other.ptr_ = other.data_;
-				}
-			}
-
-		public:
-			MemoryBuffer(MemoryBuffer &&other)
-			{
-				move(other);
-			}
-
-			MemoryBuffer &operator=(MemoryBuffer &&other)
-			{
-				assert(this != &other);
-				deallocate();
-				move(other);
-				return *this;
-			}
-#endif
-
-			// Returns a copy of the allocator associated with this buffer.
-			Allocator get_allocator() const
-			{
-				return *this;
-			}
-		};
-
-		template <typename T, std::size_t SIZE, typename Allocator>
-		void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size)
-		{
-			std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
-			if (size > new_capacity)
-				new_capacity = size;
-			T *new_ptr = this->allocate(new_capacity);
-			// The following code doesn't throw, so the raw pointer above doesn't leak.
-			std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
-				make_ptr(new_ptr, new_capacity));
-			std::size_t old_capacity = this->capacity_;
-			T *old_ptr = this->ptr_;
-			this->capacity_ = new_capacity;
-			this->ptr_ = new_ptr;
-			// deallocate may throw (at least in principle), but it doesn't matter since
-			// the buffer already uses the new storage and will deallocate it in case
-			// of exception.
-			if (old_ptr != data_)
-				Allocator::deallocate(old_ptr, old_capacity);
-		}
-
-		// A fixed-size buffer.
-		template <typename Char>
-		class FixedBuffer: public fmt::Buffer<Char>
-		{
-		public:
-			FixedBuffer(Char *array, std::size_t size): fmt::Buffer<Char>(array, size)
-			{}
-
-		protected:
-			FMT_API void grow(std::size_t size);
-		};
-
-		template <typename Char>
-		class BasicCharTraits
-		{
-		public:
-#if FMT_SECURE_SCL
-			typedef stdext::checked_array_iterator<Char*> CharPtr;
-#else
-			typedef Char *CharPtr;
-#endif
-			static Char cast(int value)
-			{
-				return static_cast<Char>(value);
-			}
-		};
-
-		template <typename Char>
-		class CharTraits;
-
-		template <>
-		class CharTraits<char>: public BasicCharTraits<char>
-		{
-		private:
-			// Conversion from wchar_t to char is not allowed.
-			static char convert(wchar_t);
-
-		public:
-			static char convert(char value)
-			{
-				return value;
-			}
-
-			// Formats a floating-point number.
-			template <typename T>
-			FMT_API static int format_float(char *buffer, std::size_t size,
-				const char *format, unsigned width, int precision, T value);
-		};
-
-		template <>
-		class CharTraits<wchar_t>: public BasicCharTraits<wchar_t>
-		{
-		public:
-			static wchar_t convert(char value)
-			{
-				return value;
-			}
-			static wchar_t convert(wchar_t value)
-			{
-				return value;
-			}
-
-			template <typename T>
-			FMT_API static int format_float(wchar_t *buffer, std::size_t size,
-				const wchar_t *format, unsigned width, int precision, T value);
-		};
-
-		// Checks if a number is negative - used to avoid warnings.
-		template <bool IsSigned>
-		struct SignChecker
-		{
-			template <typename T>
-			static bool is_negative(T value)
-			{
-				return value < 0;
-			}
-		};
-
-		template <>
-		struct SignChecker<false>
-		{
-			template <typename T>
-			static bool is_negative(T)
-			{
-				return false;
-			}
-		};
-
-		// Returns true if value is negative, false otherwise.
-		// Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
-		template <typename T>
-		inline bool is_negative(T value)
-		{
-			return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
-		}
-
-		// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
-		template <bool FitsIn32Bits>
-		struct TypeSelector
-		{
-			typedef uint32_t Type;
-		};
-
-		template <>
-		struct TypeSelector<false>
-		{
-			typedef uint64_t Type;
-		};
-
-		template <typename T>
-		struct IntTraits
-		{
-			// Smallest of uint32_t and uint64_t that is large enough to represent
-			// all values of T.
-			typedef typename
-				TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;
-		};
-
-		FMT_API void report_unknown_type(char code, const char *type);
-
-		// Static data is placed in this class template to allow header-only
-		// configuration.
-		template <typename T = void>
-		struct FMT_API BasicData
-		{
-			static const uint32_t POWERS_OF_10_32[];
-			static const uint64_t POWERS_OF_10_64[];
-			static const char DIGITS[];
-		};
-
-		typedef BasicData<> Data;
-
-#ifdef FMT_BUILTIN_CLZLL
-		// Returns the number of decimal digits in n. Leading zeros are not counted
-		// except for n == 0 in which case count_digits returns 1.
-		inline unsigned count_digits(uint64_t n)
-		{
-			// Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
-			// and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
-			int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-			return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1;
-		}
-#else
-		// Fallback version of count_digits used when __builtin_clz is not available.
-		inline unsigned count_digits(uint64_t n)
-		{
-			unsigned count = 1;
-			for (;;) {
-				// Integer division is slow so do it for a group of four digits instead
-				// of for every digit. The idea comes from the talk by Alexandrescu
-				// "Three Optimization Tips for C++". See speed-test for a comparison.
-				if (n < 10) return count;
-				if (n < 100) return count + 1;
-				if (n < 1000) return count + 2;
-				if (n < 10000) return count + 3;
-				n /= 10000u;
-				count += 4;
-			}
-		}
-#endif
-
-#ifdef FMT_BUILTIN_CLZ
-		// Optional version of count_digits for better performance on 32-bit platforms.
-		inline unsigned count_digits(uint32_t n)
-		{
-			int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
-			return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1;
-		}
-#endif
-
-		// Formats a decimal unsigned integer value writing into buffer.
-		template <typename UInt, typename Char>
-		inline void format_decimal(Char *buffer, UInt value, unsigned num_digits)
-		{
-			buffer += num_digits;
-			while (value >= 100) {
-				// Integer division is slow so do it for a group of two digits instead
-				// of for every digit. The idea comes from the talk by Alexandrescu
-				// "Three Optimization Tips for C++". See speed-test for a comparison.
-				unsigned index = static_cast<unsigned>((value % 100) * 2);
-				value /= 100;
-				*--buffer = Data::DIGITS[index + 1];
-				*--buffer = Data::DIGITS[index];
-			}
-			if (value < 10) {
-				*--buffer = static_cast<char>('0' + value);
-				return;
-			}
-			unsigned index = static_cast<unsigned>(value * 2);
-			*--buffer = Data::DIGITS[index + 1];
-			*--buffer = Data::DIGITS[index];
-		}
-
-#ifndef _WIN32
-# define FMT_USE_WINDOWS_H 0
-#elif !defined(FMT_USE_WINDOWS_H)
-# define FMT_USE_WINDOWS_H 1
-#endif
-
-		// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
-		// All the functionality that relies on it will be disabled too.
-#if FMT_USE_WINDOWS_H
-		// A converter from UTF-8 to UTF-16.
-		// It is only provided for Windows since other systems support UTF-8 natively.
-		class UTF8ToUTF16
-		{
-		private:
-			MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
-
-		public:
-			FMT_API explicit UTF8ToUTF16(StringRef s);
-			operator WStringRef() const
-			{
-				return WStringRef(&buffer_[0], size());
-			}
-			size_t size() const
-			{
-				return buffer_.size() - 1;
-			}
-			const wchar_t *c_str() const
-			{
-				return &buffer_[0];
-			}
-			std::wstring str() const
-			{
-				return std::wstring(&buffer_[0], size());
-			}
-		};
-
-		// A converter from UTF-16 to UTF-8.
-		// It is only provided for Windows since other systems support UTF-8 natively.
-		class UTF16ToUTF8
-		{
-		private:
-			MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
-
-		public:
-			UTF16ToUTF8()
-			{}
-			FMT_API explicit UTF16ToUTF8(WStringRef s);
-			operator StringRef() const
-			{
-				return StringRef(&buffer_[0], size());
-			}
-			size_t size() const
-			{
-				return buffer_.size() - 1;
-			}
-			const char *c_str() const
-			{
-				return &buffer_[0];
-			}
-			std::string str() const
-			{
-				return std::string(&buffer_[0], size());
-			}
-
-			// Performs conversion returning a system error code instead of
-			// throwing exception on conversion error. This method may still throw
-			// in case of memory allocation error.
-			FMT_API int convert(WStringRef s);
-		};
-
-		FMT_API void format_windows_error(fmt::Writer &out, int error_code,
-			fmt::StringRef message) FMT_NOEXCEPT;
-#endif
-
-		FMT_API void format_system_error(fmt::Writer &out, int error_code,
-			fmt::StringRef message) FMT_NOEXCEPT;
-
-		// A formatting argument value.
-		struct Value
-		{
-			template <typename Char>
-			struct StringValue
-			{
-				const Char *value;
-				std::size_t size;
-			};
-
-			typedef void(*FormatFunc)(
-				void *formatter, const void *arg, void *format_str_ptr);
-
-			struct CustomValue
-			{
-				const void *value;
-				FormatFunc format;
-			};
-
-			union
-			{
-				int int_value;
-				unsigned uint_value;
-				LongLong long_long_value;
-				ULongLong ulong_long_value;
-				double double_value;
-				long double long_double_value;
-				const void *pointer;
-				StringValue<char> string;
-				StringValue<signed char> sstring;
-				StringValue<unsigned char> ustring;
-				StringValue<wchar_t> wstring;
-				CustomValue custom;
-			};
-
-			enum Type
-			{
-				NONE, NAMED_ARG,
-				// Integer types should go first,
-				INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
-				// followed by floating-point types.
-				DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
-				CSTRING, STRING, WSTRING, POINTER, CUSTOM
-			};
-		};
-
-		// A formatting argument. It is a trivially copyable/constructible type to
-		// allow storage in internal::MemoryBuffer.
-		struct Arg: Value
-		{
-			Type type;
-		};
-
-		template <typename Char>
-		struct NamedArg;
-
-		template <typename T = void>
-		struct Null
-		{};
-
-		// A helper class template to enable or disable overloads taking wide
-		// characters and strings in MakeValue.
-		template <typename T, typename Char>
-		struct WCharHelper
-		{
-			typedef Null<T> Supported;
-			typedef T Unsupported;
-		};
-
-		template <typename T>
-		struct WCharHelper<T, wchar_t>
-		{
-			typedef T Supported;
-			typedef Null<T> Unsupported;
-		};
-
-		typedef char Yes[1];
-		typedef char No[2];
-
-		// These are non-members to workaround an overload resolution bug in bcc32.
-		Yes &convert(fmt::ULongLong);
-		Yes &convert(std::ostream &);
-		No &convert(...);
-
-		template <typename T>
-		T &get();
-
-		struct DummyStream: std::ostream
-		{
-			DummyStream();  // Suppress a bogus warning in MSVC.
-							// Hide all operator<< overloads from std::ostream.
-			void operator<<(Null<>);
-		};
-
-		No &operator<<(std::ostream &, int);
-
-		template<typename T, bool ENABLE_CONVERSION>
-		struct ConvertToIntImpl
-		{
-			enum
-			{
-				value = false
-			};
-		};
-
-		template<typename T>
-		struct ConvertToIntImpl<T, true>
-		{
-			// Convert to int only if T doesn't have an overloaded operator<<.
-			enum
-			{
-				value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
-			};
-		};
-
-		template<typename T, bool ENABLE_CONVERSION>
-		struct ConvertToIntImpl2
-		{
-			enum
-			{
-				value = false
-			};
-		};
-
-		template<typename T>
-		struct ConvertToIntImpl2<T, true>
-		{
-			enum
-			{
-				// Don't convert numeric types.
-				value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
-			};
-		};
-
-		template<typename T>
-		struct ConvertToInt
-		{
-			enum
-			{
-				enable_conversion = sizeof(convert(get<T>())) == sizeof(Yes)
-			};
-			enum
-			{
-				value = ConvertToIntImpl2<T, enable_conversion>::value
-			};
-		};
-
-#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
-  template <> \
-  struct ConvertToInt<Type> {  enum { value = 0 }; }
-
-		// Silence warnings about convering float to int.
-		FMT_DISABLE_CONVERSION_TO_INT(float);
-		FMT_DISABLE_CONVERSION_TO_INT(double);
-		FMT_DISABLE_CONVERSION_TO_INT(long double);
-
-		template<bool B, class T = void>
-		struct EnableIf
-		{};
-
-		template<class T>
-		struct EnableIf<true, T>
-		{
-			typedef T type;
-		};
-
-		template<bool B, class T, class F>
-		struct Conditional
-		{
-			typedef T type;
-		};
-
-		template<class T, class F>
-		struct Conditional<false, T, F>
-		{
-			typedef F type;
-		};
-
-		// For bcc32 which doesn't understand ! in template arguments.
-		template<bool>
-		struct Not
-		{
-			enum
-			{
-				value = 0
-			};
-		};
-
-		template<>
-		struct Not<false>
-		{
-			enum
-			{
-				value = 1
-			};
-		};
-
-		// Makes an Arg object from any type.
-		template <typename Formatter>
-		class MakeValue: public Arg
-		{
-		public:
-			typedef typename Formatter::Char Char;
-
-		private:
-			// The following two methods are private to disallow formatting of
-			// arbitrary pointers. If you want to output a pointer cast it to
-			// "void *" or "const void *". In particular, this forbids formatting
-			// of "[const] volatile char *" which is printed as bool by iostreams.
-			// Do not implement!
-			template <typename T>
-			MakeValue(const T *value);
-			template <typename T>
-			MakeValue(T *value);
-
-			// The following methods are private to disallow formatting of wide
-			// characters and strings into narrow strings as in
-			//   fmt::format("{}", L"test");
-			// To fix this, use a wide format string: fmt::format(L"{}", L"test").
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-			MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
-#endif
-			MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
-			MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
-			MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
-			MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
-
-			void set_string(StringRef str)
-			{
-				string.value = str.data();
-				string.size = str.size();
-			}
-
-			void set_string(WStringRef str)
-			{
-				wstring.value = str.data();
-				wstring.size = str.size();
-			}
-
-			// Formats an argument of a custom type, such as a user-defined class.
-			template <typename T>
-			static void format_custom_arg(
-				void *formatter, const void *arg, void *format_str_ptr)
-			{
-				format(*static_cast<Formatter*>(formatter),
-					*static_cast<const Char**>(format_str_ptr),
-					*static_cast<const T*>(arg));
-			}
-
-		public:
-			MakeValue()
-			{}
-
-#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
-  MakeValue(Type value) { field = rhs; } \
-  static uint64_t type(Type) { return Arg::TYPE; }
-
-#define FMT_MAKE_VALUE(Type, field, TYPE) \
-  FMT_MAKE_VALUE_(Type, field, TYPE, value)
-
-			FMT_MAKE_VALUE(bool, int_value, BOOL)
-				FMT_MAKE_VALUE(short, int_value, INT)
-				FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
-				FMT_MAKE_VALUE(int, int_value, INT)
-				FMT_MAKE_VALUE(unsigned, uint_value, UINT)
-
-				MakeValue(long value)
-			{
-				// To minimize the number of types we need to deal with, long is
-				// translated either to int or to long long depending on its size.
-				if (check(sizeof(long) == sizeof(int)))
-					int_value = static_cast<int>(value);
-				else
-					long_long_value = value;
-			}
-			static uint64_t type(long)
-			{
-				return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
-			}
-
-			MakeValue(unsigned long value)
-			{
-				if (check(sizeof(unsigned long) == sizeof(unsigned)))
-					uint_value = static_cast<unsigned>(value);
-				else
-					ulong_long_value = value;
-			}
-			static uint64_t type(unsigned long)
-			{
-				return sizeof(unsigned long) == sizeof(unsigned) ?
-					Arg::UINT : Arg::ULONG_LONG;
-			}
-
-			FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
-				FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
-				FMT_MAKE_VALUE(float, double_value, DOUBLE)
-				FMT_MAKE_VALUE(double, double_value, DOUBLE)
-				FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
-				FMT_MAKE_VALUE(signed char, int_value, INT)
-				FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
-				FMT_MAKE_VALUE(char, int_value, CHAR)
-
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-				MakeValue(typename WCharHelper<wchar_t, Char>::Supported value)
-			{
-				int_value = value;
-			}
-			static uint64_t type(wchar_t)
-			{
-				return Arg::CHAR;
-			}
-#endif
-
-#define FMT_MAKE_STR_VALUE(Type, TYPE) \
-  MakeValue(Type value) { set_string(value); } \
-  static uint64_t type(Type) { return Arg::TYPE; }
-
-			FMT_MAKE_VALUE(char *, string.value, CSTRING)
-				FMT_MAKE_VALUE(const char *, string.value, CSTRING)
-				FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
-				FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
-				FMT_MAKE_STR_VALUE(const std::string &, STRING)
-				FMT_MAKE_STR_VALUE(StringRef, STRING)
-				FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
-
-#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
-  MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
-    set_string(value); \
-  } \
-  static uint64_t type(Type) { return Arg::TYPE; }
-
-				FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
-				FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
-				FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
-				FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
-
-				FMT_MAKE_VALUE(void *, pointer, POINTER)
-				FMT_MAKE_VALUE(const void *, pointer, POINTER)
-
-				template <typename T>
-			MakeValue(const T &value,
-				typename EnableIf<Not<
-				ConvertToInt<T>::value>::value, int>::type = 0)
-			{
-				custom.value = &value;
-				custom.format = &format_custom_arg<T>;
-			}
-
-			template <typename T>
-			MakeValue(const T &value,
-				typename EnableIf<ConvertToInt<T>::value, int>::type = 0)
-			{
-				int_value = value;
-			}
-
-			template <typename T>
-			static uint64_t type(const T &)
-			{
-				return ConvertToInt<T>::value ? Arg::INT : Arg::CUSTOM;
-			}
-
-			// Additional template param `Char_` is needed here because make_type always
-			// uses char.
-			template <typename Char_>
-			MakeValue(const NamedArg<Char_> &value)
-			{
-				pointer = &value;
-			}
-
-			template <typename Char_>
-			static uint64_t type(const NamedArg<Char_> &)
-			{
-				return Arg::NAMED_ARG;
-			}
-		};
-
-		template <typename Formatter>
-		class MakeArg: public Arg
-		{
-		public:
-			MakeArg()
-			{
-				type = Arg::NONE;
-			}
-
-			template <typename T>
-			MakeArg(const T &value)
-				: Arg(MakeValue<Formatter>(value))
-			{
-				type = static_cast<Arg::Type>(MakeValue<Formatter>::type(value));
-			}
-		};
-
-		template <typename Char>
-		struct NamedArg: Arg
-		{
-			BasicStringRef<Char> name;
-
-			template <typename T>
-			NamedArg(BasicStringRef<Char> argname, const T &value)
-				: Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname)
-			{}
-		};
-
-#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
-
-		// An argument visitor.
-		// To use ArgVisitor define a subclass that implements some or all of the
-		// visit methods with the same signatures as the methods in ArgVisitor,
-		// for example, visit_int(int).
-		// Specify the subclass name as the Impl template parameter. Then calling
-		// ArgVisitor::visit for some argument will dispatch to a visit method
-		// specific to the argument type. For example, if the argument type is
-		// double then visit_double(double) method of a subclass will be called.
-		// If the subclass doesn't contain a method with this signature, then
-		// a corresponding method of ArgVisitor will be called.
-		//
-		// Example:
-		//  class MyArgVisitor : public ArgVisitor<MyArgVisitor, void> {
-		//   public:
-		//    void visit_int(int value) { print("{}", value); }
-		//    void visit_double(double value) { print("{}", value ); }
-		//  };
-		//
-		// ArgVisitor uses the curiously recurring template pattern:
-		// http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
-		template <typename Impl, typename Result>
-		class ArgVisitor
-		{
-		public:
-			void report_unhandled_arg()
-			{}
-
-			Result visit_unhandled_arg()
-			{
-				FMT_DISPATCH(report_unhandled_arg());
-				return Result();
-			}
-
-			Result visit_int(int value)
-			{
-				return FMT_DISPATCH(visit_any_int(value));
-			}
-			Result visit_long_long(LongLong value)
-			{
-				return FMT_DISPATCH(visit_any_int(value));
-			}
-			Result visit_uint(unsigned value)
-			{
-				return FMT_DISPATCH(visit_any_int(value));
-			}
-			Result visit_ulong_long(ULongLong value)
-			{
-				return FMT_DISPATCH(visit_any_int(value));
-			}
-			Result visit_bool(bool value)
-			{
-				return FMT_DISPATCH(visit_any_int(value));
-			}
-			Result visit_char(int value)
-			{
-				return FMT_DISPATCH(visit_any_int(value));
-			}
-			template <typename T>
-			Result visit_any_int(T)
-			{
-				return FMT_DISPATCH(visit_unhandled_arg());
-			}
-
-			Result visit_double(double value)
-			{
-				return FMT_DISPATCH(visit_any_double(value));
-			}
-			Result visit_long_double(long double value)
-			{
-				return FMT_DISPATCH(visit_any_double(value));
-			}
-			template <typename T>
-			Result visit_any_double(T)
-			{
-				return FMT_DISPATCH(visit_unhandled_arg());
-			}
-
-			Result visit_cstring(const char *)
-			{
-				return FMT_DISPATCH(visit_unhandled_arg());
-			}
-			Result visit_string(Arg::StringValue<char>)
-			{
-				return FMT_DISPATCH(visit_unhandled_arg());
-			}
-			Result visit_wstring(Arg::StringValue<wchar_t>)
-			{
-				return FMT_DISPATCH(visit_unhandled_arg());
-			}
-			Result visit_pointer(const void *)
-			{
-				return FMT_DISPATCH(visit_unhandled_arg());
-			}
-			Result visit_custom(Arg::CustomValue)
-			{
-				return FMT_DISPATCH(visit_unhandled_arg());
-			}
-
-			Result visit(const Arg &arg)
-			{
-				switch (arg.type) {
-				default:
-					FMT_ASSERT(false, "invalid argument type");
-					return Result();
-				case Arg::INT:
-					return FMT_DISPATCH(visit_int(arg.int_value));
-				case Arg::UINT:
-					return FMT_DISPATCH(visit_uint(arg.uint_value));
-				case Arg::LONG_LONG:
-					return FMT_DISPATCH(visit_long_long(arg.long_long_value));
-				case Arg::ULONG_LONG:
-					return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
-				case Arg::BOOL:
-					return FMT_DISPATCH(visit_bool(arg.int_value != 0));
-				case Arg::CHAR:
-					return FMT_DISPATCH(visit_char(arg.int_value));
-				case Arg::DOUBLE:
-					return FMT_DISPATCH(visit_double(arg.double_value));
-				case Arg::LONG_DOUBLE:
-					return FMT_DISPATCH(visit_long_double(arg.long_double_value));
-				case Arg::CSTRING:
-					return FMT_DISPATCH(visit_cstring(arg.string.value));
-				case Arg::STRING:
-					return FMT_DISPATCH(visit_string(arg.string));
-				case Arg::WSTRING:
-					return FMT_DISPATCH(visit_wstring(arg.wstring));
-				case Arg::POINTER:
-					return FMT_DISPATCH(visit_pointer(arg.pointer));
-				case Arg::CUSTOM:
-					return FMT_DISPATCH(visit_custom(arg.custom));
-				}
-			}
-		};
-
-		class RuntimeError: public std::runtime_error
-		{
-		protected:
-			RuntimeError(): std::runtime_error("")
-			{}
-		};
-
-		template <typename Char>
-		class PrintfArgFormatter;
-
-		template <typename Char>
-		class ArgMap;
-	}  // namespace internal
-
-	   /** An argument list. */
-	class ArgList
-	{
-	private:
-		// To reduce compiled code size per formatting function call, types of first
-		// MAX_PACKED_ARGS arguments are passed in the types_ field.
-		uint64_t types_;
-		union
-		{
-			// If the number of arguments is less than MAX_PACKED_ARGS, the argument
-			// values are stored in values_, otherwise they are stored in args_.
-			// This is done to reduce compiled code size as storing larger objects
-			// may require more code (at least on x86-64) even if the same amount of
-			// data is actually copied to stack. It saves ~10% on the bloat test.
-			const internal::Value *values_;
-			const internal::Arg *args_;
-		};
-
-		internal::Arg::Type type(unsigned index) const
-		{
-			unsigned shift = index * 4;
-			uint64_t mask = 0xf;
-			return static_cast<internal::Arg::Type>(
-				(types_ & (mask << shift)) >> shift);
-		}
-
-		template <typename Char>
-		friend class internal::ArgMap;
-
-	public:
-		// Maximum number of arguments with packed types.
-		enum
-		{
-			MAX_PACKED_ARGS = 16
-		};
-
-		ArgList(): types_(0)
-		{}
-
-		ArgList(ULongLong types, const internal::Value *values)
-			: types_(types), values_(values)
-		{}
-		ArgList(ULongLong types, const internal::Arg *args)
-			: types_(types), args_(args)
-		{}
-
-		/** Returns the argument at specified index. */
-		internal::Arg operator[](unsigned index) const
-		{
-			using internal::Arg;
-			Arg arg;
-			bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
-			if (index < MAX_PACKED_ARGS) {
-				Arg::Type arg_type = type(index);
-				internal::Value &val = arg;
-				if (arg_type != Arg::NONE)
-					val = use_values ? values_[index] : args_[index];
-				arg.type = arg_type;
-				return arg;
-			}
-			if (use_values) {
-				// The index is greater than the number of arguments that can be stored
-				// in values, so return a "none" argument.
-				arg.type = Arg::NONE;
-				return arg;
-			}
-			for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) {
-				if (args_[i].type == Arg::NONE)
-					return args_[i];
-			}
-			return args_[index];
-		}
-	};
-
-	enum Alignment
-	{
-		ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
-	};
-
-	// Flags.
-	enum
-	{
-		SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
-		CHAR_FLAG = 0x10  // Argument has char type - used in error reporting.
-	};
-
-	// An empty format specifier.
-	struct EmptySpec
-	{};
-
-	// A type specifier.
-	template <char TYPE>
-	struct TypeSpec: EmptySpec
-	{
-		Alignment align() const
-		{
-			return ALIGN_DEFAULT;
-		}
-		unsigned width() const
-		{
-			return 0;
-		}
-		int precision() const
-		{
-			return -1;
-		}
-		bool flag(unsigned) const
-		{
-			return false;
-		}
-		char type() const
-		{
-			return TYPE;
-		}
-		char fill() const
-		{
-			return ' ';
-		}
-	};
-
-	// A width specifier.
-	struct WidthSpec
-	{
-		unsigned width_;
-		// Fill is always wchar_t and cast to char if necessary to avoid having
-		// two specialization of WidthSpec and its subclasses.
-		wchar_t fill_;
-
-		WidthSpec(unsigned width, wchar_t fill): width_(width), fill_(fill)
-		{}
-
-		unsigned width() const
-		{
-			return width_;
-		}
-		wchar_t fill() const
-		{
-			return fill_;
-		}
-	};
-
-	// An alignment specifier.
-	struct AlignSpec: WidthSpec
-	{
-		Alignment align_;
-
-		AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
-			: WidthSpec(width, fill), align_(align)
-		{}
-
-		Alignment align() const
-		{
-			return align_;
-		}
-
-		int precision() const
-		{
-			return -1;
-		}
-	};
-
-	// An alignment and type specifier.
-	template <char TYPE>
-	struct AlignTypeSpec: AlignSpec
-	{
-		AlignTypeSpec(unsigned width, wchar_t fill): AlignSpec(width, fill)
-		{}
-
-		bool flag(unsigned) const
-		{
-			return false;
-		}
-		char type() const
-		{
-			return TYPE;
-		}
-	};
-
-	// A full format specifier.
-	struct FormatSpec: AlignSpec
-	{
-		unsigned flags_;
-		int precision_;
-		char type_;
-
-		FormatSpec(
-			unsigned width = 0, char type = 0, wchar_t fill = ' ')
-			: AlignSpec(width, fill), flags_(0), precision_(-1), type_(type)
-		{}
-
-		bool flag(unsigned f) const
-		{
-			return (flags_ & f) != 0;
-		}
-		int precision() const
-		{
-			return precision_;
-		}
-		char type() const
-		{
-			return type_;
-		}
-	};
-
-	// An integer format specifier.
-	template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
-	class IntFormatSpec: public SpecT
-	{
-	private:
-		T value_;
-
-	public:
-		IntFormatSpec(T val, const SpecT &spec = SpecT())
-			: SpecT(spec), value_(val)
-		{}
-
-		T value() const
-		{
-			return value_;
-		}
-	};
-
-	// A string format specifier.
-	template <typename Char>
-	class StrFormatSpec: public AlignSpec
-	{
-	private:
-		const Char *str_;
-
-	public:
-		template <typename FillChar>
-		StrFormatSpec(const Char *str, unsigned width, FillChar fill)
-			: AlignSpec(width, fill), str_(str)
-		{
-			internal::CharTraits<Char>::convert(FillChar());
-		}
-
-		const Char *str() const
-		{
-			return str_;
-		}
-	};
-
-	/**
-	Returns an integer format specifier to format the value in base 2.
-	*/
-	IntFormatSpec<int, TypeSpec<'b'> > bin(int value);
-
-	/**
-	Returns an integer format specifier to format the value in base 8.
-	*/
-	IntFormatSpec<int, TypeSpec<'o'> > oct(int value);
-
-	/**
-	Returns an integer format specifier to format the value in base 16 using
-	lower-case letters for the digits above 9.
-	*/
-	IntFormatSpec<int, TypeSpec<'x'> > hex(int value);
-
-	/**
-	Returns an integer formatter format specifier to format in base 16 using
-	upper-case letters for the digits above 9.
-	*/
-	IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);
-
-	/**
-	\rst
-	Returns an integer format specifier to pad the formatted argument with the
-	fill character to the specified width using the default (right) numeric
-	alignment.
-
-	**Example**::
-
-	MemoryWriter out;
-	out << pad(hex(0xcafe), 8, '0');
-	// out.str() == "0000cafe"
-
-	\endrst
-	*/
-	template <char TYPE_CODE, typename Char>
-	IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
-		int value, unsigned width, Char fill = ' ');
-
-#define FMT_DEFINE_INT_FORMATTERS(TYPE) \
-inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
-  return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
-} \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \
-  return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \
-} \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
-  return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \
-} \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
-  return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
-} \
- \
-template <char TYPE_CODE> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
-    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
-  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
-      f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
-} \
- \
-/* For compatibility with older compilers we provide two overloads for pad, */ \
-/* one that takes a fill character and one that doesn't. In the future this */ \
-/* can be replaced with one overload making the template argument Char      */ \
-/* default to char (C++11). */ \
-template <char TYPE_CODE, typename Char> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
-    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \
-    unsigned width, Char fill) { \
-  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
-      f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
-} \
- \
-inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
-    TYPE value, unsigned width) { \
-  return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
-      value, AlignTypeSpec<0>(width, ' ')); \
-} \
- \
-template <typename Char> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
-   TYPE value, unsigned width, Char fill) { \
- return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
-     value, AlignTypeSpec<0>(width, fill)); \
-}
-
-	FMT_DEFINE_INT_FORMATTERS(int)
-		FMT_DEFINE_INT_FORMATTERS(long)
-		FMT_DEFINE_INT_FORMATTERS(unsigned)
-		FMT_DEFINE_INT_FORMATTERS(unsigned long)
-		FMT_DEFINE_INT_FORMATTERS(LongLong)
-		FMT_DEFINE_INT_FORMATTERS(ULongLong)
-
-		/**
-		\rst
-		Returns a string formatter that pads the formatted argument with the fill
-		character to the specified width using the default (left) string alignment.
-
-		**Example**::
-
-		std::string s = str(MemoryWriter() << pad("abc", 8));
-		// s == "abc     "
-
-		\endrst
-		*/
-		template <typename Char>
-	inline StrFormatSpec<Char> pad(
-		const Char *str, unsigned width, Char fill = ' ')
-	{
-		return StrFormatSpec<Char>(str, width, fill);
-	}
-
-	inline StrFormatSpec<wchar_t> pad(
-		const wchar_t *str, unsigned width, char fill = ' ')
-	{
-		return StrFormatSpec<wchar_t>(str, width, fill);
-	}
-
-	namespace internal {
-
-		template <typename Char>
-		class ArgMap
-		{
-		private:
-			typedef std::vector<std::pair<fmt::BasicStringRef<Char>, internal::Arg> > MapType;
-			typedef typename MapType::value_type Pair;
-
-			MapType map_;
-
-		public:
-			FMT_API void init(const ArgList &args);
-
-			const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const
-			{
-				// The list is unsorted, so just return the first matching name.
-				for (typename MapType::const_iterator it = map_.begin(), end = map_.end();
-				it != end; ++it) {
-					if (it->first == name)
-						return &it->second;
-				}
-				return 0;
-			}
-		};
-
-		template <typename Impl, typename Char>
-		class ArgFormatterBase: public ArgVisitor<Impl, void>
-		{
-		private:
-			BasicWriter<Char> &writer_;
-			FormatSpec &spec_;
-
-			FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);
-
-			void write_pointer(const void *p)
-			{
-				spec_.flags_ = HASH_FLAG;
-				spec_.type_ = 'x';
-				writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
-			}
-
-		protected:
-			BasicWriter<Char> &writer()
-			{
-				return writer_;
-			}
-			FormatSpec &spec()
-			{
-				return spec_;
-			}
-
-			void write(bool value)
-			{
-				const char *str_value = value ? "true" : "false";
-				Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
-				writer_.write_str(str, spec_);
-			}
-
-			void write(const char *value)
-			{
-				Arg::StringValue<char> str = { value, value != 0 ? std::strlen(value) : 0 };
-				writer_.write_str(str, spec_);
-			}
-
-		public:
-			ArgFormatterBase(BasicWriter<Char> &w, FormatSpec &s)
-				: writer_(w), spec_(s)
-			{}
-
-			template <typename T>
-			void visit_any_int(T value)
-			{
-				writer_.write_int(value, spec_);
-			}
-
-			template <typename T>
-			void visit_any_double(T value)
-			{
-				writer_.write_double(value, spec_);
-			}
-
-			void visit_bool(bool value)
-			{
-				if (spec_.type_)
-					return visit_any_int(value);
-				write(value);
-			}
-
-			void visit_char(int value)
-			{
-				if (spec_.type_ && spec_.type_ != 'c') {
-					spec_.flags_ |= CHAR_FLAG;
-					writer_.write_int(value, spec_);
-					return;
-				}
-				if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
-					FMT_THROW(FormatError("invalid format specifier for char"));
-				typedef typename BasicWriter<Char>::CharPtr CharPtr;
-				Char fill = internal::CharTraits<Char>::cast(spec_.fill());
-				CharPtr out = CharPtr();
-				const unsigned CHAR_WIDTH = 1;
-				if (spec_.width_ > CHAR_WIDTH) {
-					out = writer_.grow_buffer(spec_.width_);
-					if (spec_.align_ == ALIGN_RIGHT) {
-						std::uninitialized_fill_n(out, spec_.width_ - CHAR_WIDTH, fill);
-						out += spec_.width_ - CHAR_WIDTH;
-					}
-					else if (spec_.align_ == ALIGN_CENTER) {
-						out = writer_.fill_padding(out, spec_.width_,
-							internal::check(CHAR_WIDTH), fill);
-					}
-					else {
-						std::uninitialized_fill_n(out + CHAR_WIDTH,
-							spec_.width_ - CHAR_WIDTH, fill);
-					}
-				}
-				else {
-					out = writer_.grow_buffer(CHAR_WIDTH);
-				}
-				*out = internal::CharTraits<Char>::cast(value);
-			}
-
-			void visit_cstring(const char *value)
-			{
-				if (spec_.type_ == 'p')
-					return write_pointer(value);
-				write(value);
-			}
-
-			void visit_string(Arg::StringValue<char> value)
-			{
-				writer_.write_str(value, spec_);
-			}
-
-			using ArgVisitor<Impl, void>::visit_wstring;
-
-			void visit_wstring(Arg::StringValue<Char> value)
-			{
-				writer_.write_str(value, spec_);
-			}
-
-			void visit_pointer(const void *value)
-			{
-				if (spec_.type_ && spec_.type_ != 'p')
-					report_unknown_type(spec_.type_, "pointer");
-				write_pointer(value);
-			}
-		};
-
-		// An argument formatter.
-		template <typename Char>
-		class BasicArgFormatter:
-			public ArgFormatterBase<BasicArgFormatter<Char>, Char>
-		{
-		private:
-			BasicFormatter<Char> &formatter_;
-			const Char *format_;
-
-		public:
-			BasicArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)
-				: ArgFormatterBase<BasicArgFormatter<Char>, Char>(f.writer(), s),
-				formatter_(f), format_(fmt)
-			{}
-
-			void visit_custom(Arg::CustomValue c)
-			{
-				c.format(&formatter_, c.value, &format_);
-			}
-		};
-
-		class FormatterBase
-		{
-		private:
-			ArgList args_;
-			int next_arg_index_;
-
-			// Returns the argument with specified index.
-			FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);
-
-		protected:
-			const ArgList &args() const
-			{
-				return args_;
-			}
-
-			explicit FormatterBase(const ArgList &args)
-			{
-				args_ = args;
-				next_arg_index_ = 0;
-			}
-
-			// Returns the next argument.
-			Arg next_arg(const char *&error)
-			{
-				if (next_arg_index_ >= 0)
-					return do_get_arg(internal::to_unsigned(next_arg_index_++), error);
-				error = "cannot switch from manual to automatic argument indexing";
-				return Arg();
-			}
-
-			// Checks if manual indexing is used and returns the argument with
-			// specified index.
-			Arg get_arg(unsigned arg_index, const char *&error)
-			{
-				return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
-			}
-
-			bool check_no_auto_index(const char *&error)
-			{
-				if (next_arg_index_ > 0) {
-					error = "cannot switch from automatic to manual argument indexing";
-					return false;
-				}
-				next_arg_index_ = -1;
-				return true;
-			}
-
-			template <typename Char>
-			void write(BasicWriter<Char> &w, const Char *start, const Char *end)
-			{
-				if (start != end)
-					w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
-			}
-		};
-
-		// A printf formatter.
-		template <typename Char>
-		class PrintfFormatter: private FormatterBase
-		{
-		private:
-			void parse_flags(FormatSpec &spec, const Char *&s);
-
-			// Returns the argument with specified index or, if arg_index is equal
-			// to the maximum unsigned value, the next argument.
-			Arg get_arg(const Char *s,
-				unsigned arg_index = (std::numeric_limits<unsigned>::max)());
-
-			// Parses argument index, flags and width and returns the argument index.
-			unsigned parse_header(const Char *&s, FormatSpec &spec);
-
-		public:
-			explicit PrintfFormatter(const ArgList &args): FormatterBase(args)
-			{}
-			FMT_API void format(BasicWriter<Char> &writer,
-				BasicCStringRef<Char> format_str);
-		};
-	}  // namespace internal
-
-	   /** This template formats data and writes the output to a writer. */
-	template <typename CharType, typename ArgFormatter>
-	class BasicFormatter: private internal::FormatterBase
-	{
-	public:
-		/** The character type for the output. */
-		typedef CharType Char;
-
-	private:
-		BasicWriter<Char> &writer_;
-		internal::ArgMap<Char> map_;
-
-		FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
-
-		using internal::FormatterBase::get_arg;
-
-		// Checks if manual indexing is used and returns the argument with
-		// specified name.
-		internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
-
-		// Parses argument index and returns corresponding argument.
-		internal::Arg parse_arg_index(const Char *&s);
-
-		// Parses argument name and returns corresponding argument.
-		internal::Arg parse_arg_name(const Char *&s);
-
-	public:
-		/**
-		\rst
-		Constructs a ``BasicFormatter`` object. References to the arguments and
-		the writer are stored in the formatter object so make sure they have
-		appropriate lifetimes.
-		\endrst
-		*/
-		BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
-			: internal::FormatterBase(args), writer_(w)
-		{}
-
-		/** Returns a reference to the writer associated with this formatter. */
-		BasicWriter<Char> &writer()
-		{
-			return writer_;
-		}
-
-		/** Formats stored arguments and writes the output to the writer. */
-		void format(BasicCStringRef<Char> format_str);
-
-		// Formats a single argument and advances format_str, a format string pointer.
-		const Char *format(const Char *&format_str, const internal::Arg &arg);
-	};
-
-	// Generates a comma-separated list with results of applying f to
-	// numbers 0..n-1.
-# define FMT_GEN(n, f) FMT_GEN##n(f)
-# define FMT_GEN1(f)  f(0)
-# define FMT_GEN2(f)  FMT_GEN1(f),  f(1)
-# define FMT_GEN3(f)  FMT_GEN2(f),  f(2)
-# define FMT_GEN4(f)  FMT_GEN3(f),  f(3)
-# define FMT_GEN5(f)  FMT_GEN4(f),  f(4)
-# define FMT_GEN6(f)  FMT_GEN5(f),  f(5)
-# define FMT_GEN7(f)  FMT_GEN6(f),  f(6)
-# define FMT_GEN8(f)  FMT_GEN7(f),  f(7)
-# define FMT_GEN9(f)  FMT_GEN8(f),  f(8)
-# define FMT_GEN10(f) FMT_GEN9(f),  f(9)
-# define FMT_GEN11(f) FMT_GEN10(f), f(10)
-# define FMT_GEN12(f) FMT_GEN11(f), f(11)
-# define FMT_GEN13(f) FMT_GEN12(f), f(12)
-# define FMT_GEN14(f) FMT_GEN13(f), f(13)
-# define FMT_GEN15(f) FMT_GEN14(f), f(14)
-
-	namespace internal {
-		inline uint64_t make_type()
-		{
-			return 0;
-		}
-
-		template <typename T>
-		inline uint64_t make_type(const T &arg)
-		{
-			return MakeValue< BasicFormatter<char> >::type(arg);
-		}
-
-		template <unsigned N, bool/*IsPacked*/ = (N < ArgList::MAX_PACKED_ARGS)>
-			struct ArgArray;
-
-			template <unsigned N>
-			struct ArgArray<N, true/*IsPacked*/>
-			{
-				typedef Value Type[N > 0 ? N : 1];
-
-				template <typename Formatter, typename T>
-				static Value make(const T &value)
-				{
-					Value result = MakeValue<Formatter>(value);
-					// Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang:
-					// https://github.com/cppformat/cppformat/issues/276
-					(void)result.custom.format;
-					return result;
-				}
-			};
-
-			template <unsigned N>
-			struct ArgArray<N, false/*IsPacked*/>
-			{
-				typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE
-
-				template <typename Formatter, typename T>
-				static Arg make(const T &value)
-				{
-					return MakeArg<Formatter>(value);
-				}
-			};
-
-#if FMT_USE_VARIADIC_TEMPLATES
-			template <typename Arg, typename... Args>
-			inline uint64_t make_type(const Arg &first, const Args & ... tail)
-			{
-				return make_type(first) | (make_type(tail...) << 4);
-			}
-
-#else
-
-			struct ArgType
-			{
-				uint64_t type;
-
-				ArgType(): type(0)
-				{}
-
-				template <typename T>
-				ArgType(const T &arg) : type(make_type(arg))
-				{}
-			};
-
-# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
-
-			inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT))
-			{
-				return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
-					(t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
-					(t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
-					(t12.type << 48) | (t13.type << 52) | (t14.type << 56);
-			}
-#endif
-
-			template <class Char>
-			class FormatBuf: public std::basic_streambuf<Char>
-			{
-			private:
-				typedef typename std::basic_streambuf<Char>::int_type int_type;
-				typedef typename std::basic_streambuf<Char>::traits_type traits_type;
-
-				Buffer<Char> &buffer_;
-				Char *start_;
-
-			public:
-				FormatBuf(Buffer<Char> &buffer): buffer_(buffer), start_(&buffer[0])
-				{
-					this->setp(start_, start_ + buffer_.capacity());
-				}
-
-				int_type overflow(int_type ch = traits_type::eof())
-				{
-					if (!traits_type::eq_int_type(ch, traits_type::eof())) {
-						size_t size = this->size();
-						buffer_.resize(size);
-						buffer_.reserve(size * 2);
-
-						start_ = &buffer_[0];
-						start_[size] = traits_type::to_char_type(ch);
-						this->setp(start_ + size + 1, start_ + size * 2);
-					}
-					return ch;
-				}
-
-				size_t size() const
-				{
-					return to_unsigned(this->pptr() - start_);
-				}
-			};
-	}  // namespace internal
-
-# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
-# define FMT_MAKE_ARG_TYPE(n) T##n
-# define FMT_MAKE_ARG(n) const T##n &v##n
-# define FMT_ASSIGN_char(n) \
-  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)
-# define FMT_ASSIGN_wchar_t(n) \
-  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)
-
-#if FMT_USE_VARIADIC_TEMPLATES
-	   // Defines a variadic function returning void.
-# define FMT_VARIADIC_VOID(func, arg_type) \
-  template <typename... Args> \
-  void func(arg_type arg0, const Args & ... args) { \
-    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
-    typename ArgArray::Type array{ \
-      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
-    func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \
-  }
-
-	   // Defines a variadic constructor.
-# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
-  template <typename... Args> \
-  ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
-    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
-    typename ArgArray::Type array{ \
-      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
-    func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \
-  }
-
-#else
-
-# define FMT_MAKE_REF(n) \
-  fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)
-# define FMT_MAKE_REF2(n) v##n
-
-	   // Defines a wrapper for a function taking one argument of type arg_type
-	   // and n additional arguments of arbitrary types.
-# define FMT_WRAP1(func, arg_type, n) \
-  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
-  inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
-    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    func(arg1, fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
-  }
-
-	   // Emulates a variadic function returning void on a pre-C++11 compiler.
-# define FMT_VARIADIC_VOID(func, arg_type) \
-  inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
-  FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
-  FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
-  FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
-  FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \
-  FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)
-
-# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
-  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
-  ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
-    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    func(arg0, arg1, fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
-  }
-
-	   // Emulates a variadic constructor on a pre-C++11 compiler.
-# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)
-#endif
-
-	   // Generates a comma-separated list with results of applying f to pairs
-	   // (argument, index).
-#define FMT_FOR_EACH1(f, x0) f(x0, 0)
-#define FMT_FOR_EACH2(f, x0, x1) \
-  FMT_FOR_EACH1(f, x0), f(x1, 1)
-#define FMT_FOR_EACH3(f, x0, x1, x2) \
-  FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)
-#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \
-  FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)
-#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \
-  FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)
-#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \
-  FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)
-#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \
-  FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)
-#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \
-  FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)
-#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \
-  FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)
-#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \
-  FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)
-
-	   /**
-	   An error returned by an operating system or a language runtime,
-	   for example a file opening error.
-	   */
-	class SystemError: public internal::RuntimeError
-	{
-	private:
-		void init(int err_code, CStringRef format_str, ArgList args);
-
-	protected:
-		int error_code_;
-
-		typedef char Char;  // For FMT_VARIADIC_CTOR.
-
-		SystemError()
-		{}
-
-	public:
-		/**
-		\rst
-		Constructs a :class:`fmt::SystemError` object with the description
-		of the form
-
-		.. parsed-literal::
-		*<message>*: *<system-message>*
-
-		where *<message>* is the formatted message and *<system-message>* is
-		the system message corresponding to the error code.
-		*error_code* is a system error code as given by ``errno``.
-		If *error_code* is not a valid error code such as -1, the system message
-		may look like "Unknown error -1" and is platform-dependent.
-
-		**Example**::
-
-		// This throws a SystemError with the description
-		//   cannot open file 'madeup': No such file or directory
-		// or similar (system message may vary).
-		const char *filename = "madeup";
-		std::FILE *file = std::fopen(filename, "r");
-		if (!file)
-		throw fmt::SystemError(errno, "cannot open file '{}'", filename);
-		\endrst
-		*/
-		SystemError(int error_code, CStringRef message)
-		{
-			init(error_code, message, ArgList());
-		}
-		FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)
-
-			int error_code() const
-		{
-			return error_code_;
-		}
-	};
-
-	/**
-	\rst
-	This template provides operations for formatting and writing data into
-	a character stream. The output is stored in a buffer provided by a subclass
-	such as :class:`fmt::BasicMemoryWriter`.
-
-	You can use one of the following typedefs for common character types:
-
-	+---------+----------------------+
-	| Type    | Definition           |
-	+=========+======================+
-	| Writer  | BasicWriter<char>    |
-	+---------+----------------------+
-	| WWriter | BasicWriter<wchar_t> |
-	+---------+----------------------+
-
-	\endrst
-	*/
-	template <typename Char>
-	class BasicWriter
-	{
-	private:
-		// Output buffer.
-		Buffer<Char> &buffer_;
-
-		FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
-
-		typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
-
-#if FMT_SECURE_SCL
-		// Returns pointer value.
-		static Char *get(CharPtr p)
-		{
-			return p.base();
-		}
-#else
-		static Char *get(Char *p)
-		{
-			return p;
-		}
-#endif
-
-		// Fills the padding around the content and returns the pointer to the
-		// content area.
-		static CharPtr fill_padding(CharPtr buffer,
-			unsigned total_size, std::size_t content_size, wchar_t fill);
-
-		// Grows the buffer by n characters and returns a pointer to the newly
-		// allocated area.
-		CharPtr grow_buffer(std::size_t n)
-		{
-			std::size_t size = buffer_.size();
-			buffer_.resize(size + n);
-			return internal::make_ptr(&buffer_[size], n);
-		}
-
-		// Writes an unsigned decimal integer.
-		template <typename UInt>
-		Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0)
-		{
-			unsigned num_digits = internal::count_digits(value);
-			Char *ptr = get(grow_buffer(prefix_size + num_digits));
-			internal::format_decimal(ptr + prefix_size, value, num_digits);
-			return ptr;
-		}
-
-		// Writes a decimal integer.
-		template <typename Int>
-		void write_decimal(Int value)
-		{
-			typedef typename internal::IntTraits<Int>::MainType MainType;
-			MainType abs_value = static_cast<MainType>(value);
-			if (internal::is_negative(value)) {
-				abs_value = 0 - abs_value;
-				*write_unsigned_decimal(abs_value, 1) = '-';
-			}
-			else {
-				write_unsigned_decimal(abs_value, 0);
-			}
-		}
-
-		// Prepare a buffer for integer formatting.
-		CharPtr prepare_int_buffer(unsigned num_digits,
-			const EmptySpec &, const char *prefix, unsigned prefix_size)
-		{
-			unsigned size = prefix_size + num_digits;
-			CharPtr p = grow_buffer(size);
-			std::uninitialized_copy(prefix, prefix + prefix_size, p);
-			return p + size - 1;
-		}
-
-		template <typename Spec>
-		CharPtr prepare_int_buffer(unsigned num_digits,
-			const Spec &spec, const char *prefix, unsigned prefix_size);
-
-		// Formats an integer.
-		template <typename T, typename Spec>
-		void write_int(T value, Spec spec);
-
-		// Formats a floating-point number (double or long double).
-		template <typename T>
-		void write_double(T value, const FormatSpec &spec);
-
-		// Writes a formatted string.
-		template <typename StrChar>
-		CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);
-
-		template <typename StrChar>
-		void write_str(const internal::Arg::StringValue<StrChar> &str,
-			const FormatSpec &spec);
-
-		// This following methods are private to disallow writing wide characters
-		// and strings to a char stream. If you want to print a wide string as a
-		// pointer as std::ostream does, cast it to const void*.
-		// Do not implement!
-		void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
-		void operator<<(
-			typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
-
-		// Appends floating-point length specifier to the format string.
-		// The second argument is only used for overload resolution.
-		void append_float_length(Char *&format_ptr, long double)
-		{
-			*format_ptr++ = 'L';
-		}
-
-		template<typename T>
-		void append_float_length(Char *&, T)
-		{}
-
-		template <typename Impl, typename Char_>
-		friend class internal::ArgFormatterBase;
-
-		friend class internal::PrintfArgFormatter<Char>;
-
-	protected:
-		/**
-		Constructs a ``BasicWriter`` object.
-		*/
-		explicit BasicWriter(Buffer<Char> &b): buffer_(b)
-		{}
-
-	public:
-		/**
-		\rst
-		Destroys a ``BasicWriter`` object.
-		\endrst
-		*/
-		virtual ~BasicWriter()
-		{}
-
-		/**
-		Returns the total number of characters written.
-		*/
-		std::size_t size() const
-		{
-			return buffer_.size();
-		}
-
-		/**
-		Returns a pointer to the output buffer content. No terminating null
-		character is appended.
-		*/
-		const Char *data() const FMT_NOEXCEPT
-		{
-			return &buffer_[0];
-		}
-
-		/**
-		Returns a pointer to the output buffer content with terminating null
-		character appended.
-		*/
-		const Char *c_str() const
-		{
-			std::size_t size = buffer_.size();
-			buffer_.reserve(size + 1);
-			buffer_[size] = '\0';
-			return &buffer_[0];
-		}
-
-		/**
-		\rst
-		Returns the content of the output buffer as an `std::string`.
-		\endrst
-		*/
-		std::basic_string<Char> str() const
-		{
-			return std::basic_string<Char>(&buffer_[0], buffer_.size());
-		}
-
-		/**
-		\rst
-		Writes formatted data.
-
-		*args* is an argument list representing arbitrary arguments.
-
-		**Example**::
-
-		MemoryWriter out;
-		out.write("Current point:\n");
-		out.write("({:+f}, {:+f})", -3.14, 3.14);
-
-		This will write the following output to the ``out`` object:
-
-		.. code-block:: none
-
-		Current point:
-		(-3.140000, +3.140000)
-
-		The output can be accessed using :func:`data()`, :func:`c_str` or
-		:func:`str` methods.
-
-		See also :ref:`syntax`.
-		\endrst
-		*/
-		void write(BasicCStringRef<Char> format, ArgList args)
-		{
-			BasicFormatter<Char>(args, *this).format(format);
-		}
-		FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
-
-			BasicWriter &operator<<(int value)
-		{
-			write_decimal(value);
-			return *this;
-		}
-		BasicWriter &operator<<(unsigned value)
-		{
-			return *this << IntFormatSpec<unsigned>(value);
-		}
-		BasicWriter &operator<<(long value)
-		{
-			write_decimal(value);
-			return *this;
-		}
-		BasicWriter &operator<<(unsigned long value)
-		{
-			return *this << IntFormatSpec<unsigned long>(value);
-		}
-		BasicWriter &operator<<(LongLong value)
-		{
-			write_decimal(value);
-			return *this;
-		}
-
-		/**
-		\rst
-		Formats *value* and writes it to the stream.
-		\endrst
-		*/
-		BasicWriter &operator<<(ULongLong value)
-		{
-			return *this << IntFormatSpec<ULongLong>(value);
-		}
-
-		BasicWriter &operator<<(double value)
-		{
-			write_double(value, FormatSpec());
-			return *this;
-		}
-
-		/**
-		\rst
-		Formats *value* using the general format for floating-point numbers
-		(``'g'``) and writes it to the stream.
-		\endrst
-		*/
-		BasicWriter &operator<<(long double value)
-		{
-			write_double(value, FormatSpec());
-			return *this;
-		}
-
-		/**
-		Writes a character to the stream.
-		*/
-		BasicWriter &operator<<(char value)
-		{
-			buffer_.push_back(value);
-			return *this;
-		}
-
-		BasicWriter &operator<<(
-			typename internal::WCharHelper<wchar_t, Char>::Supported value)
-		{
-			buffer_.push_back(value);
-			return *this;
-		}
-
-		/**
-		\rst
-		Writes *value* to the stream.
-		\endrst
-		*/
-		BasicWriter &operator<<(fmt::BasicStringRef<Char> value)
-		{
-			const Char *str = value.data();
-			buffer_.append(str, str + value.size());
-			return *this;
-		}
-
-		BasicWriter &operator<<(
-			typename internal::WCharHelper<StringRef, Char>::Supported value)
-		{
-			const char *str = value.data();
-			buffer_.append(str, str + value.size());
-			return *this;
-		}
-
-		template <typename T, typename Spec, typename FillChar>
-		BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec)
-		{
-			internal::CharTraits<Char>::convert(FillChar());
-			write_int(spec.value(), spec);
-			return *this;
-		}
-
-		template <typename StrChar>
-		BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec)
-		{
-			const StrChar *s = spec.str();
-			write_str(s, std::char_traits<Char>::length(s), spec);
-			return *this;
-		}
-
-		void clear() FMT_NOEXCEPT
-		{
-			buffer_.clear();
-		}
-	};
-
-	template <typename Char>
-	template <typename StrChar>
-	typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
-		const StrChar *s, std::size_t size, const AlignSpec &spec)
-	{
-		CharPtr out = CharPtr();
-		if (spec.width() > size) {
-			out = grow_buffer(spec.width());
-			Char fill = internal::CharTraits<Char>::cast(spec.fill());
-			if (spec.align() == ALIGN_RIGHT) {
-				std::uninitialized_fill_n(out, spec.width() - size, fill);
-				out += spec.width() - size;
-			}
-			else if (spec.align() == ALIGN_CENTER) {
-				out = fill_padding(out, spec.width(), size, fill);
-			}
-			else {
-				std::uninitialized_fill_n(out + size, spec.width() - size, fill);
-			}
-		}
-		else {
-			out = grow_buffer(size);
-		}
-		std::uninitialized_copy(s, s + size, out);
-		return out;
-	}
-
-	template <typename Char>
-	template <typename StrChar>
-	void BasicWriter<Char>::write_str(
-		const internal::Arg::StringValue<StrChar> &s, const FormatSpec &spec)
-	{
-		// Check if StrChar is convertible to Char.
-		internal::CharTraits<Char>::convert(StrChar());
-		if (spec.type_ && spec.type_ != 's')
-			internal::report_unknown_type(spec.type_, "string");
-		const StrChar *str_value = s.value;
-		std::size_t str_size = s.size;
-		if (str_size == 0) {
-			if (!str_value) {
-				FMT_THROW(FormatError("string pointer is null"));
-				return;
-			}
-		}
-		std::size_t precision = static_cast<std::size_t>(spec.precision_);
-		if (spec.precision_ >= 0 && precision < str_size)
-			str_size = precision;
-		write_str(str_value, str_size, spec);
-	}
-
-	template <typename Char>
-	typename BasicWriter<Char>::CharPtr
-		BasicWriter<Char>::fill_padding(
-			CharPtr buffer, unsigned total_size,
-			std::size_t content_size, wchar_t fill)
-	{
-		std::size_t padding = total_size - content_size;
-		std::size_t left_padding = padding / 2;
-		Char fill_char = internal::CharTraits<Char>::cast(fill);
-		std::uninitialized_fill_n(buffer, left_padding, fill_char);
-		buffer += left_padding;
-		CharPtr content = buffer;
-		std::uninitialized_fill_n(buffer + content_size,
-			padding - left_padding, fill_char);
-		return content;
-	}
-
-	template <typename Char>
-	template <typename Spec>
-	typename BasicWriter<Char>::CharPtr
-		BasicWriter<Char>::prepare_int_buffer(
-			unsigned num_digits, const Spec &spec,
-			const char *prefix, unsigned prefix_size)
-	{
-		unsigned width = spec.width();
-		Alignment align = spec.align();
-		Char fill = internal::CharTraits<Char>::cast(spec.fill());
-		if (spec.precision() > static_cast<int>(num_digits)) {
-			// Octal prefix '0' is counted as a digit, so ignore it if precision
-			// is specified.
-			if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
-				--prefix_size;
-			unsigned number_size =
-				prefix_size + internal::to_unsigned(spec.precision());
-			AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
-			if (number_size >= width)
-				return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
-			buffer_.reserve(width);
-			unsigned fill_size = width - number_size;
-			if (align != ALIGN_LEFT) {
-				CharPtr p = grow_buffer(fill_size);
-				std::uninitialized_fill(p, p + fill_size, fill);
-			}
-			CharPtr result = prepare_int_buffer(
-				num_digits, subspec, prefix, prefix_size);
-			if (align == ALIGN_LEFT) {
-				CharPtr p = grow_buffer(fill_size);
-				std::uninitialized_fill(p, p + fill_size, fill);
-			}
-			return result;
-		}
-		unsigned size = prefix_size + num_digits;
-		if (width <= size) {
-			CharPtr p = grow_buffer(size);
-			std::uninitialized_copy(prefix, prefix + prefix_size, p);
-			return p + size - 1;
-		}
-		CharPtr p = grow_buffer(width);
-		CharPtr end = p + width;
-		if (align == ALIGN_LEFT) {
-			std::uninitialized_copy(prefix, prefix + prefix_size, p);
-			p += size;
-			std::uninitialized_fill(p, end, fill);
-		}
-		else if (align == ALIGN_CENTER) {
-			p = fill_padding(p, width, size, fill);
-			std::uninitialized_copy(prefix, prefix + prefix_size, p);
-			p += size;
-		}
-		else {
-			if (align == ALIGN_NUMERIC) {
-				if (prefix_size != 0) {
-					p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
-					size -= prefix_size;
-				}
-			}
-			else {
-				std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
-			}
-			std::uninitialized_fill(p, end - size, fill);
-			p = end;
-		}
-		return p - 1;
-	}
-
-	template <typename Char>
-	template <typename T, typename Spec>
-	void BasicWriter<Char>::write_int(T value, Spec spec)
-	{
-		unsigned prefix_size = 0;
-		typedef typename internal::IntTraits<T>::MainType UnsignedType;
-		UnsignedType abs_value = static_cast<UnsignedType>(value);
-		char prefix[4] = "";
-		if (internal::is_negative(value)) {
-			prefix[0] = '-';
-			++prefix_size;
-			abs_value = 0 - abs_value;
-		}
-		else if (spec.flag(SIGN_FLAG)) {
-			prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
-			++prefix_size;
-		}
-		switch (spec.type()) {
-		case 0: case 'd': {
-			unsigned num_digits = internal::count_digits(abs_value);
-			CharPtr p = prepare_int_buffer(
-				num_digits, spec, prefix, prefix_size) + 1 - num_digits;
-			internal::format_decimal(get(p), abs_value, num_digits);
-			break;
-		}
-		case 'x': case 'X': {
-			UnsignedType n = abs_value;
-			if (spec.flag(HASH_FLAG)) {
-				prefix[prefix_size++] = '0';
-				prefix[prefix_size++] = spec.type();
-			}
-			unsigned num_digits = 0;
-			do {
-				++num_digits;
-			} while ((n >>= 4) != 0);
-			Char *p = get(prepare_int_buffer(
-				num_digits, spec, prefix, prefix_size));
-			n = abs_value;
-			const char *digits = spec.type() == 'x' ?
-				"0123456789abcdef" : "0123456789ABCDEF";
-			do {
-				*p-- = digits[n & 0xf];
-			} while ((n >>= 4) != 0);
-			break;
-		}
-		case 'b': case 'B': {
-			UnsignedType n = abs_value;
-			if (spec.flag(HASH_FLAG)) {
-				prefix[prefix_size++] = '0';
-				prefix[prefix_size++] = spec.type();
-			}
-			unsigned num_digits = 0;
-			do {
-				++num_digits;
-			} while ((n >>= 1) != 0);
-			Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
-			n = abs_value;
-			do {
-				*p-- = static_cast<Char>('0' + (n & 1));
-			} while ((n >>= 1) != 0);
-			break;
-		}
-		case 'o': {
-			UnsignedType n = abs_value;
-			if (spec.flag(HASH_FLAG))
-				prefix[prefix_size++] = '0';
-			unsigned num_digits = 0;
-			do {
-				++num_digits;
-			} while ((n >>= 3) != 0);
-			Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
-			n = abs_value;
-			do {
-				*p-- = static_cast<Char>('0' + (n & 7));
-			} while ((n >>= 3) != 0);
-			break;
-		}
-		default:
-			internal::report_unknown_type(
-				spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
-			break;
-		}
-	}
-
-	template <typename Char>
-	template <typename T>
-	void BasicWriter<Char>::write_double(T value, const FormatSpec &spec)
-	{
-		// Check type.
-		char type = spec.type();
-		bool upper = false;
-		switch (type) {
-		case 0:
-			type = 'g';
-			break;
-		case 'e': case 'f': case 'g': case 'a':
-			break;
-		case 'F':
-#ifdef _MSC_VER
-			// MSVC's printf doesn't support 'F'.
-			type = 'f';
-#endif
-			// Fall through.
-		case 'E': case 'G': case 'A':
-			upper = true;
-			break;
-		default:
-			internal::report_unknown_type(type, "double");
-			break;
-		}
-
-		char sign = 0;
-		// Use isnegative instead of value < 0 because the latter is always
-		// false for NaN.
-		if (internal::FPUtil::isnegative(static_cast<double>(value))) {
-			sign = '-';
-			value = -value;
-		}
-		else if (spec.flag(SIGN_FLAG)) {
-			sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
-		}
-
-		if (internal::FPUtil::isnotanumber(value)) {
-			// Format NaN ourselves because sprintf's output is not consistent
-			// across platforms.
-			std::size_t nan_size = 4;
-			const char *nan = upper ? " NAN" : " nan";
-			if (!sign) {
-				--nan_size;
-				++nan;
-			}
-			CharPtr out = write_str(nan, nan_size, spec);
-			if (sign)
-				*out = sign;
-			return;
-		}
-
-		if (internal::FPUtil::isinfinity(value)) {
-			// Format infinity ourselves because sprintf's output is not consistent
-			// across platforms.
-			std::size_t inf_size = 4;
-			const char *inf = upper ? " INF" : " inf";
-			if (!sign) {
-				--inf_size;
-				++inf;
-			}
-			CharPtr out = write_str(inf, inf_size, spec);
-			if (sign)
-				*out = sign;
-			return;
-		}
-
-		std::size_t offset = buffer_.size();
-		unsigned width = spec.width();
-		if (sign) {
-			buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
-			if (width > 0)
-				--width;
-			++offset;
-		}
-
-		// Build format string.
-		enum
-		{
-			MAX_FORMAT_SIZE = 10
-		}; // longest format: %#-*.*Lg
-		Char format[MAX_FORMAT_SIZE];
-		Char *format_ptr = format;
-		*format_ptr++ = '%';
-		unsigned width_for_sprintf = width;
-		if (spec.flag(HASH_FLAG))
-			*format_ptr++ = '#';
-		if (spec.align() == ALIGN_CENTER) {
-			width_for_sprintf = 0;
-		}
-		else {
-			if (spec.align() == ALIGN_LEFT)
-				*format_ptr++ = '-';
-			if (width != 0)
-				*format_ptr++ = '*';
-		}
-		if (spec.precision() >= 0) {
-			*format_ptr++ = '.';
-			*format_ptr++ = '*';
-		}
-
-		append_float_length(format_ptr, value);
-		*format_ptr++ = type;
-		*format_ptr = '\0';
-
-		// Format using snprintf.
-		Char fill = internal::CharTraits<Char>::cast(spec.fill());
-		unsigned n = 0;
-		Char *start = 0;
-		for (;;) {
-			std::size_t buffer_size = buffer_.capacity() - offset;
-#ifdef _MSC_VER
-			// MSVC's vsnprintf_s doesn't work with zero size, so reserve
-			// space for at least one extra character to make the size non-zero.
-			// Note that the buffer's capacity will increase by more than 1.
-			if (buffer_size == 0) {
-				buffer_.reserve(offset + 1);
-				buffer_size = buffer_.capacity() - offset;
-			}
-#endif
-			start = &buffer_[offset];
-			int result = internal::CharTraits<Char>::format_float(
-				start, buffer_size, format, width_for_sprintf, spec.precision(), value);
-			if (result >= 0) {
-				n = internal::to_unsigned(result);
-				if (offset + n < buffer_.capacity())
-					break;  // The buffer is large enough - continue with formatting.
-				buffer_.reserve(offset + n + 1);
-			}
-			else {
-				// If result is negative we ask to increase the capacity by at least 1,
-				// but as std::vector, the buffer grows exponentially.
-				buffer_.reserve(buffer_.capacity() + 1);
-			}
-		}
-		if (sign) {
-			if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
-				*start != ' ') {
-				*(start - 1) = sign;
-				sign = 0;
-			}
-			else {
-				*(start - 1) = fill;
-			}
-			++n;
-		}
-		if (spec.align() == ALIGN_CENTER && spec.width() > n) {
-			width = spec.width();
-			CharPtr p = grow_buffer(width);
-			std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
-			fill_padding(p, spec.width(), n, fill);
-			return;
-		}
-		if (spec.fill() != ' ' || sign) {
-			while (*start == ' ')
-				*start++ = fill;
-			if (sign)
-				*(start - 1) = sign;
-		}
-		grow_buffer(n);
-	}
-
-	/**
-	\rst
-	This class template provides operations for formatting and writing data
-	into a character stream. The output is stored in a memory buffer that grows
-	dynamically.
-
-	You can use one of the following typedefs for common character types
-	and the standard allocator:
-
-	+---------------+-----------------------------------------------------+
-	| Type          | Definition                                          |
-	+===============+=====================================================+
-	| MemoryWriter  | BasicMemoryWriter<char, std::allocator<char>>       |
-	+---------------+-----------------------------------------------------+
-	| WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
-	+---------------+-----------------------------------------------------+
-
-	**Example**::
-
-	MemoryWriter out;
-	out << "The answer is " << 42 << "\n";
-	out.write("({:+f}, {:+f})", -3.14, 3.14);
-
-	This will write the following output to the ``out`` object:
-
-	.. code-block:: none
-
-	The answer is 42
-	(-3.140000, +3.140000)
-
-	The output can be converted to an ``std::string`` with ``out.str()`` or
-	accessed as a C string with ``out.c_str()``.
-	\endrst
-	*/
-	template <typename Char, typename Allocator = std::allocator<Char> >
-	class BasicMemoryWriter: public BasicWriter<Char>
-	{
-	private:
-		internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
-
-	public:
-		explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
-			: BasicWriter<Char>(buffer_), buffer_(alloc)
-		{}
-
-#if FMT_USE_RVALUE_REFERENCES
-		/**
-		\rst
-		Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
-		of the other object to it.
-		\endrst
-		*/
-		BasicMemoryWriter(BasicMemoryWriter &&other)
-			: BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_))
-		{}
-
-		/**
-		\rst
-		Moves the content of the other ``BasicMemoryWriter`` object to this one.
-		\endrst
-		*/
-		BasicMemoryWriter &operator=(BasicMemoryWriter &&other)
-		{
-			buffer_ = std::move(other.buffer_);
-			return *this;
-		}
-#endif
-	};
-
-	typedef BasicMemoryWriter<char> MemoryWriter;
-	typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
-
-	/**
-	\rst
-	This class template provides operations for formatting and writing data
-	into a fixed-size array. For writing into a dynamically growing buffer
-	use :class:`fmt::BasicMemoryWriter`.
-
-	Any write method will throw ``std::runtime_error`` if the output doesn't fit
-	into the array.
-
-	You can use one of the following typedefs for common character types:
-
-	+--------------+---------------------------+
-	| Type         | Definition                |
-	+==============+===========================+
-	| ArrayWriter  | BasicArrayWriter<char>    |
-	+--------------+---------------------------+
-	| WArrayWriter | BasicArrayWriter<wchar_t> |
-	+--------------+---------------------------+
-	\endrst
-	*/
-	template <typename Char>
-	class BasicArrayWriter: public BasicWriter<Char>
-	{
-	private:
-		internal::FixedBuffer<Char> buffer_;
-
-	public:
-		/**
-		\rst
-		Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
-		given size.
-		\endrst
-		*/
-		BasicArrayWriter(Char *array, std::size_t size)
-			: BasicWriter<Char>(buffer_), buffer_(array, size)
-		{}
-
-		/**
-		\rst
-		Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
-		size known at compile time.
-		\endrst
-		*/
-		template <std::size_t SIZE>
-		explicit BasicArrayWriter(Char(&array)[SIZE])
-			: BasicWriter<Char>(buffer_), buffer_(array, SIZE)
-		{}
-	};
-
-	typedef BasicArrayWriter<char> ArrayWriter;
-	typedef BasicArrayWriter<wchar_t> WArrayWriter;
-
-	// Formats a value.
-	template <typename Char, typename T>
-	void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value)
-	{
-		internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
-
-		internal::FormatBuf<Char> format_buf(buffer);
-		std::basic_ostream<Char> output(&format_buf);
-		output << value;
-
-		BasicStringRef<Char> str(&buffer[0], format_buf.size());
-		typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
-		format_str = f.format(format_str, MakeArg(str));
-	}
-
-	// Reports a system error without throwing an exception.
-	// Can be used to report errors from destructors.
-	FMT_API void report_system_error(int error_code,
-		StringRef message) FMT_NOEXCEPT;
-
-#if FMT_USE_WINDOWS_H
-
-	/** A Windows error. */
-	class WindowsError: public SystemError
-	{
-	private:
-		FMT_API void init(int error_code, CStringRef format_str, ArgList args);
-
-	public:
-		/**
-		\rst
-		Constructs a :class:`fmt::WindowsError` object with the description
-		of the form
-
-		.. parsed-literal::
-		*<message>*: *<system-message>*
-
-		where *<message>* is the formatted message and *<system-message>* is the
-		system message corresponding to the error code.
-		*error_code* is a Windows error code as given by ``GetLastError``.
-		If *error_code* is not a valid error code such as -1, the system message
-		will look like "error -1".
-
-		**Example**::
-
-		// This throws a WindowsError with the description
-		//   cannot open file 'madeup': The system cannot find the file specified.
-		// or similar (system message may vary).
-		const char *filename = "madeup";
-		LPOFSTRUCT of = LPOFSTRUCT();
-		HFILE file = OpenFile(filename, &of, OF_READ);
-		if (file == HFILE_ERROR) {
-		throw fmt::WindowsError(GetLastError(),
-		"cannot open file '{}'", filename);
-		}
-		\endrst
-		*/
-		WindowsError(int error_code, CStringRef message)
-		{
-			init(error_code, message, ArgList());
-		}
-		FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
-	};
-
-	// Reports a Windows error without throwing an exception.
-	// Can be used to report errors from destructors.
-	FMT_API void report_windows_error(int error_code,
-		StringRef message) FMT_NOEXCEPT;
-
-#endif
-
-	enum Color
-	{
-		BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE
-	};
-
-	/**
-	Formats a string and prints it to stdout using ANSI escape sequences
-	to specify color (experimental).
-	Example:
-	print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
-	*/
-	FMT_API void print_colored(Color c, CStringRef format, ArgList args);
-
-	/**
-	\rst
-	Formats arguments and returns the result as a string.
-
-	**Example**::
-
-	std::string message = format("The answer is {}", 42);
-	\endrst
-	*/
-	inline std::string format(CStringRef format_str, ArgList args)
-	{
-		MemoryWriter w;
-		w.write(format_str, args);
-		return w.str();
-	}
-
-	inline std::wstring format(WCStringRef format_str, ArgList args)
-	{
-		WMemoryWriter w;
-		w.write(format_str, args);
-		return w.str();
-	}
-
-	/**
-	\rst
-	Prints formatted data to the file *f*.
-
-	**Example**::
-
-	print(stderr, "Don't {}!", "panic");
-	\endrst
-	*/
-	FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args);
-
-	/**
-	\rst
-	Prints formatted data to ``stdout``.
-
-	**Example**::
-
-	print("Elapsed time: {0:.2f} seconds", 1.23);
-	\endrst
-	*/
-	FMT_API void print(CStringRef format_str, ArgList args);
-
-	template <typename Char>
-	void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args)
-	{
-		internal::PrintfFormatter<Char>(args).format(w, format);
-	}
-
-	/**
-	\rst
-	Formats arguments and returns the result as a string.
-
-	**Example**::
-
-	std::string message = fmt::sprintf("The answer is %d", 42);
-	\endrst
-	*/
-	inline std::string sprintf(CStringRef format, ArgList args)
-	{
-		MemoryWriter w;
-		printf(w, format, args);
-		return w.str();
-	}
-
-	inline std::wstring sprintf(WCStringRef format, ArgList args)
-	{
-		WMemoryWriter w;
-		printf(w, format, args);
-		return w.str();
-	}
-
-	/**
-	\rst
-	Prints formatted data to the file *f*.
-
-	**Example**::
-
-	fmt::fprintf(stderr, "Don't %s!", "panic");
-	\endrst
-	*/
-	FMT_API int fprintf(std::FILE *f, CStringRef format, ArgList args);
-
-	/**
-	\rst
-	Prints formatted data to ``stdout``.
-
-	**Example**::
-
-	fmt::printf("Elapsed time: %.2f seconds", 1.23);
-	\endrst
-	*/
-	inline int printf(CStringRef format, ArgList args)
-	{
-		return fprintf(stdout, format, args);
-	}
-
-	/**
-	Fast integer formatter.
-	*/
-	class FormatInt
-	{
-	private:
-		// Buffer should be large enough to hold all digits (digits10 + 1),
-		// a sign and a null character.
-		enum
-		{
-			BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3
-		};
-		mutable char buffer_[BUFFER_SIZE];
-		char *str_;
-
-		// Formats value in reverse and returns the number of digits.
-		char *format_decimal(ULongLong value)
-		{
-			char *buffer_end = buffer_ + BUFFER_SIZE - 1;
-			while (value >= 100) {
-				// Integer division is slow so do it for a group of two digits instead
-				// of for every digit. The idea comes from the talk by Alexandrescu
-				// "Three Optimization Tips for C++". See speed-test for a comparison.
-				unsigned index = static_cast<unsigned>((value % 100) * 2);
-				value /= 100;
-				*--buffer_end = internal::Data::DIGITS[index + 1];
-				*--buffer_end = internal::Data::DIGITS[index];
-			}
-			if (value < 10) {
-				*--buffer_end = static_cast<char>('0' + value);
-				return buffer_end;
-			}
-			unsigned index = static_cast<unsigned>(value * 2);
-			*--buffer_end = internal::Data::DIGITS[index + 1];
-			*--buffer_end = internal::Data::DIGITS[index];
-			return buffer_end;
-		}
-
-		void FormatSigned(LongLong value)
-		{
-			ULongLong abs_value = static_cast<ULongLong>(value);
-			bool negative = value < 0;
-			if (negative)
-				abs_value = 0 - abs_value;
-			str_ = format_decimal(abs_value);
-			if (negative)
-				*--str_ = '-';
-		}
-
-	public:
-		explicit FormatInt(int value)
-		{
-			FormatSigned(value);
-		}
-		explicit FormatInt(long value)
-		{
-			FormatSigned(value);
-		}
-		explicit FormatInt(LongLong value)
-		{
-			FormatSigned(value);
-		}
-		explicit FormatInt(unsigned value): str_(format_decimal(value))
-		{}
-		explicit FormatInt(unsigned long value): str_(format_decimal(value))
-		{}
-		explicit FormatInt(ULongLong value): str_(format_decimal(value))
-		{}
-
-		/** Returns the number of characters written to the output buffer. */
-		std::size_t size() const
-		{
-			return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
-		}
-
-		/**
-		Returns a pointer to the output buffer content. No terminating null
-		character is appended.
-		*/
-		const char *data() const
-		{
-			return str_;
-		}
-
-		/**
-		Returns a pointer to the output buffer content with terminating null
-		character appended.
-		*/
-		const char *c_str() const
-		{
-			buffer_[BUFFER_SIZE - 1] = '\0';
-			return str_;
-		}
-
-		/**
-		\rst
-		Returns the content of the output buffer as an ``std::string``.
-		\endrst
-		*/
-		std::string str() const
-		{
-			return std::string(str_, size());
-		}
-	};
-
-	// Formats a decimal integer value writing into buffer and returns
-	// a pointer to the end of the formatted string. This function doesn't
-	// write a terminating null character.
-	template <typename T>
-	inline void format_decimal(char *&buffer, T value)
-	{
-		typedef typename internal::IntTraits<T>::MainType MainType;
-		MainType abs_value = static_cast<MainType>(value);
-		if (internal::is_negative(value)) {
-			*buffer++ = '-';
-			abs_value = 0 - abs_value;
-		}
-		if (abs_value < 100) {
-			if (abs_value < 10) {
-				*buffer++ = static_cast<char>('0' + abs_value);
-				return;
-			}
-			unsigned index = static_cast<unsigned>(abs_value * 2);
-			*buffer++ = internal::Data::DIGITS[index];
-			*buffer++ = internal::Data::DIGITS[index + 1];
-			return;
-		}
-		unsigned num_digits = internal::count_digits(abs_value);
-		internal::format_decimal(buffer, abs_value, num_digits);
-		buffer += num_digits;
-	}
-
-	/**
-	\rst
-	Returns a named argument for formatting functions.
-
-	**Example**::
-
-	print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
-
-	\endrst
-	*/
-	template <typename T>
-	inline internal::NamedArg<char> arg(StringRef name, const T &arg)
-	{
-		return internal::NamedArg<char>(name, arg);
-	}
-
-	template <typename T>
-	inline internal::NamedArg<wchar_t> arg(WStringRef name, const T &arg)
-	{
-		return internal::NamedArg<wchar_t>(name, arg);
-	}
-
-	// The following two functions are deleted intentionally to disable
-	// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``.
-	template <typename Char>
-	void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
-	template <typename Char>
-	void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
-}
-
-#if FMT_GCC_VERSION
-// Use the system_header pragma to suppress warnings about variadic macros
-// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't
-// work. It is used at the end because we want to suppress as little warnings
-// as possible.
-# pragma GCC system_header
-#endif
-
-// This is used to work around VC++ bugs in handling variadic macros.
-#define FMT_EXPAND(args) args
-
-// Returns the number of arguments.
-// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s.
-#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())
-#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))
-#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
-
-#define FMT_CONCAT(a, b) a##b
-#define FMT_FOR_EACH_(N, f, ...) \
-  FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))
-#define FMT_FOR_EACH(f, ...) \
-  FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))
-
-#define FMT_ADD_ARG_NAME(type, index) type arg##index
-#define FMT_GET_ARG_NAME(type, index) arg##index
-
-#if FMT_USE_VARIADIC_TEMPLATES
-# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
-  template <typename... Args> \
-  ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
-      const Args & ... args) { \
-    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
-    typename ArgArray::Type array{ \
-      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
-    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
-      fmt::ArgList(fmt::internal::make_type(args...), array)); \
-  }
-#else
-// Defines a wrapper for a function taking __VA_ARGS__ arguments
-// and n additional arguments of arbitrary types.
-# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \
-  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
-  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
-      FMT_GEN(n, FMT_MAKE_ARG)) { \
-    fmt::internal::ArgArray<n>::Type arr; \
-    FMT_GEN(n, FMT_ASSIGN_##Char); \
-    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
-  }
-
-# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
-  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \
-    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \
-  } \
-  FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)
-#endif  // FMT_USE_VARIADIC_TEMPLATES
-
-/**
-\rst
-Defines a variadic function with the specified return type, function name
-and argument types passed as variable arguments to this macro.
-
-**Example**::
-
-void print_error(const char *file, int line, const char *format,
-fmt::ArgList args) {
-fmt::print("{}: {}: ", file, line);
-fmt::print(format, args);
-}
-FMT_VARIADIC(void, print_error, const char *, int, const char *)
-
-``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that
-don't implement variadic templates. You don't have to use this macro if
-you don't need legacy compiler support and can use variadic templates
-directly::
-
-template <typename... Args>
-void print_error(const char *file, int line, const char *format,
-const Args & ... args) {
-fmt::print("{}: {}: ", file, line);
-fmt::print(format, args...);
-}
-\endrst
-*/
-#define FMT_VARIADIC(ReturnType, func, ...) \
-  FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)
-
-#define FMT_VARIADIC_W(ReturnType, func, ...) \
-  FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
-
-#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)
-
-#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)
-
-/**
-\rst
-Convenient macro to capture the arguments' names and values into several
-``fmt::arg(name, value)``.
-
-**Example**::
-
-int x = 1, y = 2;
-print("point: ({x}, {y})", FMT_CAPTURE(x, y));
-// same as:
-// print("point: ({x}, {y})", arg("x", x), arg("y", y));
-
-\endrst
-*/
-#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)
-
-#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)
-
-namespace fmt {
-	FMT_VARIADIC(std::string, format, CStringRef)
-		FMT_VARIADIC_W(std::wstring, format, WCStringRef)
-		FMT_VARIADIC(void, print, CStringRef)
-		FMT_VARIADIC(void, print, std::FILE *, CStringRef)
-
-		FMT_VARIADIC(void, print_colored, Color, CStringRef)
-		FMT_VARIADIC(std::string, sprintf, CStringRef)
-		FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)
-		FMT_VARIADIC(int, printf, CStringRef)
-		FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
-
-#if FMT_USE_IOSTREAMS
-		/**
-		\rst
-		Prints formatted data to the stream *os*.
-
-		**Example**::
-
-		print(cerr, "Don't {}!", "panic");
-		\endrst
-		*/
-		FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
-	FMT_VARIADIC(void, print, std::ostream &, CStringRef)
-
-		/**
-		\rst
-		Prints formatted data to the stream *os*.
-
-		**Example**::
-
-		fprintf(cerr, "Don't %s!", "panic");
-		\endrst
-		*/
-		FMT_API int fprintf(std::ostream &os, CStringRef format_str, ArgList args);
-	FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
-#endif
-
-	namespace internal {
-		template <typename Char>
-		inline bool is_name_start(Char c)
-		{
-			return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-		}
-
-		// Parses an unsigned integer advancing s to the end of the parsed input.
-		// This function assumes that the first character of s is a digit.
-		template <typename Char>
-		unsigned parse_nonnegative_int(const Char *&s)
-		{
-			assert('0' <= *s && *s <= '9');
-			unsigned value = 0;
-			do {
-				unsigned new_value = value * 10 + (*s++ - '0');
-				// Check if value wrapped around.
-				if (new_value < value) {
-					value = (std::numeric_limits<unsigned>::max)();
-					break;
-				}
-				value = new_value;
-			} while ('0' <= *s && *s <= '9');
-			// Convert to unsigned to prevent a warning.
-			unsigned max_int = (std::numeric_limits<int>::max)();
-			if (value > max_int)
-				FMT_THROW(FormatError("number is too big"));
-			return value;
-		}
-
-		inline void require_numeric_argument(const Arg &arg, char spec)
-		{
-			if (arg.type > Arg::LAST_NUMERIC_TYPE) {
-				std::string message =
-					fmt::format("format specifier '{}' requires numeric argument", spec);
-				FMT_THROW(fmt::FormatError(message));
-			}
-		}
-
-		template <typename Char>
-		void check_sign(const Char *&s, const Arg &arg)
-		{
-			char sign = static_cast<char>(*s);
-			require_numeric_argument(arg, sign);
-			if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
-				FMT_THROW(FormatError(fmt::format(
-					"format specifier '{}' requires signed argument", sign)));
-			}
-			++s;
-		}
-	}  // namespace internal
-
-	template <typename Char, typename AF>
-	inline internal::Arg BasicFormatter<Char, AF>::get_arg(
-		BasicStringRef<Char> arg_name, const char *&error)
-	{
-		if (check_no_auto_index(error)) {
-			map_.init(args());
-			const internal::Arg *arg = map_.find(arg_name);
-			if (arg)
-				return *arg;
-			error = "argument not found";
-		}
-		return internal::Arg();
-	}
-
-	template <typename Char, typename AF>
-	inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s)
-	{
-		const char *error = 0;
-		internal::Arg arg = *s < '0' || *s > '9' ?
-			next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
-		if (error) {
-			FMT_THROW(FormatError(
-				*s != '}' && *s != ':' ? "invalid format string" : error));
-		}
-		return arg;
-	}
-
-	template <typename Char, typename AF>
-	inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s)
-	{
-		assert(internal::is_name_start(*s));
-		const Char *start = s;
-		Char c;
-		do {
-			c = *++s;
-		} while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
-		const char *error = 0;
-		internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
-		if (error)
-			FMT_THROW(FormatError(error));
-		return arg;
-	}
-
-	template <typename Char, typename ArgFormatter>
-	const Char *BasicFormatter<Char, ArgFormatter>::format(
-		const Char *&format_str, const internal::Arg &arg)
-	{
-		using internal::Arg;
-		const Char *s = format_str;
-		FormatSpec spec;
-		if (*s == ':') {
-			if (arg.type == Arg::CUSTOM) {
-				arg.custom.format(this, arg.custom.value, &s);
-				return s;
-			}
-			++s;
-			// Parse fill and alignment.
-			if (Char c = *s) {
-				const Char *p = s + 1;
-				spec.align_ = ALIGN_DEFAULT;
-				do {
-					switch (*p) {
-					case '<':
-						spec.align_ = ALIGN_LEFT;
-						break;
-					case '>':
-						spec.align_ = ALIGN_RIGHT;
-						break;
-					case '=':
-						spec.align_ = ALIGN_NUMERIC;
-						break;
-					case '^':
-						spec.align_ = ALIGN_CENTER;
-						break;
-					}
-					if (spec.align_ != ALIGN_DEFAULT) {
-						if (p != s) {
-							if (c == '}') break;
-							if (c == '{')
-								FMT_THROW(FormatError("invalid fill character '{'"));
-							s += 2;
-							spec.fill_ = c;
-						}
-						else ++s;
-						if (spec.align_ == ALIGN_NUMERIC)
-							require_numeric_argument(arg, '=');
-						break;
-					}
-				} while (--p >= s);
-			}
-
-			// Parse sign.
-			switch (*s) {
-			case '+':
-				check_sign(s, arg);
-				spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
-				break;
-			case '-':
-				check_sign(s, arg);
-				spec.flags_ |= MINUS_FLAG;
-				break;
-			case ' ':
-				check_sign(s, arg);
-				spec.flags_ |= SIGN_FLAG;
-				break;
-			}
-
-			if (*s == '#') {
-				require_numeric_argument(arg, '#');
-				spec.flags_ |= HASH_FLAG;
-				++s;
-			}
-
-			// Parse zero flag.
-			if (*s == '0') {
-				require_numeric_argument(arg, '0');
-				spec.align_ = ALIGN_NUMERIC;
-				spec.fill_ = '0';
-				++s;
-			}
-
-			// Parse width.
-			if ('0' <= *s && *s <= '9') {
-				spec.width_ = internal::parse_nonnegative_int(s);
-			}
-			else if (*s == '{') {
-				++s;
-				Arg width_arg = internal::is_name_start(*s) ?
-					parse_arg_name(s) : parse_arg_index(s);
-				if (*s++ != '}')
-					FMT_THROW(FormatError("invalid format string"));
-				ULongLong value = 0;
-				switch (width_arg.type) {
-				case Arg::INT:
-					if (width_arg.int_value < 0)
-						FMT_THROW(FormatError("negative width"));
-					value = width_arg.int_value;
-					break;
-				case Arg::UINT:
-					value = width_arg.uint_value;
-					break;
-				case Arg::LONG_LONG:
-					if (width_arg.long_long_value < 0)
-						FMT_THROW(FormatError("negative width"));
-					value = width_arg.long_long_value;
-					break;
-				case Arg::ULONG_LONG:
-					value = width_arg.ulong_long_value;
-					break;
-				default:
-					FMT_THROW(FormatError("width is not integer"));
-				}
-				if (value >(std::numeric_limits<int>::max)())
-					FMT_THROW(FormatError("number is too big"));
-				spec.width_ = static_cast<int>(value);
-			}
-
-			// Parse precision.
-			if (*s == '.') {
-				++s;
-				spec.precision_ = 0;
-				if ('0' <= *s && *s <= '9') {
-					spec.precision_ = internal::parse_nonnegative_int(s);
-				}
-				else if (*s == '{') {
-					++s;
-					Arg precision_arg = internal::is_name_start(*s) ?
-						parse_arg_name(s) : parse_arg_index(s);
-					if (*s++ != '}')
-						FMT_THROW(FormatError("invalid format string"));
-					ULongLong value = 0;
-					switch (precision_arg.type) {
-					case Arg::INT:
-						if (precision_arg.int_value < 0)
-							FMT_THROW(FormatError("negative precision"));
-						value = precision_arg.int_value;
-						break;
-					case Arg::UINT:
-						value = precision_arg.uint_value;
-						break;
-					case Arg::LONG_LONG:
-						if (precision_arg.long_long_value < 0)
-							FMT_THROW(FormatError("negative precision"));
-						value = precision_arg.long_long_value;
-						break;
-					case Arg::ULONG_LONG:
-						value = precision_arg.ulong_long_value;
-						break;
-					default:
-						FMT_THROW(FormatError("precision is not integer"));
-					}
-					if (value >(std::numeric_limits<int>::max)())
-						FMT_THROW(FormatError("number is too big"));
-					spec.precision_ = static_cast<int>(value);
-				}
-				else {
-					FMT_THROW(FormatError("missing precision specifier"));
-				}
-				if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
-					FMT_THROW(FormatError(
-						fmt::format("precision not allowed in {} format specifier",
-							arg.type == Arg::POINTER ? "pointer" : "integer")));
-				}
-			}
-
-			// Parse type.
-			if (*s != '}' && *s)
-				spec.type_ = static_cast<char>(*s++);
-		}
-
-		if (*s++ != '}')
-			FMT_THROW(FormatError("missing '}' in format string"));
-
-		// Format argument.
-		ArgFormatter(*this, spec, s - 1).visit(arg);
-		return s;
-	}
-
-	template <typename Char, typename AF>
-	void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str)
-	{
-		const Char *s = format_str.c_str();
-		const Char *start = s;
-		while (*s) {
-			Char c = *s++;
-			if (c != '{' && c != '}') continue;
-			if (*s == c) {
-				write(writer_, start, s);
-				start = ++s;
-				continue;
-			}
-			if (c == '}')
-				FMT_THROW(FormatError("unmatched '}' in format string"));
-			write(writer_, start, s - 1);
-			internal::Arg arg = internal::is_name_start(*s) ?
-				parse_arg_name(s) : parse_arg_index(s);
-			start = s = format(s, arg);
-		}
-		write(writer_, start, s);
-	}
-}  // namespace fmt
-
-#if FMT_USE_USER_DEFINED_LITERALS
-namespace fmt {
-	namespace internal {
-
-		template <typename Char>
-		struct UdlFormat
-		{
-			const Char *str;
-
-			template <typename... Args>
-			auto operator()(Args && ... args) const
-				-> decltype(format(str, std::forward<Args>(args)...))
-			{
-				return format(str, std::forward<Args>(args)...);
-			}
-		};
-
-		template <typename Char>
-		struct UdlArg
-		{
-			const Char *str;
-
-			template <typename T>
-			NamedArg<Char> operator=(T &&value) const
-			{
-				return{ str, std::forward<T>(value) };
-			}
-		};
-
-	} // namespace internal
-
-	inline namespace literals {
-
-		/**
-		\rst
-		C++11 literal equivalent of :func:`fmt::format`.
-
-		**Example**::
-
-		using namespace fmt::literals;
-		std::string message = "The answer is {}"_format(42);
-		\endrst
-		*/
-		inline internal::UdlFormat<char>
-			operator"" _format(const char *s, std::size_t)
-		{
-			return{ s };
-		}
-		inline internal::UdlFormat<wchar_t>
-			operator"" _format(const wchar_t *s, std::size_t)
-		{
-			return{ s };
-		}
-
-		/**
-		\rst
-		C++11 literal equivalent of :func:`fmt::arg`.
-
-		**Example**::
-
-		using namespace fmt::literals;
-		print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-		\endrst
-		*/
-		inline internal::UdlArg<char>
-			operator"" _a(const char *s, std::size_t)
-		{
-			return{ s };
-		}
-		inline internal::UdlArg<wchar_t>
-			operator"" _a(const wchar_t *s, std::size_t)
-		{
-			return{ s };
-		}
-
-	} // inline namespace literals
-} // namespace fmt
-#endif // FMT_USE_USER_DEFINED_LITERALS
-
-  // Restore warnings.
-#if FMT_GCC_VERSION >= 406
-# pragma GCC diagnostic pop
-#endif
-
-#if defined(__clang__) && !defined(__INTEL_COMPILER)
-# pragma clang diagnostic pop
-#endif
-
-#ifdef FMT_HEADER_ONLY
-# include "format.cc"
-#endif
-
-#endif  // FMT_FORMAT_H_
-
+/*

+Formatting library for C++

+

+Copyright (c) 2012 - 2015, Victor Zverovich

+All rights reserved.

+

+Redistribution and use in source and binary forms, with or without

+modification, are permitted provided that the following conditions are met:

+

+1. Redistributions of source code must retain the above copyright notice, this

+list of conditions and the following disclaimer.

+2. Redistributions in binary form must reproduce the above copyright notice,

+this list of conditions and the following disclaimer in the documentation

+and/or other materials provided with the distribution.

+

+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR

+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+*/

+

+#ifndef FMT_FORMAT_H_

+#define FMT_FORMAT_H_

+

+

+//Added to spdlog version for header only usage

+#define FMT_HEADER_ONLY

+

+//Added to spdlog version in order to avoid including windows.h

+#if !defined (FMT_USE_WINDOWS_H)

+#define FMT_USE_WINDOWS_H 0

+#endif

+

+#include <cassert>

+#include <cmath>

+#include <cstdio>

+#include <cstring>

+#include <limits>

+#include <memory>

+#include <stdexcept>

+#include <string>

+#include <vector>

+#include <utility>

+

+#ifndef FMT_USE_IOSTREAMS

+# define FMT_USE_IOSTREAMS 1

+#endif

+

+#if FMT_USE_IOSTREAMS

+# include <ostream>

+#endif

+

+#ifdef _SECURE_SCL

+# define FMT_SECURE_SCL _SECURE_SCL

+#else

+# define FMT_SECURE_SCL 0

+#endif

+

+#if FMT_SECURE_SCL

+# include <iterator>

+#endif

+

+#if defined(_MSC_VER) && _MSC_VER <= 1500

+typedef unsigned __int32 uint32_t;

+typedef unsigned __int64 uint64_t;

+typedef __int64          intmax_t;

+#else

+#include <stdint.h>

+#endif

+

+#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)

+# ifdef FMT_EXPORT

+#  define FMT_API __declspec(dllexport)

+# elif defined(FMT_SHARED)

+#  define FMT_API __declspec(dllimport)

+# endif

+#endif

+#ifndef FMT_API

+# define FMT_API

+#endif

+

+#ifdef __GNUC__

+# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)

+# define FMT_GCC_EXTENSION __extension__

+# if FMT_GCC_VERSION >= 406

+#  pragma GCC diagnostic push

+// Disable the warning about "long long" which is sometimes reported even

+// when using __extension__.

+#  pragma GCC diagnostic ignored "-Wlong-long"

+// Disable the warning about declaration shadowing because it affects too

+// many valid cases.

+#  pragma GCC diagnostic ignored "-Wshadow"

+// Disable the warning about implicit conversions that may change the sign of

+// an integer; silencing it otherwise would require many explicit casts.

+#  pragma GCC diagnostic ignored "-Wsign-conversion"

+# endif

+# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__

+#  define FMT_HAS_GXX_CXX11 1

+# endif

+#else

+# define FMT_GCC_EXTENSION

+#endif

+

+#if defined(__clang__) && !defined(__INTEL_COMPILER)

+# pragma clang diagnostic push

+# pragma clang diagnostic ignored "-Wdocumentation"

+#endif

+

+#ifdef __GNUC_LIBSTD__

+# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)

+#endif

+

+#ifdef __has_feature

+# define FMT_HAS_FEATURE(x) __has_feature(x)

+#else

+# define FMT_HAS_FEATURE(x) 0

+#endif

+

+#ifdef __has_builtin

+# define FMT_HAS_BUILTIN(x) __has_builtin(x)

+#else

+# define FMT_HAS_BUILTIN(x) 0

+#endif

+

+#ifdef __has_cpp_attribute

+# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)

+#else

+# define FMT_HAS_CPP_ATTRIBUTE(x) 0

+#endif

+

+#ifndef FMT_USE_VARIADIC_TEMPLATES

+// Variadic templates are available in GCC since version 4.4

+// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++

+// since version 2013.

+# define FMT_USE_VARIADIC_TEMPLATES \

+   (FMT_HAS_FEATURE(cxx_variadic_templates) || \

+       (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800)

+#endif

+

+#ifndef FMT_USE_RVALUE_REFERENCES

+// Don't use rvalue references when compiling with clang and an old libstdc++

+// as the latter doesn't provide std::move.

+# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402

+#  define FMT_USE_RVALUE_REFERENCES 0

+# else

+#  define FMT_USE_RVALUE_REFERENCES \

+    (FMT_HAS_FEATURE(cxx_rvalue_references) || \

+        (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600)

+# endif

+#endif

+

+#if FMT_USE_RVALUE_REFERENCES

+# include <utility>  // for std::move

+#endif

+

+// Check if exceptions are disabled.

+#if defined(__GNUC__) && !defined(__EXCEPTIONS)

+# define FMT_EXCEPTIONS 0

+#endif

+#if defined(_MSC_VER) && !_HAS_EXCEPTIONS

+# define FMT_EXCEPTIONS 0

+#endif

+#ifndef FMT_EXCEPTIONS

+# define FMT_EXCEPTIONS 1

+#endif

+

+#ifndef FMT_THROW

+# if FMT_EXCEPTIONS

+#  define FMT_THROW(x) throw x

+# else

+#  define FMT_THROW(x) assert(false)

+# endif

+#endif

+

+// Define FMT_USE_NOEXCEPT to make C++ Format use noexcept (C++11 feature).

+#ifndef FMT_USE_NOEXCEPT

+# define FMT_USE_NOEXCEPT 0

+#endif

+

+#ifndef FMT_NOEXCEPT

+# if FMT_EXCEPTIONS

+#  if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \

+    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \

+    _MSC_VER >= 1900

+#   define FMT_NOEXCEPT noexcept

+#  else

+#   define FMT_NOEXCEPT throw()

+#  endif

+# else

+#  define FMT_NOEXCEPT

+# endif

+#endif

+

+// A macro to disallow the copy constructor and operator= functions

+// This should be used in the private: declarations for a class

+#ifndef FMT_USE_DELETED_FUNCTIONS

+# define FMT_USE_DELETED_FUNCTIONS 0

+#endif

+

+#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \

+  (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800

+# define FMT_DELETED_OR_UNDEFINED  = delete

+# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \

+    TypeName(const TypeName&) = delete; \

+    TypeName& operator=(const TypeName&) = delete

+#else

+# define FMT_DELETED_OR_UNDEFINED

+# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \

+    TypeName(const TypeName&); \

+    TypeName& operator=(const TypeName&)

+#endif

+

+#ifndef FMT_USE_USER_DEFINED_LITERALS

+// All compilers which support UDLs also support variadic templates. This

+// makes the fmt::literals implementation easier. However, an explicit check

+// for variadic templates is added here just in case.

+# define FMT_USE_USER_DEFINED_LITERALS \

+   FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \

+   (FMT_HAS_FEATURE(cxx_user_literals) || \

+       (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1900)

+#endif

+

+#ifndef FMT_ASSERT

+# define FMT_ASSERT(condition, message) assert((condition) && message)

+#endif

+

+

+#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)

+# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)

+#endif

+

+#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)

+# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)

+#endif

+

+// Some compilers masquerade as both MSVC and GCC-likes or

+// otherwise support __builtin_clz and __builtin_clzll, so

+// only define FMT_BUILTIN_CLZ using the MSVC intrinsics

+// if the clz and clzll builtins are not available.

+#if defined(_MSC_VER) && !defined(FMT_BUILTIN_CLZLL)

+# include <intrin.h>  // _BitScanReverse, _BitScanReverse64

+

+namespace fmt

+{

+namespace internal

+{

+# pragma intrinsic(_BitScanReverse)

+inline uint32_t clz(uint32_t x)

+{

+    unsigned long r = 0;

+    _BitScanReverse(&r, x);

+

+    assert(x != 0);

+    // Static analysis complains about using uninitialized data

+    // "r", but the only way that can happen is if "x" is 0,

+    // which the callers guarantee to not happen.

+# pragma warning(suppress: 6102)

+    return 31 - r;

+}

+# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)

+

+# ifdef _WIN64

+#  pragma intrinsic(_BitScanReverse64)

+# endif

+

+inline uint32_t clzll(uint64_t x)

+{

+    unsigned long r = 0;

+# ifdef _WIN64

+    _BitScanReverse64(&r, x);

+# else

+    // Scan the high 32 bits.

+    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))

+        return 63 - (r + 32);

+

+    // Scan the low 32 bits.

+    _BitScanReverse(&r, static_cast<uint32_t>(x));

+# endif

+

+    assert(x != 0);

+    // Static analysis complains about using uninitialized data

+    // "r", but the only way that can happen is if "x" is 0,

+    // which the callers guarantee to not happen.

+# pragma warning(suppress: 6102)

+    return 63 - r;

+}

+# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)

+}

+}

+#endif

+

+namespace fmt

+{

+namespace internal

+{

+struct DummyInt

+{

+    int data[2];

+    operator int() const

+    {

+        return 0;

+    }

+};

+typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;

+

+// Dummy implementations of system functions such as signbit and ecvt called

+// if the latter are not available.

+inline DummyInt signbit(...)

+{

+    return DummyInt();

+}

+inline DummyInt _ecvt_s(...)

+{

+    return DummyInt();

+}

+inline DummyInt isinf(...)

+{

+    return DummyInt();

+}

+inline DummyInt _finite(...)

+{

+    return DummyInt();

+}

+inline DummyInt isnan(...)

+{

+    return DummyInt();

+}

+inline DummyInt _isnan(...)

+{

+    return DummyInt();

+}

+

+// A helper function to suppress bogus "conditional expression is constant"

+// warnings.

+template <typename T>

+inline T check(T value)

+{

+    return value;

+}

+}

+}  // namespace fmt

+

+namespace std

+{

+// Standard permits specialization of std::numeric_limits. This specialization

+// is used to resolve ambiguity between isinf and std::isinf in glibc:

+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891

+// and the same for isnan and signbit.

+template <>

+class numeric_limits<fmt::internal::DummyInt>:

+    public std::numeric_limits<int>

+{

+public:

+    // Portable version of isinf.

+    template <typename T>

+    static bool isinfinity(T x)

+    {

+        using namespace fmt::internal;

+        // The resolution "priority" is:

+        // isinf macro > std::isinf > ::isinf > fmt::internal::isinf

+        if (check(sizeof(isinf(x)) == sizeof(bool) ||

+                  sizeof(isinf(x)) == sizeof(int)))

+        {

+            return isinf(x) != 0;

+        }

+        return !_finite(static_cast<double>(x));

+    }

+

+    // Portable version of isnan.

+    template <typename T>

+    static bool isnotanumber(T x)

+    {

+        using namespace fmt::internal;

+        if (check(sizeof(isnan(x)) == sizeof(bool) ||

+                  sizeof(isnan(x)) == sizeof(int)))

+        {

+            return isnan(x) != 0;

+        }

+        return _isnan(static_cast<double>(x)) != 0;

+    }

+

+    // Portable version of signbit.

+    static bool isnegative(double x)

+    {

+        using namespace fmt::internal;

+        if (check(sizeof(signbit(x)) == sizeof(int)))

+            return signbit(x) != 0;

+        if (x < 0) return true;

+        if (!isnotanumber(x)) return false;

+        int dec = 0, sign = 0;

+        char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.

+        _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);

+        return sign != 0;

+    }

+};

+}  // namespace std

+

+namespace fmt

+{

+

+// Fix the warning about long long on older versions of GCC

+// that don't support the diagnostic pragma.

+FMT_GCC_EXTENSION typedef long long LongLong;

+FMT_GCC_EXTENSION typedef unsigned long long ULongLong;

+

+#if FMT_USE_RVALUE_REFERENCES

+using std::move;

+#endif

+

+template <typename Char>

+class BasicWriter;

+

+typedef BasicWriter<char> Writer;

+typedef BasicWriter<wchar_t> WWriter;

+

+namespace internal

+{

+template <typename Char>

+class BasicArgFormatter;

+}

+

+template <typename CharType,

+          typename ArgFormatter = internal::BasicArgFormatter<CharType> >

+class BasicFormatter;

+

+template <typename Char, typename T>

+void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value);

+

+/**

+\rst

+A string reference. It can be constructed from a C string or ``std::string``.

+

+You can use one of the following typedefs for common character types:

+

++------------+-------------------------+

+| Type       | Definition              |

++============+=========================+

+| StringRef  | BasicStringRef<char>    |

++------------+-------------------------+

+| WStringRef | BasicStringRef<wchar_t> |

++------------+-------------------------+

+

+This class is most useful as a parameter type to allow passing

+different types of strings to a function, for example::

+

+template <typename... Args>

+std::string format(StringRef format_str, const Args & ... args);

+

+format("{}", 42);

+format(std::string("{}"), 42);

+\endrst

+*/

+template <typename Char>

+class BasicStringRef

+{

+private:

+    const Char *data_;

+    std::size_t size_;

+

+public:

+    /** Constructs a string reference object from a C string and a size. */

+    BasicStringRef(const Char *s, std::size_t size): data_(s), size_(size)

+    {}

+

+    /**

+    \rst

+    Constructs a string reference object from a C string computing

+    the size with ``std::char_traits<Char>::length``.

+    \endrst

+    */

+    BasicStringRef(const Char *s)

+        : data_(s), size_(std::char_traits<Char>::length(s))

+    {}

+

+    /**

+    \rst

+    Constructs a string reference from an ``std::string`` object.

+    \endrst

+    */

+    BasicStringRef(const std::basic_string<Char> &s)

+        : data_(s.c_str()), size_(s.size())

+    {}

+

+    /**

+    \rst

+    Converts a string reference to an ``std::string`` object.

+    \endrst

+    */

+    std::basic_string<Char> to_string() const

+    {

+        return std::basic_string<Char>(data_, size_);

+    }

+

+    /** Returns a pointer to the string data. */

+    const Char *data() const

+    {

+        return data_;

+    }

+

+    /** Returns the string size. */

+    std::size_t size() const

+    {

+        return size_;

+    }

+

+    // Lexicographically compare this string reference to other.

+    int compare(BasicStringRef other) const

+    {

+        std::size_t size = size_ < other.size_ ? size_ : other.size_;

+        int result = std::char_traits<Char>::compare(data_, other.data_, size);

+        if (result == 0)

+            result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);

+        return result;

+    }

+

+    friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)

+    {

+        return lhs.compare(rhs) == 0;

+    }

+    friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)

+    {

+        return lhs.compare(rhs) != 0;

+    }

+    friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)

+    {

+        return lhs.compare(rhs) < 0;

+    }

+    friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)

+    {

+        return lhs.compare(rhs) <= 0;

+    }

+    friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)

+    {

+        return lhs.compare(rhs) > 0;

+    }

+    friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)

+    {

+        return lhs.compare(rhs) >= 0;

+    }

+};

+

+typedef BasicStringRef<char> StringRef;

+typedef BasicStringRef<wchar_t> WStringRef;

+

+/**

+\rst

+A reference to a null terminated string. It can be constructed from a C

+string or ``std::string``.

+

+You can use one of the following typedefs for common character types:

+

++-------------+--------------------------+

+| Type        | Definition               |

++=============+==========================+

+| CStringRef  | BasicCStringRef<char>    |

++-------------+--------------------------+

+| WCStringRef | BasicCStringRef<wchar_t> |

++-------------+--------------------------+

+

+This class is most useful as a parameter type to allow passing

+different types of strings to a function, for example::

+

+template <typename... Args>

+std::string format(CStringRef format_str, const Args & ... args);

+

+format("{}", 42);

+format(std::string("{}"), 42);

+\endrst

+*/

+template <typename Char>

+class BasicCStringRef

+{

+private:

+    const Char *data_;

+

+public:

+    /** Constructs a string reference object from a C string. */

+    BasicCStringRef(const Char *s): data_(s)

+    {}

+

+    /**

+    \rst

+    Constructs a string reference from an ``std::string`` object.

+    \endrst

+    */

+    BasicCStringRef(const std::basic_string<Char> &s): data_(s.c_str())

+    {}

+

+    /** Returns the pointer to a C string. */

+    const Char *c_str() const

+    {

+        return data_;

+    }

+};

+

+typedef BasicCStringRef<char> CStringRef;

+typedef BasicCStringRef<wchar_t> WCStringRef;

+

+/**

+A formatting error such as invalid format string.

+*/

+class FormatError: public std::runtime_error

+{

+public:

+    explicit FormatError(CStringRef message)

+        : std::runtime_error(message.c_str())

+    {}

+};

+

+namespace internal

+{

+

+// MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.

+template <typename T>

+struct MakeUnsigned

+{

+    typedef T Type;

+};

+

+#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \

+  template <> \

+  struct MakeUnsigned<T> { typedef U Type; }

+

+FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char);

+FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);

+FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short);

+FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);

+FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);

+FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);

+

+// Casts nonnegative integer to unsigned.

+template <typename Int>

+inline typename MakeUnsigned<Int>::Type to_unsigned(Int value)

+{

+    FMT_ASSERT(value >= 0, "negative value");

+    return static_cast<typename MakeUnsigned<Int>::Type>(value);

+}

+

+// The number of characters to store in the MemoryBuffer object itself

+// to avoid dynamic memory allocation.

+enum

+{

+    INLINE_BUFFER_SIZE = 500

+};

+

+#if FMT_SECURE_SCL

+// Use checked iterator to avoid warnings on MSVC.

+template <typename T>

+inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size)

+{

+    return stdext::checked_array_iterator<T*>(ptr, size);

+}

+#else

+template <typename T>

+inline T *make_ptr(T *ptr, std::size_t)

+{

+    return ptr;

+}

+#endif

+}  // namespace internal

+

+/**

+\rst

+A buffer supporting a subset of ``std::vector``'s operations.

+\endrst

+*/

+template <typename T>

+class Buffer

+{

+private:

+    FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);

+

+protected:

+    T *ptr_;

+    std::size_t size_;

+    std::size_t capacity_;

+

+    Buffer(T *ptr = 0, std::size_t capacity = 0)

+        : ptr_(ptr), size_(0), capacity_(capacity)

+    {}

+

+    /**

+    \rst

+    Increases the buffer capacity to hold at least *size* elements updating

+    ``ptr_`` and ``capacity_``.

+    \endrst

+    */

+    virtual void grow(std::size_t size) = 0;

+

+public:

+    virtual ~Buffer()

+    {}

+

+    /** Returns the size of this buffer. */

+    std::size_t size() const

+    {

+        return size_;

+    }

+

+    /** Returns the capacity of this buffer. */

+    std::size_t capacity() const

+    {

+        return capacity_;

+    }

+

+    /**

+    Resizes the buffer. If T is a POD type new elements may not be initialized.

+    */

+    void resize(std::size_t new_size)

+    {

+        if (new_size > capacity_)

+            grow(new_size);

+        size_ = new_size;

+    }

+

+    /**

+    \rst

+    Reserves space to store at least *capacity* elements.

+    \endrst

+    */

+    void reserve(std::size_t capacity)

+    {

+        if (capacity > capacity_)

+            grow(capacity);

+    }

+

+    void clear() FMT_NOEXCEPT

+    {

+        size_ = 0;

+    }

+

+    void push_back(const T &value)

+    {

+        if (size_ == capacity_)

+            grow(size_ + 1);

+        ptr_[size_++] = value;

+    }

+

+    /** Appends data to the end of the buffer. */

+    template <typename U>

+    void append(const U *begin, const U *end);

+

+    T &operator[](std::size_t index)

+    {

+        return ptr_[index];

+    }

+    const T &operator[](std::size_t index) const

+    {

+        return ptr_[index];

+    }

+};

+

+template <typename T>

+template <typename U>

+void Buffer<T>::append(const U *begin, const U *end)

+{

+    std::size_t new_size = size_ + internal::to_unsigned(end - begin);

+    if (new_size > capacity_)

+        grow(new_size);

+    std::uninitialized_copy(begin, end,

+                            internal::make_ptr(ptr_, capacity_) + size_);

+    size_ = new_size;

+}

+

+namespace internal

+{

+

+// A memory buffer for trivially copyable/constructible types with the first SIZE

+// elements stored in the object itself.

+template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >

+class MemoryBuffer: private Allocator, public Buffer<T>

+{

+private:

+    T data_[SIZE];

+

+    // Deallocate memory allocated by the buffer.

+    void deallocate()

+    {

+        if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);

+    }

+

+protected:

+    void grow(std::size_t size);

+

+public:

+    explicit MemoryBuffer(const Allocator &alloc = Allocator())

+        : Allocator(alloc), Buffer<T>(data_, SIZE)

+    {}

+    ~MemoryBuffer()

+    {

+        deallocate();

+    }

+

+#if FMT_USE_RVALUE_REFERENCES

+private:

+    // Move data from other to this buffer.

+    void move(MemoryBuffer &other)

+    {

+        Allocator &this_alloc = *this, &other_alloc = other;

+        this_alloc = std::move(other_alloc);

+        this->size_ = other.size_;

+        this->capacity_ = other.capacity_;

+        if (other.ptr_ == other.data_)

+        {

+            this->ptr_ = data_;

+            std::uninitialized_copy(other.data_, other.data_ + this->size_,

+                                    make_ptr(data_, this->capacity_));

+        }

+        else

+        {

+            this->ptr_ = other.ptr_;

+            // Set pointer to the inline array so that delete is not called

+            // when deallocating.

+            other.ptr_ = other.data_;

+        }

+    }

+

+public:

+    MemoryBuffer(MemoryBuffer &&other)

+    {

+        move(other);

+    }

+

+    MemoryBuffer &operator=(MemoryBuffer &&other)

+    {

+        assert(this != &other);

+        deallocate();

+        move(other);

+        return *this;

+    }

+#endif

+

+    // Returns a copy of the allocator associated with this buffer.

+    Allocator get_allocator() const

+    {

+        return *this;

+    }

+};

+

+template <typename T, std::size_t SIZE, typename Allocator>

+void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size)

+{

+    std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;

+    if (size > new_capacity)

+        new_capacity = size;

+    T *new_ptr = this->allocate(new_capacity);

+    // The following code doesn't throw, so the raw pointer above doesn't leak.

+    std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,

+                            make_ptr(new_ptr, new_capacity));

+    std::size_t old_capacity = this->capacity_;

+    T *old_ptr = this->ptr_;

+    this->capacity_ = new_capacity;

+    this->ptr_ = new_ptr;

+    // deallocate may throw (at least in principle), but it doesn't matter since

+    // the buffer already uses the new storage and will deallocate it in case

+    // of exception.

+    if (old_ptr != data_)

+        Allocator::deallocate(old_ptr, old_capacity);

+}

+

+// A fixed-size buffer.

+template <typename Char>

+class FixedBuffer: public fmt::Buffer<Char>

+{

+public:

+    FixedBuffer(Char *array, std::size_t size): fmt::Buffer<Char>(array, size)

+    {}

+

+protected:

+    FMT_API void grow(std::size_t size);

+};

+

+template <typename Char>

+class BasicCharTraits

+{

+public:

+#if FMT_SECURE_SCL

+    typedef stdext::checked_array_iterator<Char*> CharPtr;

+#else

+    typedef Char *CharPtr;

+#endif

+    static Char cast(int value)

+    {

+        return static_cast<Char>(value);

+    }

+};

+

+template <typename Char>

+class CharTraits;

+

+template <>

+class CharTraits<char>: public BasicCharTraits<char>

+{

+private:

+    // Conversion from wchar_t to char is not allowed.

+    static char convert(wchar_t);

+

+public:

+    static char convert(char value)

+    {

+        return value;

+    }

+

+    // Formats a floating-point number.

+    template <typename T>

+    FMT_API static int format_float(char *buffer, std::size_t size,

+                                    const char *format, unsigned width, int precision, T value);

+};

+

+template <>

+class CharTraits<wchar_t>: public BasicCharTraits<wchar_t>

+{

+public:

+    static wchar_t convert(char value)

+    {

+        return value;

+    }

+    static wchar_t convert(wchar_t value)

+    {

+        return value;

+    }

+

+    template <typename T>

+    FMT_API static int format_float(wchar_t *buffer, std::size_t size,

+                                    const wchar_t *format, unsigned width, int precision, T value);

+};

+

+// Checks if a number is negative - used to avoid warnings.

+template <bool IsSigned>

+struct SignChecker

+{

+    template <typename T>

+    static bool is_negative(T value)

+    {

+        return value < 0;

+    }

+};

+

+template <>

+struct SignChecker<false>

+{

+    template <typename T>

+    static bool is_negative(T)

+    {

+        return false;

+    }

+};

+

+// Returns true if value is negative, false otherwise.

+// Same as (value < 0) but doesn't produce warnings if T is an unsigned type.

+template <typename T>

+inline bool is_negative(T value)

+{

+    return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);

+}

+

+// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.

+template <bool FitsIn32Bits>

+struct TypeSelector

+{

+    typedef uint32_t Type;

+};

+

+template <>

+struct TypeSelector<false>

+{

+    typedef uint64_t Type;

+};

+

+template <typename T>

+struct IntTraits

+{

+    // Smallest of uint32_t and uint64_t that is large enough to represent

+    // all values of T.

+    typedef typename

+    TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;

+};

+

+FMT_API void report_unknown_type(char code, const char *type);

+

+// Static data is placed in this class template to allow header-only

+// configuration.

+template <typename T = void>

+struct FMT_API BasicData

+{

+    static const uint32_t POWERS_OF_10_32[];

+    static const uint64_t POWERS_OF_10_64[];

+    static const char DIGITS[];

+};

+

+typedef BasicData<> Data;

+

+#ifdef FMT_BUILTIN_CLZLL

+// Returns the number of decimal digits in n. Leading zeros are not counted

+// except for n == 0 in which case count_digits returns 1.

+inline unsigned count_digits(uint64_t n)

+{

+    // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10

+    // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.

+    int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;

+    return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1;

+}

+#else

+// Fallback version of count_digits used when __builtin_clz is not available.

+inline unsigned count_digits(uint64_t n)

+{

+    unsigned count = 1;

+    for (;;)

+    {

+        // Integer division is slow so do it for a group of four digits instead

+        // of for every digit. The idea comes from the talk by Alexandrescu

+        // "Three Optimization Tips for C++". See speed-test for a comparison.

+        if (n < 10) return count;

+        if (n < 100) return count + 1;

+        if (n < 1000) return count + 2;

+        if (n < 10000) return count + 3;

+        n /= 10000u;

+        count += 4;

+    }

+}

+#endif

+

+#ifdef FMT_BUILTIN_CLZ

+// Optional version of count_digits for better performance on 32-bit platforms.

+inline unsigned count_digits(uint32_t n)

+{

+    int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;

+    return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1;

+}

+#endif

+

+// Formats a decimal unsigned integer value writing into buffer.

+template <typename UInt, typename Char>

+inline void format_decimal(Char *buffer, UInt value, unsigned num_digits)

+{

+    buffer += num_digits;

+    while (value >= 100)

+    {

+        // Integer division is slow so do it for a group of two digits instead

+        // of for every digit. The idea comes from the talk by Alexandrescu

+        // "Three Optimization Tips for C++". See speed-test for a comparison.

+        unsigned index = static_cast<unsigned>((value % 100) * 2);

+        value /= 100;

+        *--buffer = Data::DIGITS[index + 1];

+        *--buffer = Data::DIGITS[index];

+    }

+    if (value < 10)

+    {

+        *--buffer = static_cast<char>('0' + value);

+        return;

+    }

+    unsigned index = static_cast<unsigned>(value * 2);

+    *--buffer = Data::DIGITS[index + 1];

+    *--buffer = Data::DIGITS[index];

+}

+

+#ifndef _WIN32

+# define FMT_USE_WINDOWS_H 0

+#elif !defined(FMT_USE_WINDOWS_H)

+# define FMT_USE_WINDOWS_H 1

+#endif

+

+// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.

+// All the functionality that relies on it will be disabled too.

+#if FMT_USE_WINDOWS_H

+// A converter from UTF-8 to UTF-16.

+// It is only provided for Windows since other systems support UTF-8 natively.

+class UTF8ToUTF16

+{

+private:

+    MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;

+

+public:

+    FMT_API explicit UTF8ToUTF16(StringRef s);

+    operator WStringRef() const

+    {

+        return WStringRef(&buffer_[0], size());

+    }

+    size_t size() const

+    {

+        return buffer_.size() - 1;

+    }

+    const wchar_t *c_str() const

+    {

+        return &buffer_[0];

+    }

+    std::wstring str() const

+    {

+        return std::wstring(&buffer_[0], size());

+    }

+};

+

+// A converter from UTF-16 to UTF-8.

+// It is only provided for Windows since other systems support UTF-8 natively.

+class UTF16ToUTF8

+{

+private:

+    MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;

+

+public:

+    UTF16ToUTF8()

+    {}

+    FMT_API explicit UTF16ToUTF8(WStringRef s);

+    operator StringRef() const

+    {

+        return StringRef(&buffer_[0], size());

+    }

+    size_t size() const

+    {

+        return buffer_.size() - 1;

+    }

+    const char *c_str() const

+    {

+        return &buffer_[0];

+    }

+    std::string str() const

+    {

+        return std::string(&buffer_[0], size());

+    }

+

+    // Performs conversion returning a system error code instead of

+    // throwing exception on conversion error. This method may still throw

+    // in case of memory allocation error.

+    FMT_API int convert(WStringRef s);

+};

+

+FMT_API void format_windows_error(fmt::Writer &out, int error_code,

+                                  fmt::StringRef message) FMT_NOEXCEPT;

+#endif

+

+FMT_API void format_system_error(fmt::Writer &out, int error_code,

+                                 fmt::StringRef message) FMT_NOEXCEPT;

+

+// A formatting argument value.

+struct Value

+{

+    template <typename Char>

+    struct StringValue

+    {

+        const Char *value;

+        std::size_t size;

+    };

+

+    typedef void(*FormatFunc)(

+        void *formatter, const void *arg, void *format_str_ptr);

+

+    struct CustomValue

+    {

+        const void *value;

+        FormatFunc format;

+    };

+

+    union

+    {

+        int int_value;

+        unsigned uint_value;

+        LongLong long_long_value;

+        ULongLong ulong_long_value;

+        double double_value;

+        long double long_double_value;

+        const void *pointer;

+        StringValue<char> string;

+        StringValue<signed char> sstring;

+        StringValue<unsigned char> ustring;

+        StringValue<wchar_t> wstring;

+        CustomValue custom;

+    };

+

+    enum Type

+    {

+        NONE, NAMED_ARG,

+        // Integer types should go first,

+        INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,

+        // followed by floating-point types.

+        DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,

+        CSTRING, STRING, WSTRING, POINTER, CUSTOM

+    };

+};

+

+// A formatting argument. It is a trivially copyable/constructible type to

+// allow storage in internal::MemoryBuffer.

+struct Arg: Value

+{

+    Type type;

+};

+

+template <typename Char>

+struct NamedArg;

+

+template <typename T = void>

+struct Null

+{};

+

+// A helper class template to enable or disable overloads taking wide

+// characters and strings in MakeValue.

+template <typename T, typename Char>

+struct WCharHelper

+{

+    typedef Null<T> Supported;

+    typedef T Unsupported;

+};

+

+template <typename T>

+struct WCharHelper<T, wchar_t>

+{

+    typedef T Supported;

+    typedef Null<T> Unsupported;

+};

+

+typedef char Yes[1];

+typedef char No[2];

+

+// These are non-members to workaround an overload resolution bug in bcc32.

+Yes &convert(fmt::ULongLong);

+Yes &convert(std::ostream &);

+No &convert(...);

+

+template <typename T>

+T &get();

+

+struct DummyStream: std::ostream

+{

+    DummyStream();  // Suppress a bogus warning in MSVC.

+    // Hide all operator<< overloads from std::ostream.

+    void operator<<(Null<>);

+};

+

+No &operator<<(std::ostream &, int);

+

+template<typename T, bool ENABLE_CONVERSION>

+struct ConvertToIntImpl

+{

+    enum

+    {

+        value = false

+    };

+};

+

+template<typename T>

+struct ConvertToIntImpl<T, true>

+{

+    // Convert to int only if T doesn't have an overloaded operator<<.

+    enum

+    {

+        value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)

+    };

+};

+

+template<typename T, bool ENABLE_CONVERSION>

+struct ConvertToIntImpl2

+{

+    enum

+    {

+        value = false

+    };

+};

+

+template<typename T>

+struct ConvertToIntImpl2<T, true>

+{

+    enum

+    {

+        // Don't convert numeric types.

+        value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value

+    };

+};

+

+template<typename T>

+struct ConvertToInt

+{

+    enum

+    {

+        enable_conversion = sizeof(convert(get<T>())) == sizeof(Yes)

+    };

+    enum

+    {

+        value = ConvertToIntImpl2<T, enable_conversion>::value

+    };

+};

+

+#define FMT_DISABLE_CONVERSION_TO_INT(Type) \

+  template <> \

+  struct ConvertToInt<Type> {  enum { value = 0 }; }

+

+// Silence warnings about convering float to int.

+FMT_DISABLE_CONVERSION_TO_INT(float);

+FMT_DISABLE_CONVERSION_TO_INT(double);

+FMT_DISABLE_CONVERSION_TO_INT(long double);

+

+template<bool B, class T = void>

+struct EnableIf

+{};

+

+template<class T>

+struct EnableIf<true, T>

+{

+    typedef T type;

+};

+

+template<bool B, class T, class F>

+struct Conditional

+{

+    typedef T type;

+};

+

+template<class T, class F>

+struct Conditional<false, T, F>

+{

+    typedef F type;

+};

+

+// For bcc32 which doesn't understand ! in template arguments.

+template<bool>

+struct Not

+{

+    enum

+    {

+        value = 0

+    };

+};

+

+template<>

+struct Not<false>

+{

+    enum

+    {

+        value = 1

+    };

+};

+

+// Makes an Arg object from any type.

+template <typename Formatter>

+class MakeValue: public Arg

+{

+public:

+    typedef typename Formatter::Char Char;

+

+private:

+    // The following two methods are private to disallow formatting of

+    // arbitrary pointers. If you want to output a pointer cast it to

+    // "void *" or "const void *". In particular, this forbids formatting

+    // of "[const] volatile char *" which is printed as bool by iostreams.

+    // Do not implement!

+    template <typename T>

+    MakeValue(const T *value);

+    template <typename T>

+    MakeValue(T *value);

+

+    // The following methods are private to disallow formatting of wide

+    // characters and strings into narrow strings as in

+    //   fmt::format("{}", L"test");

+    // To fix this, use a wide format string: fmt::format(L"{}", L"test").

+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)

+    MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);

+#endif

+    MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);

+    MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);

+    MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);

+    MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);

+

+    void set_string(StringRef str)

+    {

+        string.value = str.data();

+        string.size = str.size();

+    }

+

+    void set_string(WStringRef str)

+    {

+        wstring.value = str.data();

+        wstring.size = str.size();

+    }

+

+    // Formats an argument of a custom type, such as a user-defined class.

+    template <typename T>

+    static void format_custom_arg(

+        void *formatter, const void *arg, void *format_str_ptr)

+    {

+        format(*static_cast<Formatter*>(formatter),

+               *static_cast<const Char**>(format_str_ptr),

+               *static_cast<const T*>(arg));

+    }

+

+public:

+    MakeValue()

+    {}

+

+#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \

+  MakeValue(Type value) { field = rhs; } \

+  static uint64_t type(Type) { return Arg::TYPE; }

+

+#define FMT_MAKE_VALUE(Type, field, TYPE) \

+  FMT_MAKE_VALUE_(Type, field, TYPE, value)

+

+    FMT_MAKE_VALUE(bool, int_value, BOOL)

+    FMT_MAKE_VALUE(short, int_value, INT)

+    FMT_MAKE_VALUE(unsigned short, uint_value, UINT)

+    FMT_MAKE_VALUE(int, int_value, INT)

+    FMT_MAKE_VALUE(unsigned, uint_value, UINT)

+

+    MakeValue(long value)

+    {

+        // To minimize the number of types we need to deal with, long is

+        // translated either to int or to long long depending on its size.

+        if (check(sizeof(long) == sizeof(int)))

+            int_value = static_cast<int>(value);

+        else

+            long_long_value = value;

+    }

+    static uint64_t type(long)

+    {

+        return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;

+    }

+

+    MakeValue(unsigned long value)

+    {

+        if (check(sizeof(unsigned long) == sizeof(unsigned)))

+            uint_value = static_cast<unsigned>(value);

+        else

+            ulong_long_value = value;

+    }

+    static uint64_t type(unsigned long)

+    {

+        return sizeof(unsigned long) == sizeof(unsigned) ?

+               Arg::UINT : Arg::ULONG_LONG;

+    }

+

+    FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)

+    FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)

+    FMT_MAKE_VALUE(float, double_value, DOUBLE)

+    FMT_MAKE_VALUE(double, double_value, DOUBLE)

+    FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)

+    FMT_MAKE_VALUE(signed char, int_value, INT)

+    FMT_MAKE_VALUE(unsigned char, uint_value, UINT)

+    FMT_MAKE_VALUE(char, int_value, CHAR)

+

+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)

+    MakeValue(typename WCharHelper<wchar_t, Char>::Supported value)

+    {

+        int_value = value;

+    }

+    static uint64_t type(wchar_t)

+    {

+        return Arg::CHAR;

+    }

+#endif

+

+#define FMT_MAKE_STR_VALUE(Type, TYPE) \

+  MakeValue(Type value) { set_string(value); } \

+  static uint64_t type(Type) { return Arg::TYPE; }

+

+    FMT_MAKE_VALUE(char *, string.value, CSTRING)

+    FMT_MAKE_VALUE(const char *, string.value, CSTRING)

+    FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)

+    FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)

+    FMT_MAKE_STR_VALUE(const std::string &, STRING)

+    FMT_MAKE_STR_VALUE(StringRef, STRING)

+    FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())

+

+#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \

+  MakeValue(typename WCharHelper<Type, Char>::Supported value) { \

+    set_string(value); \

+  } \

+  static uint64_t type(Type) { return Arg::TYPE; }

+

+    FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)

+    FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)

+    FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)

+    FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)

+

+    FMT_MAKE_VALUE(void *, pointer, POINTER)

+    FMT_MAKE_VALUE(const void *, pointer, POINTER)

+

+    template <typename T>

+    MakeValue(const T &value,

+              typename EnableIf<Not<

+              ConvertToInt<T>::value>::value, int>::type = 0)

+    {

+        custom.value = &value;

+        custom.format = &format_custom_arg<T>;

+    }

+

+    template <typename T>

+    MakeValue(const T &value,

+              typename EnableIf<ConvertToInt<T>::value, int>::type = 0)

+    {

+        int_value = value;

+    }

+

+    template <typename T>

+    static uint64_t type(const T &)

+    {

+        return ConvertToInt<T>::value ? Arg::INT : Arg::CUSTOM;

+    }

+

+    // Additional template param `Char_` is needed here because make_type always

+    // uses char.

+    template <typename Char_>

+    MakeValue(const NamedArg<Char_> &value)

+    {

+        pointer = &value;

+    }

+

+    template <typename Char_>

+    static uint64_t type(const NamedArg<Char_> &)

+    {

+        return Arg::NAMED_ARG;

+    }

+};

+

+template <typename Formatter>

+class MakeArg: public Arg

+{

+public:

+    MakeArg()

+    {

+        type = Arg::NONE;

+    }

+

+    template <typename T>

+    MakeArg(const T &value)

+        : Arg(MakeValue<Formatter>(value))

+    {

+        type = static_cast<Arg::Type>(MakeValue<Formatter>::type(value));

+    }

+};

+

+template <typename Char>

+struct NamedArg: Arg

+{

+    BasicStringRef<Char> name;

+

+    template <typename T>

+    NamedArg(BasicStringRef<Char> argname, const T &value)

+        : Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname)

+    {}

+};

+

+#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call

+

+// An argument visitor.

+// To use ArgVisitor define a subclass that implements some or all of the

+// visit methods with the same signatures as the methods in ArgVisitor,

+// for example, visit_int(int).

+// Specify the subclass name as the Impl template parameter. Then calling

+// ArgVisitor::visit for some argument will dispatch to a visit method

+// specific to the argument type. For example, if the argument type is

+// double then visit_double(double) method of a subclass will be called.

+// If the subclass doesn't contain a method with this signature, then

+// a corresponding method of ArgVisitor will be called.

+//

+// Example:

+//  class MyArgVisitor : public ArgVisitor<MyArgVisitor, void> {

+//   public:

+//    void visit_int(int value) { print("{}", value); }

+//    void visit_double(double value) { print("{}", value ); }

+//  };

+//

+// ArgVisitor uses the curiously recurring template pattern:

+// http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern

+template <typename Impl, typename Result>

+class ArgVisitor

+{

+public:

+    void report_unhandled_arg()

+    {}

+

+    Result visit_unhandled_arg()

+    {

+        FMT_DISPATCH(report_unhandled_arg());

+        return Result();

+    }

+

+    Result visit_int(int value)

+    {

+        return FMT_DISPATCH(visit_any_int(value));

+    }

+    Result visit_long_long(LongLong value)

+    {

+        return FMT_DISPATCH(visit_any_int(value));

+    }

+    Result visit_uint(unsigned value)

+    {

+        return FMT_DISPATCH(visit_any_int(value));

+    }

+    Result visit_ulong_long(ULongLong value)

+    {

+        return FMT_DISPATCH(visit_any_int(value));

+    }

+    Result visit_bool(bool value)

+    {

+        return FMT_DISPATCH(visit_any_int(value));

+    }

+    Result visit_char(int value)

+    {

+        return FMT_DISPATCH(visit_any_int(value));

+    }

+    template <typename T>

+    Result visit_any_int(T)

+    {

+        return FMT_DISPATCH(visit_unhandled_arg());

+    }

+

+    Result visit_double(double value)

+    {

+        return FMT_DISPATCH(visit_any_double(value));

+    }

+    Result visit_long_double(long double value)

+    {

+        return FMT_DISPATCH(visit_any_double(value));

+    }

+    template <typename T>

+    Result visit_any_double(T)

+    {

+        return FMT_DISPATCH(visit_unhandled_arg());

+    }

+

+    Result visit_cstring(const char *)

+    {

+        return FMT_DISPATCH(visit_unhandled_arg());

+    }

+    Result visit_string(Arg::StringValue<char>)

+    {

+        return FMT_DISPATCH(visit_unhandled_arg());

+    }

+    Result visit_wstring(Arg::StringValue<wchar_t>)

+    {

+        return FMT_DISPATCH(visit_unhandled_arg());

+    }

+    Result visit_pointer(const void *)

+    {

+        return FMT_DISPATCH(visit_unhandled_arg());

+    }

+    Result visit_custom(Arg::CustomValue)

+    {

+        return FMT_DISPATCH(visit_unhandled_arg());

+    }

+

+    Result visit(const Arg &arg)

+    {

+        switch (arg.type)

+        {

+        default:

+            FMT_ASSERT(false, "invalid argument type");

+            return Result();

+        case Arg::INT:

+            return FMT_DISPATCH(visit_int(arg.int_value));

+        case Arg::UINT:

+            return FMT_DISPATCH(visit_uint(arg.uint_value));

+        case Arg::LONG_LONG:

+            return FMT_DISPATCH(visit_long_long(arg.long_long_value));

+        case Arg::ULONG_LONG:

+            return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));

+        case Arg::BOOL:

+            return FMT_DISPATCH(visit_bool(arg.int_value != 0));

+        case Arg::CHAR:

+            return FMT_DISPATCH(visit_char(arg.int_value));

+        case Arg::DOUBLE:

+            return FMT_DISPATCH(visit_double(arg.double_value));

+        case Arg::LONG_DOUBLE:

+            return FMT_DISPATCH(visit_long_double(arg.long_double_value));

+        case Arg::CSTRING:

+            return FMT_DISPATCH(visit_cstring(arg.string.value));

+        case Arg::STRING:

+            return FMT_DISPATCH(visit_string(arg.string));

+        case Arg::WSTRING:

+            return FMT_DISPATCH(visit_wstring(arg.wstring));

+        case Arg::POINTER:

+            return FMT_DISPATCH(visit_pointer(arg.pointer));

+        case Arg::CUSTOM:

+            return FMT_DISPATCH(visit_custom(arg.custom));

+        }

+    }

+};

+

+class RuntimeError: public std::runtime_error

+{

+protected:

+    RuntimeError(): std::runtime_error("")

+    {}

+};

+

+template <typename Char>

+class PrintfArgFormatter;

+

+template <typename Char>

+class ArgMap;

+}  // namespace internal

+

+/** An argument list. */

+class ArgList

+{

+private:

+    // To reduce compiled code size per formatting function call, types of first

+    // MAX_PACKED_ARGS arguments are passed in the types_ field.

+    uint64_t types_;

+    union

+    {

+        // If the number of arguments is less than MAX_PACKED_ARGS, the argument

+        // values are stored in values_, otherwise they are stored in args_.

+        // This is done to reduce compiled code size as storing larger objects

+        // may require more code (at least on x86-64) even if the same amount of

+        // data is actually copied to stack. It saves ~10% on the bloat test.

+        const internal::Value *values_;

+        const internal::Arg *args_;

+    };

+

+    internal::Arg::Type type(unsigned index) const

+    {

+        unsigned shift = index * 4;

+        uint64_t mask = 0xf;

+        return static_cast<internal::Arg::Type>(

+                   (types_ & (mask << shift)) >> shift);

+    }

+

+    template <typename Char>

+    friend class internal::ArgMap;

+

+public:

+    // Maximum number of arguments with packed types.

+    enum

+    {

+        MAX_PACKED_ARGS = 16

+    };

+

+    ArgList(): types_(0)

+    {}

+

+    ArgList(ULongLong types, const internal::Value *values)

+        : types_(types), values_(values)

+    {}

+    ArgList(ULongLong types, const internal::Arg *args)

+        : types_(types), args_(args)

+    {}

+

+    /** Returns the argument at specified index. */

+    internal::Arg operator[](unsigned index) const

+    {

+        using internal::Arg;

+        Arg arg;

+        bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;

+        if (index < MAX_PACKED_ARGS)

+        {

+            Arg::Type arg_type = type(index);

+            internal::Value &val = arg;

+            if (arg_type != Arg::NONE)

+                val = use_values ? values_[index] : args_[index];

+            arg.type = arg_type;

+            return arg;

+        }

+        if (use_values)

+        {

+            // The index is greater than the number of arguments that can be stored

+            // in values, so return a "none" argument.

+            arg.type = Arg::NONE;

+            return arg;

+        }

+        for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i)

+        {

+            if (args_[i].type == Arg::NONE)

+                return args_[i];

+        }

+        return args_[index];

+    }

+};

+

+enum Alignment

+{

+    ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC

+};

+

+// Flags.

+enum

+{

+    SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,

+    CHAR_FLAG = 0x10  // Argument has char type - used in error reporting.

+};

+

+// An empty format specifier.

+struct EmptySpec

+{};

+

+// A type specifier.

+template <char TYPE>

+struct TypeSpec: EmptySpec

+{

+    Alignment align() const

+    {

+        return ALIGN_DEFAULT;

+    }

+    unsigned width() const

+    {

+        return 0;

+    }

+    int precision() const

+    {

+        return -1;

+    }

+    bool flag(unsigned) const

+    {

+        return false;

+    }

+    char type() const

+    {

+        return TYPE;

+    }

+    char fill() const

+    {

+        return ' ';

+    }

+};

+

+// A width specifier.

+struct WidthSpec

+{

+    unsigned width_;

+    // Fill is always wchar_t and cast to char if necessary to avoid having

+    // two specialization of WidthSpec and its subclasses.

+    wchar_t fill_;

+

+    WidthSpec(unsigned width, wchar_t fill): width_(width), fill_(fill)

+    {}

+

+    unsigned width() const

+    {

+        return width_;

+    }

+    wchar_t fill() const

+    {

+        return fill_;

+    }

+};

+

+// An alignment specifier.

+struct AlignSpec: WidthSpec

+{

+    Alignment align_;

+

+    AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)

+        : WidthSpec(width, fill), align_(align)

+    {}

+

+    Alignment align() const

+    {

+        return align_;

+    }

+

+    int precision() const

+    {

+        return -1;

+    }

+};

+

+// An alignment and type specifier.

+template <char TYPE>

+struct AlignTypeSpec: AlignSpec

+{

+    AlignTypeSpec(unsigned width, wchar_t fill): AlignSpec(width, fill)

+    {}

+

+    bool flag(unsigned) const

+    {

+        return false;

+    }

+    char type() const

+    {

+        return TYPE;

+    }

+};

+

+// A full format specifier.

+struct FormatSpec: AlignSpec

+{

+    unsigned flags_;

+    int precision_;

+    char type_;

+

+    FormatSpec(

+        unsigned width = 0, char type = 0, wchar_t fill = ' ')

+        : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type)

+    {}

+

+    bool flag(unsigned f) const

+    {

+        return (flags_ & f) != 0;

+    }

+    int precision() const

+    {

+        return precision_;

+    }

+    char type() const

+    {

+        return type_;

+    }

+};

+

+// An integer format specifier.

+template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>

+class IntFormatSpec: public SpecT

+{

+private:

+    T value_;

+

+public:

+    IntFormatSpec(T val, const SpecT &spec = SpecT())

+        : SpecT(spec), value_(val)

+    {}

+

+    T value() const

+    {

+        return value_;

+    }

+};

+

+// A string format specifier.

+template <typename Char>

+class StrFormatSpec: public AlignSpec

+{

+private:

+    const Char *str_;

+

+public:

+    template <typename FillChar>

+    StrFormatSpec(const Char *str, unsigned width, FillChar fill)

+        : AlignSpec(width, fill), str_(str)

+    {

+        internal::CharTraits<Char>::convert(FillChar());

+    }

+

+    const Char *str() const

+    {

+        return str_;

+    }

+};

+

+/**

+Returns an integer format specifier to format the value in base 2.

+*/

+IntFormatSpec<int, TypeSpec<'b'> > bin(int value);

+

+/**

+Returns an integer format specifier to format the value in base 8.

+*/

+IntFormatSpec<int, TypeSpec<'o'> > oct(int value);

+

+/**

+Returns an integer format specifier to format the value in base 16 using

+lower-case letters for the digits above 9.

+*/

+IntFormatSpec<int, TypeSpec<'x'> > hex(int value);

+

+/**

+Returns an integer formatter format specifier to format in base 16 using

+upper-case letters for the digits above 9.

+*/

+IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);

+

+/**

+\rst

+Returns an integer format specifier to pad the formatted argument with the

+fill character to the specified width using the default (right) numeric

+alignment.

+

+**Example**::

+

+MemoryWriter out;

+out << pad(hex(0xcafe), 8, '0');

+// out.str() == "0000cafe"

+

+\endrst

+*/

+template <char TYPE_CODE, typename Char>

+IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(

+    int value, unsigned width, Char fill = ' ');

+

+#define FMT_DEFINE_INT_FORMATTERS(TYPE) \

+inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \

+  return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \

+} \

+ \

+inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \

+  return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \

+} \

+ \

+inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \

+  return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \

+} \

+ \

+inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \

+  return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \

+} \

+ \

+template <char TYPE_CODE> \

+inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \

+    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \

+  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \

+      f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \

+} \

+ \

+/* For compatibility with older compilers we provide two overloads for pad, */ \

+/* one that takes a fill character and one that doesn't. In the future this */ \

+/* can be replaced with one overload making the template argument Char      */ \

+/* default to char (C++11). */ \

+template <char TYPE_CODE, typename Char> \

+inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \

+    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \

+    unsigned width, Char fill) { \

+  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \

+      f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \

+} \

+ \

+inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \

+    TYPE value, unsigned width) { \

+  return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \

+      value, AlignTypeSpec<0>(width, ' ')); \

+} \

+ \

+template <typename Char> \

+inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \

+   TYPE value, unsigned width, Char fill) { \

+ return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \

+     value, AlignTypeSpec<0>(width, fill)); \

+}

+

+FMT_DEFINE_INT_FORMATTERS(int)

+FMT_DEFINE_INT_FORMATTERS(long)

+FMT_DEFINE_INT_FORMATTERS(unsigned)

+FMT_DEFINE_INT_FORMATTERS(unsigned long)

+FMT_DEFINE_INT_FORMATTERS(LongLong)

+FMT_DEFINE_INT_FORMATTERS(ULongLong)

+

+/**

+\rst

+Returns a string formatter that pads the formatted argument with the fill

+character to the specified width using the default (left) string alignment.

+

+**Example**::

+

+std::string s = str(MemoryWriter() << pad("abc", 8));

+// s == "abc     "

+

+\endrst

+*/

+template <typename Char>

+inline StrFormatSpec<Char> pad(

+    const Char *str, unsigned width, Char fill = ' ')

+{

+    return StrFormatSpec<Char>(str, width, fill);

+}

+

+inline StrFormatSpec<wchar_t> pad(

+    const wchar_t *str, unsigned width, char fill = ' ')

+{

+    return StrFormatSpec<wchar_t>(str, width, fill);

+}

+

+namespace internal

+{

+

+template <typename Char>

+class ArgMap

+{

+private:

+    typedef std::vector<std::pair<fmt::BasicStringRef<Char>, internal::Arg> > MapType;

+    typedef typename MapType::value_type Pair;

+

+    MapType map_;

+

+public:

+    FMT_API void init(const ArgList &args);

+

+    const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const

+    {

+        // The list is unsorted, so just return the first matching name.

+        for (typename MapType::const_iterator it = map_.begin(), end = map_.end();

+                it != end; ++it)

+        {

+            if (it->first == name)

+                return &it->second;

+        }

+        return 0;

+    }

+};

+

+template <typename Impl, typename Char>

+class ArgFormatterBase: public ArgVisitor<Impl, void>

+{

+private:

+    BasicWriter<Char> &writer_;

+    FormatSpec &spec_;

+

+    FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);

+

+    void write_pointer(const void *p)

+    {

+        spec_.flags_ = HASH_FLAG;

+        spec_.type_ = 'x';

+        writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);

+    }

+

+protected:

+    BasicWriter<Char> &writer()

+    {

+        return writer_;

+    }

+    FormatSpec &spec()

+    {

+        return spec_;

+    }

+

+    void write(bool value)

+    {

+        const char *str_value = value ? "true" : "false";

+        Arg::StringValue<char> str = { str_value, std::strlen(str_value) };

+        writer_.write_str(str, spec_);

+    }

+

+    void write(const char *value)

+    {

+        Arg::StringValue<char> str = { value, value != 0 ? std::strlen(value) : 0 };

+        writer_.write_str(str, spec_);

+    }

+

+public:

+    ArgFormatterBase(BasicWriter<Char> &w, FormatSpec &s)

+        : writer_(w), spec_(s)

+    {}

+

+    template <typename T>

+    void visit_any_int(T value)

+    {

+        writer_.write_int(value, spec_);

+    }

+

+    template <typename T>

+    void visit_any_double(T value)

+    {

+        writer_.write_double(value, spec_);

+    }

+

+    void visit_bool(bool value)

+    {

+        if (spec_.type_)

+            return visit_any_int(value);

+        write(value);

+    }

+

+    void visit_char(int value)

+    {

+        if (spec_.type_ && spec_.type_ != 'c')

+        {

+            spec_.flags_ |= CHAR_FLAG;

+            writer_.write_int(value, spec_);

+            return;

+        }

+        if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)

+            FMT_THROW(FormatError("invalid format specifier for char"));

+        typedef typename BasicWriter<Char>::CharPtr CharPtr;

+        Char fill = internal::CharTraits<Char>::cast(spec_.fill());

+        CharPtr out = CharPtr();

+        const unsigned CHAR_WIDTH = 1;

+        if (spec_.width_ > CHAR_WIDTH)

+        {

+            out = writer_.grow_buffer(spec_.width_);

+            if (spec_.align_ == ALIGN_RIGHT)

+            {

+                std::uninitialized_fill_n(out, spec_.width_ - CHAR_WIDTH, fill);

+                out += spec_.width_ - CHAR_WIDTH;

+            }

+            else if (spec_.align_ == ALIGN_CENTER)

+            {

+                out = writer_.fill_padding(out, spec_.width_,

+                                           internal::check(CHAR_WIDTH), fill);

+            }

+            else

+            {

+                std::uninitialized_fill_n(out + CHAR_WIDTH,

+                                          spec_.width_ - CHAR_WIDTH, fill);

+            }

+        }

+        else

+        {

+            out = writer_.grow_buffer(CHAR_WIDTH);

+        }

+        *out = internal::CharTraits<Char>::cast(value);

+    }

+

+    void visit_cstring(const char *value)

+    {

+        if (spec_.type_ == 'p')

+            return write_pointer(value);

+        write(value);

+    }

+

+    void visit_string(Arg::StringValue<char> value)

+    {

+        writer_.write_str(value, spec_);

+    }

+

+    using ArgVisitor<Impl, void>::visit_wstring;

+

+    void visit_wstring(Arg::StringValue<Char> value)

+    {

+        writer_.write_str(value, spec_);

+    }

+

+    void visit_pointer(const void *value)

+    {

+        if (spec_.type_ && spec_.type_ != 'p')

+            report_unknown_type(spec_.type_, "pointer");

+        write_pointer(value);

+    }

+};

+

+// An argument formatter.

+template <typename Char>

+class BasicArgFormatter:

+    public ArgFormatterBase<BasicArgFormatter<Char>, Char>

+{

+private:

+    BasicFormatter<Char> &formatter_;

+    const Char *format_;

+

+public:

+    BasicArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)

+        : ArgFormatterBase<BasicArgFormatter<Char>, Char>(f.writer(), s),

+          formatter_(f), format_(fmt)

+    {}

+

+    void visit_custom(Arg::CustomValue c)

+    {

+        c.format(&formatter_, c.value, &format_);

+    }

+};

+

+class FormatterBase

+{

+private:

+    ArgList args_;

+    int next_arg_index_;

+

+    // Returns the argument with specified index.

+    FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);

+

+protected:

+    const ArgList &args() const

+    {

+        return args_;

+    }

+

+    explicit FormatterBase(const ArgList &args)

+    {

+        args_ = args;

+        next_arg_index_ = 0;

+    }

+

+    // Returns the next argument.

+    Arg next_arg(const char *&error)

+    {

+        if (next_arg_index_ >= 0)

+            return do_get_arg(internal::to_unsigned(next_arg_index_++), error);

+        error = "cannot switch from manual to automatic argument indexing";

+        return Arg();

+    }

+

+    // Checks if manual indexing is used and returns the argument with

+    // specified index.

+    Arg get_arg(unsigned arg_index, const char *&error)

+    {

+        return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();

+    }

+

+    bool check_no_auto_index(const char *&error)

+    {

+        if (next_arg_index_ > 0)

+        {

+            error = "cannot switch from automatic to manual argument indexing";

+            return false;

+        }

+        next_arg_index_ = -1;

+        return true;

+    }

+

+    template <typename Char>

+    void write(BasicWriter<Char> &w, const Char *start, const Char *end)

+    {

+        if (start != end)

+            w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));

+    }

+};

+

+// A printf formatter.

+template <typename Char>

+class PrintfFormatter: private FormatterBase

+{

+private:

+    void parse_flags(FormatSpec &spec, const Char *&s);

+

+    // Returns the argument with specified index or, if arg_index is equal

+    // to the maximum unsigned value, the next argument.

+    Arg get_arg(const Char *s,

+                unsigned arg_index = (std::numeric_limits<unsigned>::max)());

+

+    // Parses argument index, flags and width and returns the argument index.

+    unsigned parse_header(const Char *&s, FormatSpec &spec);

+

+public:

+    explicit PrintfFormatter(const ArgList &args): FormatterBase(args)

+    {}

+    FMT_API void format(BasicWriter<Char> &writer,

+                        BasicCStringRef<Char> format_str);

+};

+}  // namespace internal

+

+/** This template formats data and writes the output to a writer. */

+template <typename CharType, typename ArgFormatter>

+class BasicFormatter: private internal::FormatterBase

+{

+public:

+    /** The character type for the output. */

+    typedef CharType Char;

+

+private:

+    BasicWriter<Char> &writer_;

+    internal::ArgMap<Char> map_;

+

+    FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);

+

+    using internal::FormatterBase::get_arg;

+

+    // Checks if manual indexing is used and returns the argument with

+    // specified name.

+    internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);

+

+    // Parses argument index and returns corresponding argument.

+    internal::Arg parse_arg_index(const Char *&s);

+

+    // Parses argument name and returns corresponding argument.

+    internal::Arg parse_arg_name(const Char *&s);

+

+public:

+    /**

+    \rst

+    Constructs a ``BasicFormatter`` object. References to the arguments and

+    the writer are stored in the formatter object so make sure they have

+    appropriate lifetimes.

+    \endrst

+    */

+    BasicFormatter(const ArgList &args, BasicWriter<Char> &w)

+        : internal::FormatterBase(args), writer_(w)

+    {}

+

+    /** Returns a reference to the writer associated with this formatter. */

+    BasicWriter<Char> &writer()

+    {

+        return writer_;

+    }

+

+    /** Formats stored arguments and writes the output to the writer. */

+    void format(BasicCStringRef<Char> format_str);

+

+    // Formats a single argument and advances format_str, a format string pointer.

+    const Char *format(const Char *&format_str, const internal::Arg &arg);

+};

+

+// Generates a comma-separated list with results of applying f to

+// numbers 0..n-1.

+# define FMT_GEN(n, f) FMT_GEN##n(f)

+# define FMT_GEN1(f)  f(0)

+# define FMT_GEN2(f)  FMT_GEN1(f),  f(1)

+# define FMT_GEN3(f)  FMT_GEN2(f),  f(2)

+# define FMT_GEN4(f)  FMT_GEN3(f),  f(3)

+# define FMT_GEN5(f)  FMT_GEN4(f),  f(4)

+# define FMT_GEN6(f)  FMT_GEN5(f),  f(5)

+# define FMT_GEN7(f)  FMT_GEN6(f),  f(6)

+# define FMT_GEN8(f)  FMT_GEN7(f),  f(7)

+# define FMT_GEN9(f)  FMT_GEN8(f),  f(8)

+# define FMT_GEN10(f) FMT_GEN9(f),  f(9)

+# define FMT_GEN11(f) FMT_GEN10(f), f(10)

+# define FMT_GEN12(f) FMT_GEN11(f), f(11)

+# define FMT_GEN13(f) FMT_GEN12(f), f(12)

+# define FMT_GEN14(f) FMT_GEN13(f), f(13)

+# define FMT_GEN15(f) FMT_GEN14(f), f(14)

+

+namespace internal

+{

+inline uint64_t make_type()

+{

+    return 0;

+}

+

+template <typename T>

+inline uint64_t make_type(const T &arg)

+{

+    return MakeValue< BasicFormatter<char> >::type(arg);

+}

+

+template <unsigned N, bool/*IsPacked*/ = (N < ArgList::MAX_PACKED_ARGS)>

+          struct ArgArray;

+

+template <unsigned N>

+struct ArgArray<N, true/*IsPacked*/>

+{

+    typedef Value Type[N > 0 ? N : 1];

+

+template <typename Formatter, typename T>

+static Value make(const T &value)

+{

+    Value result = MakeValue<Formatter>(value);

+    // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang:

+    // https://github.com/cppformat/cppformat/issues/276

+    (void)result.custom.format;

+    return result;

+}

+         };

+

+template <unsigned N>

+struct ArgArray<N, false/*IsPacked*/>

+{

+    typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE

+

+    template <typename Formatter, typename T>

+    static Arg make(const T &value)

+    {

+        return MakeArg<Formatter>(value);

+    }

+};

+

+#if FMT_USE_VARIADIC_TEMPLATES

+template <typename Arg, typename... Args>

+inline uint64_t make_type(const Arg &first, const Args & ... tail)

+{

+    return make_type(first) | (make_type(tail...) << 4);

+}

+

+#else

+

+struct ArgType

+{

+    uint64_t type;

+

+    ArgType(): type(0)

+    {}

+

+    template <typename T>

+    ArgType(const T &arg) : type(make_type(arg))

+    {}

+};

+

+# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()

+

+inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT))

+{

+    return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |

+           (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |

+           (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |

+           (t12.type << 48) | (t13.type << 52) | (t14.type << 56);

+}

+#endif

+

+template <class Char>

+class FormatBuf: public std::basic_streambuf<Char>

+{

+private:

+    typedef typename std::basic_streambuf<Char>::int_type int_type;

+    typedef typename std::basic_streambuf<Char>::traits_type traits_type;

+

+    Buffer<Char> &buffer_;

+    Char *start_;

+

+public:

+    FormatBuf(Buffer<Char> &buffer): buffer_(buffer), start_(&buffer[0])

+    {

+        this->setp(start_, start_ + buffer_.capacity());

+    }

+

+    int_type overflow(int_type ch = traits_type::eof())

+    {

+        if (!traits_type::eq_int_type(ch, traits_type::eof()))

+        {

+            size_t size = this->size();

+            buffer_.resize(size);

+            buffer_.reserve(size * 2);

+

+            start_ = &buffer_[0];

+            start_[size] = traits_type::to_char_type(ch);

+            this->setp(start_ + size + 1, start_ + size * 2);

+        }

+        return ch;

+    }

+

+    size_t size() const

+    {

+        return to_unsigned(this->pptr() - start_);

+    }

+};

+}  // namespace internal

+

+# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n

+# define FMT_MAKE_ARG_TYPE(n) T##n

+# define FMT_MAKE_ARG(n) const T##n &v##n

+# define FMT_ASSIGN_char(n) \

+  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)

+# define FMT_ASSIGN_wchar_t(n) \

+  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)

+

+#if FMT_USE_VARIADIC_TEMPLATES

+// Defines a variadic function returning void.

+# define FMT_VARIADIC_VOID(func, arg_type) \

+  template <typename... Args> \

+  void func(arg_type arg0, const Args & ... args) { \

+    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \

+    typename ArgArray::Type array{ \

+      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \

+    func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \

+  }

+

+// Defines a variadic constructor.

+# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \

+  template <typename... Args> \

+  ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \

+    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \

+    typename ArgArray::Type array{ \

+      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \

+    func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \

+  }

+

+#else

+

+# define FMT_MAKE_REF(n) \

+  fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)

+# define FMT_MAKE_REF2(n) v##n

+

+// Defines a wrapper for a function taking one argument of type arg_type

+// and n additional arguments of arbitrary types.

+# define FMT_WRAP1(func, arg_type, n) \

+  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \

+  inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \

+    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \

+    func(arg1, fmt::ArgList( \

+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \

+  }

+

+// Emulates a variadic function returning void on a pre-C++11 compiler.

+# define FMT_VARIADIC_VOID(func, arg_type) \

+  inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \

+  FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \

+  FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \

+  FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \

+  FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \

+  FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)

+

+# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \

+  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \

+  ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \

+    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \

+    func(arg0, arg1, fmt::ArgList( \

+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \

+  }

+

+// Emulates a variadic constructor on a pre-C++11 compiler.

+# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \

+  FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)

+#endif

+

+// Generates a comma-separated list with results of applying f to pairs

+// (argument, index).

+#define FMT_FOR_EACH1(f, x0) f(x0, 0)

+#define FMT_FOR_EACH2(f, x0, x1) \

+  FMT_FOR_EACH1(f, x0), f(x1, 1)

+#define FMT_FOR_EACH3(f, x0, x1, x2) \

+  FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)

+#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \

+  FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)

+#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \

+  FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)

+#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \

+  FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)

+#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \

+  FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)

+#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \

+  FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)

+#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \

+  FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)

+#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \

+  FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)

+

+/**

+An error returned by an operating system or a language runtime,

+for example a file opening error.

+*/

+class SystemError: public internal::RuntimeError

+{

+private:

+    void init(int err_code, CStringRef format_str, ArgList args);

+

+protected:

+    int error_code_;

+

+    typedef char Char;  // For FMT_VARIADIC_CTOR.

+

+    SystemError()

+    {}

+

+public:

+    /**

+    \rst

+    Constructs a :class:`fmt::SystemError` object with the description

+    of the form

+

+    .. parsed-literal::

+    *<message>*: *<system-message>*

+

+    where *<message>* is the formatted message and *<system-message>* is

+    the system message corresponding to the error code.

+    *error_code* is a system error code as given by ``errno``.

+    If *error_code* is not a valid error code such as -1, the system message

+    may look like "Unknown error -1" and is platform-dependent.

+

+    **Example**::

+

+    // This throws a SystemError with the description

+    //   cannot open file 'madeup': No such file or directory

+    // or similar (system message may vary).

+    const char *filename = "madeup";

+    std::FILE *file = std::fopen(filename, "r");

+    if (!file)

+    throw fmt::SystemError(errno, "cannot open file '{}'", filename);

+    \endrst

+    */

+    SystemError(int error_code, CStringRef message)

+    {

+        init(error_code, message, ArgList());

+    }

+    FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)

+

+    int error_code() const

+    {

+        return error_code_;

+    }

+};

+

+/**

+\rst

+This template provides operations for formatting and writing data into

+a character stream. The output is stored in a buffer provided by a subclass

+such as :class:`fmt::BasicMemoryWriter`.

+

+You can use one of the following typedefs for common character types:

+

++---------+----------------------+

+| Type    | Definition           |

++=========+======================+

+| Writer  | BasicWriter<char>    |

++---------+----------------------+

+| WWriter | BasicWriter<wchar_t> |

++---------+----------------------+

+

+\endrst

+*/

+template <typename Char>

+class BasicWriter

+{

+private:

+    // Output buffer.

+    Buffer<Char> &buffer_;

+

+    FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);

+

+    typedef typename internal::CharTraits<Char>::CharPtr CharPtr;

+

+#if FMT_SECURE_SCL

+    // Returns pointer value.

+    static Char *get(CharPtr p)

+    {

+        return p.base();

+    }

+#else

+    static Char *get(Char *p)

+    {

+        return p;

+    }

+#endif

+

+    // Fills the padding around the content and returns the pointer to the

+    // content area.

+    static CharPtr fill_padding(CharPtr buffer,

+                                unsigned total_size, std::size_t content_size, wchar_t fill);

+

+    // Grows the buffer by n characters and returns a pointer to the newly

+    // allocated area.

+    CharPtr grow_buffer(std::size_t n)

+    {

+        std::size_t size = buffer_.size();

+        buffer_.resize(size + n);

+        return internal::make_ptr(&buffer_[size], n);

+    }

+

+    // Writes an unsigned decimal integer.

+    template <typename UInt>

+    Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0)

+    {

+        unsigned num_digits = internal::count_digits(value);

+        Char *ptr = get(grow_buffer(prefix_size + num_digits));

+        internal::format_decimal(ptr + prefix_size, value, num_digits);

+        return ptr;

+    }

+

+    // Writes a decimal integer.

+    template <typename Int>

+    void write_decimal(Int value)

+    {

+        typedef typename internal::IntTraits<Int>::MainType MainType;

+        MainType abs_value = static_cast<MainType>(value);

+        if (internal::is_negative(value))

+        {

+            abs_value = 0 - abs_value;

+            *write_unsigned_decimal(abs_value, 1) = '-';

+        }

+        else

+        {

+            write_unsigned_decimal(abs_value, 0);

+        }

+    }

+

+    // Prepare a buffer for integer formatting.

+    CharPtr prepare_int_buffer(unsigned num_digits,

+                               const EmptySpec &, const char *prefix, unsigned prefix_size)

+    {

+        unsigned size = prefix_size + num_digits;

+        CharPtr p = grow_buffer(size);

+        std::uninitialized_copy(prefix, prefix + prefix_size, p);

+        return p + size - 1;

+    }

+

+    template <typename Spec>

+    CharPtr prepare_int_buffer(unsigned num_digits,

+                               const Spec &spec, const char *prefix, unsigned prefix_size);

+

+    // Formats an integer.

+    template <typename T, typename Spec>

+    void write_int(T value, Spec spec);

+

+    // Formats a floating-point number (double or long double).

+    template <typename T>

+    void write_double(T value, const FormatSpec &spec);

+

+    // Writes a formatted string.

+    template <typename StrChar>

+    CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);

+

+    template <typename StrChar>

+    void write_str(const internal::Arg::StringValue<StrChar> &str,

+                   const FormatSpec &spec);

+

+    // This following methods are private to disallow writing wide characters

+    // and strings to a char stream. If you want to print a wide string as a

+    // pointer as std::ostream does, cast it to const void*.

+    // Do not implement!

+    void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);

+    void operator<<(

+        typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);

+

+    // Appends floating-point length specifier to the format string.

+    // The second argument is only used for overload resolution.

+    void append_float_length(Char *&format_ptr, long double)

+    {

+        *format_ptr++ = 'L';

+    }

+

+    template<typename T>

+    void append_float_length(Char *&, T)

+    {}

+

+    template <typename Impl, typename Char_>

+    friend class internal::ArgFormatterBase;

+

+    friend class internal::PrintfArgFormatter<Char>;

+

+protected:

+    /**

+    Constructs a ``BasicWriter`` object.

+    */

+    explicit BasicWriter(Buffer<Char> &b): buffer_(b)

+    {}

+

+public:

+    /**

+    \rst

+    Destroys a ``BasicWriter`` object.

+    \endrst

+    */

+    virtual ~BasicWriter()

+    {}

+

+    /**

+    Returns the total number of characters written.

+    */

+    std::size_t size() const

+    {

+        return buffer_.size();

+    }

+

+    /**

+    Returns a pointer to the output buffer content. No terminating null

+    character is appended.

+    */

+    const Char *data() const FMT_NOEXCEPT

+    {

+        return &buffer_[0];

+    }

+

+    /**

+    Returns a pointer to the output buffer content with terminating null

+    character appended.

+    */

+    const Char *c_str() const

+    {

+        std::size_t size = buffer_.size();

+        buffer_.reserve(size + 1);

+        buffer_[size] = '\0';

+        return &buffer_[0];

+    }

+

+    /**

+    \rst

+    Returns the content of the output buffer as an `std::string`.

+    \endrst

+    */

+    std::basic_string<Char> str() const

+    {

+        return std::basic_string<Char>(&buffer_[0], buffer_.size());

+    }

+

+    /**

+    \rst

+    Writes formatted data.

+

+    *args* is an argument list representing arbitrary arguments.

+

+    **Example**::

+

+    MemoryWriter out;

+    out.write("Current point:\n");

+    out.write("({:+f}, {:+f})", -3.14, 3.14);

+

+    This will write the following output to the ``out`` object:

+

+    .. code-block:: none

+

+    Current point:

+    (-3.140000, +3.140000)

+

+    The output can be accessed using :func:`data()`, :func:`c_str` or

+    :func:`str` methods.

+

+    See also :ref:`syntax`.

+    \endrst

+    */

+    void write(BasicCStringRef<Char> format, ArgList args)

+    {

+        BasicFormatter<Char>(args, *this).format(format);

+    }

+    FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)

+

+    BasicWriter &operator<<(int value)

+    {

+        write_decimal(value);

+        return *this;

+    }

+    BasicWriter &operator<<(unsigned value)

+    {

+        return *this << IntFormatSpec<unsigned>(value);

+    }

+    BasicWriter &operator<<(long value)

+    {

+        write_decimal(value);

+        return *this;

+    }

+    BasicWriter &operator<<(unsigned long value)

+    {

+        return *this << IntFormatSpec<unsigned long>(value);

+    }

+    BasicWriter &operator<<(LongLong value)

+    {

+        write_decimal(value);

+        return *this;

+    }

+

+    /**

+    \rst

+    Formats *value* and writes it to the stream.

+    \endrst

+    */

+    BasicWriter &operator<<(ULongLong value)

+    {

+        return *this << IntFormatSpec<ULongLong>(value);

+    }

+

+    BasicWriter &operator<<(double value)

+    {

+        write_double(value, FormatSpec());

+        return *this;

+    }

+

+    /**

+    \rst

+    Formats *value* using the general format for floating-point numbers

+    (``'g'``) and writes it to the stream.

+    \endrst

+    */

+    BasicWriter &operator<<(long double value)

+    {

+        write_double(value, FormatSpec());

+        return *this;

+    }

+

+    /**

+    Writes a character to the stream.

+    */

+    BasicWriter &operator<<(char value)

+    {

+        buffer_.push_back(value);

+        return *this;

+    }

+

+    BasicWriter &operator<<(

+        typename internal::WCharHelper<wchar_t, Char>::Supported value)

+    {

+        buffer_.push_back(value);

+        return *this;

+    }

+

+    /**

+    \rst

+    Writes *value* to the stream.

+    \endrst

+    */

+    BasicWriter &operator<<(fmt::BasicStringRef<Char> value)

+    {

+        const Char *str = value.data();

+        buffer_.append(str, str + value.size());

+        return *this;

+    }

+

+    BasicWriter &operator<<(

+        typename internal::WCharHelper<StringRef, Char>::Supported value)

+    {

+        const char *str = value.data();

+        buffer_.append(str, str + value.size());

+        return *this;

+    }

+

+    template <typename T, typename Spec, typename FillChar>

+    BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec)

+    {

+        internal::CharTraits<Char>::convert(FillChar());

+        write_int(spec.value(), spec);

+        return *this;

+    }

+

+    template <typename StrChar>

+    BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec)

+    {

+        const StrChar *s = spec.str();

+        write_str(s, std::char_traits<Char>::length(s), spec);

+        return *this;

+    }

+

+    void clear() FMT_NOEXCEPT

+    {

+        buffer_.clear();

+    }

+};

+

+template <typename Char>

+template <typename StrChar>

+typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(

+    const StrChar *s, std::size_t size, const AlignSpec &spec)

+{

+    CharPtr out = CharPtr();

+    if (spec.width() > size)

+    {

+        out = grow_buffer(spec.width());

+        Char fill = internal::CharTraits<Char>::cast(spec.fill());

+        if (spec.align() == ALIGN_RIGHT)

+        {

+            std::uninitialized_fill_n(out, spec.width() - size, fill);

+            out += spec.width() - size;

+        }

+        else if (spec.align() == ALIGN_CENTER)

+        {

+            out = fill_padding(out, spec.width(), size, fill);

+        }

+        else

+        {

+            std::uninitialized_fill_n(out + size, spec.width() - size, fill);

+        }

+    }

+    else

+    {

+        out = grow_buffer(size);

+    }

+    std::uninitialized_copy(s, s + size, out);

+    return out;

+}

+

+template <typename Char>

+template <typename StrChar>

+void BasicWriter<Char>::write_str(

+    const internal::Arg::StringValue<StrChar> &s, const FormatSpec &spec)

+{

+    // Check if StrChar is convertible to Char.

+    internal::CharTraits<Char>::convert(StrChar());

+    if (spec.type_ && spec.type_ != 's')

+        internal::report_unknown_type(spec.type_, "string");

+    const StrChar *str_value = s.value;

+    std::size_t str_size = s.size;

+    if (str_size == 0)

+    {

+        if (!str_value)

+        {

+            FMT_THROW(FormatError("string pointer is null"));

+            return;

+        }

+    }

+    std::size_t precision = static_cast<std::size_t>(spec.precision_);

+    if (spec.precision_ >= 0 && precision < str_size)

+        str_size = precision;

+    write_str(str_value, str_size, spec);

+}

+

+template <typename Char>

+typename BasicWriter<Char>::CharPtr

+BasicWriter<Char>::fill_padding(

+    CharPtr buffer, unsigned total_size,

+    std::size_t content_size, wchar_t fill)

+{

+    std::size_t padding = total_size - content_size;

+    std::size_t left_padding = padding / 2;

+    Char fill_char = internal::CharTraits<Char>::cast(fill);

+    std::uninitialized_fill_n(buffer, left_padding, fill_char);

+    buffer += left_padding;

+    CharPtr content = buffer;

+    std::uninitialized_fill_n(buffer + content_size,

+                              padding - left_padding, fill_char);

+    return content;

+}

+

+template <typename Char>

+template <typename Spec>

+typename BasicWriter<Char>::CharPtr

+BasicWriter<Char>::prepare_int_buffer(

+    unsigned num_digits, const Spec &spec,

+    const char *prefix, unsigned prefix_size)

+{

+    unsigned width = spec.width();

+    Alignment align = spec.align();

+    Char fill = internal::CharTraits<Char>::cast(spec.fill());

+    if (spec.precision() > static_cast<int>(num_digits))

+    {

+        // Octal prefix '0' is counted as a digit, so ignore it if precision

+        // is specified.

+        if (prefix_size > 0 && prefix[prefix_size - 1] == '0')

+            --prefix_size;

+        unsigned number_size =

+            prefix_size + internal::to_unsigned(spec.precision());

+        AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);

+        if (number_size >= width)

+            return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);

+        buffer_.reserve(width);

+        unsigned fill_size = width - number_size;

+        if (align != ALIGN_LEFT)

+        {

+            CharPtr p = grow_buffer(fill_size);

+            std::uninitialized_fill(p, p + fill_size, fill);

+        }

+        CharPtr result = prepare_int_buffer(

+                             num_digits, subspec, prefix, prefix_size);

+        if (align == ALIGN_LEFT)

+        {

+            CharPtr p = grow_buffer(fill_size);

+            std::uninitialized_fill(p, p + fill_size, fill);

+        }

+        return result;

+    }

+    unsigned size = prefix_size + num_digits;

+    if (width <= size)

+    {

+        CharPtr p = grow_buffer(size);

+        std::uninitialized_copy(prefix, prefix + prefix_size, p);

+        return p + size - 1;

+    }

+    CharPtr p = grow_buffer(width);

+    CharPtr end = p + width;

+    if (align == ALIGN_LEFT)

+    {

+        std::uninitialized_copy(prefix, prefix + prefix_size, p);

+        p += size;

+        std::uninitialized_fill(p, end, fill);

+    }

+    else if (align == ALIGN_CENTER)

+    {

+        p = fill_padding(p, width, size, fill);

+        std::uninitialized_copy(prefix, prefix + prefix_size, p);

+        p += size;

+    }

+    else

+    {

+        if (align == ALIGN_NUMERIC)

+        {

+            if (prefix_size != 0)

+            {

+                p = std::uninitialized_copy(prefix, prefix + prefix_size, p);

+                size -= prefix_size;

+            }

+        }

+        else

+        {

+            std::uninitialized_copy(prefix, prefix + prefix_size, end - size);

+        }

+        std::uninitialized_fill(p, end - size, fill);

+        p = end;

+    }

+    return p - 1;

+}

+

+template <typename Char>

+template <typename T, typename Spec>

+void BasicWriter<Char>::write_int(T value, Spec spec)

+{

+    unsigned prefix_size = 0;

+    typedef typename internal::IntTraits<T>::MainType UnsignedType;

+    UnsignedType abs_value = static_cast<UnsignedType>(value);

+    char prefix[4] = "";

+    if (internal::is_negative(value))

+    {

+        prefix[0] = '-';

+        ++prefix_size;

+        abs_value = 0 - abs_value;

+    }

+    else if (spec.flag(SIGN_FLAG))

+    {

+        prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';

+        ++prefix_size;

+    }

+    switch (spec.type())

+    {

+    case 0:

+    case 'd':

+    {

+        unsigned num_digits = internal::count_digits(abs_value);

+        CharPtr p = prepare_int_buffer(

+                        num_digits, spec, prefix, prefix_size) + 1 - num_digits;

+        internal::format_decimal(get(p), abs_value, num_digits);

+        break;

+    }

+    case 'x':

+    case 'X':

+    {

+        UnsignedType n = abs_value;

+        if (spec.flag(HASH_FLAG))

+        {

+            prefix[prefix_size++] = '0';

+            prefix[prefix_size++] = spec.type();

+        }

+        unsigned num_digits = 0;

+        do

+        {

+            ++num_digits;

+        }

+        while ((n >>= 4) != 0);

+        Char *p = get(prepare_int_buffer(

+                          num_digits, spec, prefix, prefix_size));

+        n = abs_value;

+        const char *digits = spec.type() == 'x' ?

+                             "0123456789abcdef" : "0123456789ABCDEF";

+        do

+        {

+            *p-- = digits[n & 0xf];

+        }

+        while ((n >>= 4) != 0);

+        break;

+    }

+    case 'b':

+    case 'B':

+    {

+        UnsignedType n = abs_value;

+        if (spec.flag(HASH_FLAG))

+        {

+            prefix[prefix_size++] = '0';

+            prefix[prefix_size++] = spec.type();

+        }

+        unsigned num_digits = 0;

+        do

+        {

+            ++num_digits;

+        }

+        while ((n >>= 1) != 0);

+        Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));

+        n = abs_value;

+        do

+        {

+            *p-- = static_cast<Char>('0' + (n & 1));

+        }

+        while ((n >>= 1) != 0);

+        break;

+    }

+    case 'o':

+    {

+        UnsignedType n = abs_value;

+        if (spec.flag(HASH_FLAG))

+            prefix[prefix_size++] = '0';

+        unsigned num_digits = 0;

+        do

+        {

+            ++num_digits;

+        }

+        while ((n >>= 3) != 0);

+        Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));

+        n = abs_value;

+        do

+        {

+            *p-- = static_cast<Char>('0' + (n & 7));

+        }

+        while ((n >>= 3) != 0);

+        break;

+    }

+    default:

+        internal::report_unknown_type(

+            spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");

+        break;

+    }

+}

+

+template <typename Char>

+template <typename T>

+void BasicWriter<Char>::write_double(T value, const FormatSpec &spec)

+{

+    // Check type.

+    char type = spec.type();

+    bool upper = false;

+    switch (type)

+    {

+    case 0:

+        type = 'g';

+        break;

+    case 'e':

+    case 'f':

+    case 'g':

+    case 'a':

+        break;

+    case 'F':

+#ifdef _MSC_VER

+        // MSVC's printf doesn't support 'F'.

+        type = 'f';

+#endif

+    // Fall through.

+    case 'E':

+    case 'G':

+    case 'A':

+        upper = true;

+        break;

+    default:

+        internal::report_unknown_type(type, "double");

+        break;

+    }

+

+    char sign = 0;

+    // Use isnegative instead of value < 0 because the latter is always

+    // false for NaN.

+    if (internal::FPUtil::isnegative(static_cast<double>(value)))

+    {

+        sign = '-';

+        value = -value;

+    }

+    else if (spec.flag(SIGN_FLAG))

+    {

+        sign = spec.flag(PLUS_FLAG) ? '+' : ' ';

+    }

+

+    if (internal::FPUtil::isnotanumber(value))

+    {

+        // Format NaN ourselves because sprintf's output is not consistent

+        // across platforms.

+        std::size_t nan_size = 4;

+        const char *nan = upper ? " NAN" : " nan";

+        if (!sign)

+        {

+            --nan_size;

+            ++nan;

+        }

+        CharPtr out = write_str(nan, nan_size, spec);

+        if (sign)

+            *out = sign;

+        return;

+    }

+

+    if (internal::FPUtil::isinfinity(value))

+    {

+        // Format infinity ourselves because sprintf's output is not consistent

+        // across platforms.

+        std::size_t inf_size = 4;

+        const char *inf = upper ? " INF" : " inf";

+        if (!sign)

+        {

+            --inf_size;

+            ++inf;

+        }

+        CharPtr out = write_str(inf, inf_size, spec);

+        if (sign)

+            *out = sign;

+        return;

+    }

+

+    std::size_t offset = buffer_.size();

+    unsigned width = spec.width();

+    if (sign)

+    {

+        buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));

+        if (width > 0)

+            --width;

+        ++offset;

+    }

+

+    // Build format string.

+    enum

+    {

+        MAX_FORMAT_SIZE = 10

+    }; // longest format: %#-*.*Lg

+    Char format[MAX_FORMAT_SIZE];

+    Char *format_ptr = format;

+    *format_ptr++ = '%';

+    unsigned width_for_sprintf = width;

+    if (spec.flag(HASH_FLAG))

+        *format_ptr++ = '#';

+    if (spec.align() == ALIGN_CENTER)

+    {

+        width_for_sprintf = 0;

+    }

+    else

+    {

+        if (spec.align() == ALIGN_LEFT)

+            *format_ptr++ = '-';

+        if (width != 0)

+            *format_ptr++ = '*';

+    }

+    if (spec.precision() >= 0)

+    {

+        *format_ptr++ = '.';

+        *format_ptr++ = '*';

+    }

+

+    append_float_length(format_ptr, value);

+    *format_ptr++ = type;

+    *format_ptr = '\0';

+

+    // Format using snprintf.

+    Char fill = internal::CharTraits<Char>::cast(spec.fill());

+    unsigned n = 0;

+    Char *start = 0;

+    for (;;)

+    {

+        std::size_t buffer_size = buffer_.capacity() - offset;

+#ifdef _MSC_VER

+        // MSVC's vsnprintf_s doesn't work with zero size, so reserve

+        // space for at least one extra character to make the size non-zero.

+        // Note that the buffer's capacity will increase by more than 1.

+        if (buffer_size == 0)

+        {

+            buffer_.reserve(offset + 1);

+            buffer_size = buffer_.capacity() - offset;

+        }

+#endif

+        start = &buffer_[offset];

+        int result = internal::CharTraits<Char>::format_float(

+                         start, buffer_size, format, width_for_sprintf, spec.precision(), value);

+        if (result >= 0)

+        {

+            n = internal::to_unsigned(result);

+            if (offset + n < buffer_.capacity())

+                break;  // The buffer is large enough - continue with formatting.

+            buffer_.reserve(offset + n + 1);

+        }

+        else

+        {

+            // If result is negative we ask to increase the capacity by at least 1,

+            // but as std::vector, the buffer grows exponentially.

+            buffer_.reserve(buffer_.capacity() + 1);

+        }

+    }

+    if (sign)

+    {

+        if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||

+                *start != ' ')

+        {

+            *(start - 1) = sign;

+            sign = 0;

+        }

+        else

+        {

+            *(start - 1) = fill;

+        }

+        ++n;

+    }

+    if (spec.align() == ALIGN_CENTER && spec.width() > n)

+    {

+        width = spec.width();

+        CharPtr p = grow_buffer(width);

+        std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));

+        fill_padding(p, spec.width(), n, fill);

+        return;

+    }

+    if (spec.fill() != ' ' || sign)

+    {

+        while (*start == ' ')

+            *start++ = fill;

+        if (sign)

+            *(start - 1) = sign;

+    }

+    grow_buffer(n);

+}

+

+/**

+\rst

+This class template provides operations for formatting and writing data

+into a character stream. The output is stored in a memory buffer that grows

+dynamically.

+

+You can use one of the following typedefs for common character types

+and the standard allocator:

+

++---------------+-----------------------------------------------------+

+| Type          | Definition                                          |

++===============+=====================================================+

+| MemoryWriter  | BasicMemoryWriter<char, std::allocator<char>>       |

++---------------+-----------------------------------------------------+

+| WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |

++---------------+-----------------------------------------------------+

+

+**Example**::

+

+MemoryWriter out;

+out << "The answer is " << 42 << "\n";

+out.write("({:+f}, {:+f})", -3.14, 3.14);

+

+This will write the following output to the ``out`` object:

+

+.. code-block:: none

+

+The answer is 42

+(-3.140000, +3.140000)

+

+The output can be converted to an ``std::string`` with ``out.str()`` or

+accessed as a C string with ``out.c_str()``.

+\endrst

+*/

+template <typename Char, typename Allocator = std::allocator<Char> >

+class BasicMemoryWriter: public BasicWriter<Char>

+{

+private:

+    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;

+

+public:

+    explicit BasicMemoryWriter(const Allocator& alloc = Allocator())

+        : BasicWriter<Char>(buffer_), buffer_(alloc)

+    {}

+

+#if FMT_USE_RVALUE_REFERENCES

+    /**

+    \rst

+    Constructs a :class:`fmt::BasicMemoryWriter` object moving the content

+    of the other object to it.

+    \endrst

+    */

+    BasicMemoryWriter(BasicMemoryWriter &&other)

+        : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_))

+    {}

+

+    /**

+    \rst

+    Moves the content of the other ``BasicMemoryWriter`` object to this one.

+    \endrst

+    */

+    BasicMemoryWriter &operator=(BasicMemoryWriter &&other)

+    {

+        buffer_ = std::move(other.buffer_);

+        return *this;

+    }

+#endif

+};

+

+typedef BasicMemoryWriter<char> MemoryWriter;

+typedef BasicMemoryWriter<wchar_t> WMemoryWriter;

+

+/**

+\rst

+This class template provides operations for formatting and writing data

+into a fixed-size array. For writing into a dynamically growing buffer

+use :class:`fmt::BasicMemoryWriter`.

+

+Any write method will throw ``std::runtime_error`` if the output doesn't fit

+into the array.

+

+You can use one of the following typedefs for common character types:

+

++--------------+---------------------------+

+| Type         | Definition                |

++==============+===========================+

+| ArrayWriter  | BasicArrayWriter<char>    |

++--------------+---------------------------+

+| WArrayWriter | BasicArrayWriter<wchar_t> |

++--------------+---------------------------+

+\endrst

+*/

+template <typename Char>

+class BasicArrayWriter: public BasicWriter<Char>

+{

+private:

+    internal::FixedBuffer<Char> buffer_;

+

+public:

+    /**

+    \rst

+    Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the

+    given size.

+    \endrst

+    */

+    BasicArrayWriter(Char *array, std::size_t size)

+        : BasicWriter<Char>(buffer_), buffer_(array, size)

+    {}

+

+    /**

+    \rst

+    Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the

+    size known at compile time.

+    \endrst

+    */

+    template <std::size_t SIZE>

+    explicit BasicArrayWriter(Char(&array)[SIZE])

+        : BasicWriter<Char>(buffer_), buffer_(array, SIZE)

+    {}

+};

+

+typedef BasicArrayWriter<char> ArrayWriter;

+typedef BasicArrayWriter<wchar_t> WArrayWriter;

+

+// Formats a value.

+template <typename Char, typename T>

+void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value)

+{

+    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;

+

+    internal::FormatBuf<Char> format_buf(buffer);

+    std::basic_ostream<Char> output(&format_buf);

+    output << value;

+

+    BasicStringRef<Char> str(&buffer[0], format_buf.size());

+    typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;

+    format_str = f.format(format_str, MakeArg(str));

+}

+

+// Reports a system error without throwing an exception.

+// Can be used to report errors from destructors.

+FMT_API void report_system_error(int error_code,

+                                 StringRef message) FMT_NOEXCEPT;

+

+#if FMT_USE_WINDOWS_H

+

+/** A Windows error. */

+class WindowsError: public SystemError

+{

+private:

+    FMT_API void init(int error_code, CStringRef format_str, ArgList args);

+

+public:

+    /**

+    \rst

+    Constructs a :class:`fmt::WindowsError` object with the description

+    of the form

+

+    .. parsed-literal::

+    *<message>*: *<system-message>*

+

+    where *<message>* is the formatted message and *<system-message>* is the

+    system message corresponding to the error code.

+    *error_code* is a Windows error code as given by ``GetLastError``.

+    If *error_code* is not a valid error code such as -1, the system message

+    will look like "error -1".

+

+    **Example**::

+

+    // This throws a WindowsError with the description

+    //   cannot open file 'madeup': The system cannot find the file specified.

+    // or similar (system message may vary).

+    const char *filename = "madeup";

+    LPOFSTRUCT of = LPOFSTRUCT();

+    HFILE file = OpenFile(filename, &of, OF_READ);

+    if (file == HFILE_ERROR) {

+    throw fmt::WindowsError(GetLastError(),

+    "cannot open file '{}'", filename);

+    }

+    \endrst

+    */

+    WindowsError(int error_code, CStringRef message)

+    {

+        init(error_code, message, ArgList());

+    }

+    FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)

+};

+

+// Reports a Windows error without throwing an exception.

+// Can be used to report errors from destructors.

+FMT_API void report_windows_error(int error_code,

+                                  StringRef message) FMT_NOEXCEPT;

+

+#endif

+

+enum Color

+{

+    BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE

+};

+

+/**

+Formats a string and prints it to stdout using ANSI escape sequences

+to specify color (experimental).

+Example:

+print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);

+*/

+FMT_API void print_colored(Color c, CStringRef format, ArgList args);

+

+/**

+\rst

+Formats arguments and returns the result as a string.

+

+**Example**::

+

+std::string message = format("The answer is {}", 42);

+\endrst

+*/

+inline std::string format(CStringRef format_str, ArgList args)

+{

+    MemoryWriter w;

+    w.write(format_str, args);

+    return w.str();

+}

+

+inline std::wstring format(WCStringRef format_str, ArgList args)

+{

+    WMemoryWriter w;

+    w.write(format_str, args);

+    return w.str();

+}

+

+/**

+\rst

+Prints formatted data to the file *f*.

+

+**Example**::

+

+print(stderr, "Don't {}!", "panic");

+\endrst

+*/

+FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args);

+

+/**

+\rst

+Prints formatted data to ``stdout``.

+

+**Example**::

+

+print("Elapsed time: {0:.2f} seconds", 1.23);

+\endrst

+*/

+FMT_API void print(CStringRef format_str, ArgList args);

+

+template <typename Char>

+void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args)

+{

+    internal::PrintfFormatter<Char>(args).format(w, format);

+}

+

+/**

+\rst

+Formats arguments and returns the result as a string.

+

+**Example**::

+

+std::string message = fmt::sprintf("The answer is %d", 42);

+\endrst

+*/

+inline std::string sprintf(CStringRef format, ArgList args)

+{

+    MemoryWriter w;

+    printf(w, format, args);

+    return w.str();

+}

+

+inline std::wstring sprintf(WCStringRef format, ArgList args)

+{

+    WMemoryWriter w;

+    printf(w, format, args);

+    return w.str();

+}

+

+/**

+\rst

+Prints formatted data to the file *f*.

+

+**Example**::

+

+fmt::fprintf(stderr, "Don't %s!", "panic");

+\endrst

+*/

+FMT_API int fprintf(std::FILE *f, CStringRef format, ArgList args);

+

+/**

+\rst

+Prints formatted data to ``stdout``.

+

+**Example**::

+

+fmt::printf("Elapsed time: %.2f seconds", 1.23);

+\endrst

+*/

+inline int printf(CStringRef format, ArgList args)

+{

+    return fprintf(stdout, format, args);

+}

+

+/**

+Fast integer formatter.

+*/

+class FormatInt

+{

+private:

+    // Buffer should be large enough to hold all digits (digits10 + 1),

+    // a sign and a null character.

+    enum

+    {

+        BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3

+    };

+    mutable char buffer_[BUFFER_SIZE];

+    char *str_;

+

+    // Formats value in reverse and returns the number of digits.

+    char *format_decimal(ULongLong value)

+    {

+        char *buffer_end = buffer_ + BUFFER_SIZE - 1;

+        while (value >= 100)

+        {

+            // Integer division is slow so do it for a group of two digits instead

+            // of for every digit. The idea comes from the talk by Alexandrescu

+            // "Three Optimization Tips for C++". See speed-test for a comparison.

+            unsigned index = static_cast<unsigned>((value % 100) * 2);

+            value /= 100;

+            *--buffer_end = internal::Data::DIGITS[index + 1];

+            *--buffer_end = internal::Data::DIGITS[index];

+        }

+        if (value < 10)

+        {

+            *--buffer_end = static_cast<char>('0' + value);

+            return buffer_end;

+        }

+        unsigned index = static_cast<unsigned>(value * 2);

+        *--buffer_end = internal::Data::DIGITS[index + 1];

+        *--buffer_end = internal::Data::DIGITS[index];

+        return buffer_end;

+    }

+

+    void FormatSigned(LongLong value)

+    {

+        ULongLong abs_value = static_cast<ULongLong>(value);

+        bool negative = value < 0;

+        if (negative)

+            abs_value = 0 - abs_value;

+        str_ = format_decimal(abs_value);

+        if (negative)

+            *--str_ = '-';

+    }

+

+public:

+    explicit FormatInt(int value)

+    {

+        FormatSigned(value);

+    }

+    explicit FormatInt(long value)

+    {

+        FormatSigned(value);

+    }

+    explicit FormatInt(LongLong value)

+    {

+        FormatSigned(value);

+    }

+    explicit FormatInt(unsigned value): str_(format_decimal(value))

+    {}

+    explicit FormatInt(unsigned long value): str_(format_decimal(value))

+    {}

+    explicit FormatInt(ULongLong value): str_(format_decimal(value))

+    {}

+

+    /** Returns the number of characters written to the output buffer. */

+    std::size_t size() const

+    {

+        return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);

+    }

+

+    /**

+    Returns a pointer to the output buffer content. No terminating null

+    character is appended.

+    */

+    const char *data() const

+    {

+        return str_;

+    }

+

+    /**

+    Returns a pointer to the output buffer content with terminating null

+    character appended.

+    */

+    const char *c_str() const

+    {

+        buffer_[BUFFER_SIZE - 1] = '\0';

+        return str_;

+    }

+

+    /**

+    \rst

+    Returns the content of the output buffer as an ``std::string``.

+    \endrst

+    */

+    std::string str() const

+    {

+        return std::string(str_, size());

+    }

+};

+

+// Formats a decimal integer value writing into buffer and returns

+// a pointer to the end of the formatted string. This function doesn't

+// write a terminating null character.

+template <typename T>

+inline void format_decimal(char *&buffer, T value)

+{

+    typedef typename internal::IntTraits<T>::MainType MainType;

+    MainType abs_value = static_cast<MainType>(value);

+    if (internal::is_negative(value))

+    {

+        *buffer++ = '-';

+        abs_value = 0 - abs_value;

+    }

+    if (abs_value < 100)

+    {

+        if (abs_value < 10)

+        {

+            *buffer++ = static_cast<char>('0' + abs_value);

+            return;

+        }

+        unsigned index = static_cast<unsigned>(abs_value * 2);

+        *buffer++ = internal::Data::DIGITS[index];

+        *buffer++ = internal::Data::DIGITS[index + 1];

+        return;

+    }

+    unsigned num_digits = internal::count_digits(abs_value);

+    internal::format_decimal(buffer, abs_value, num_digits);

+    buffer += num_digits;

+}

+

+/**

+\rst

+Returns a named argument for formatting functions.

+

+**Example**::

+

+print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));

+

+\endrst

+*/

+template <typename T>

+inline internal::NamedArg<char> arg(StringRef name, const T &arg)

+{

+    return internal::NamedArg<char>(name, arg);

+}

+

+template <typename T>

+inline internal::NamedArg<wchar_t> arg(WStringRef name, const T &arg)

+{

+    return internal::NamedArg<wchar_t>(name, arg);

+}

+

+// The following two functions are deleted intentionally to disable

+// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``.

+template <typename Char>

+void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;

+template <typename Char>

+void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;

+}

+

+#if FMT_GCC_VERSION

+// Use the system_header pragma to suppress warnings about variadic macros

+// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't

+// work. It is used at the end because we want to suppress as little warnings

+// as possible.

+# pragma GCC system_header

+#endif

+

+// This is used to work around VC++ bugs in handling variadic macros.

+#define FMT_EXPAND(args) args

+

+// Returns the number of arguments.

+// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s.

+#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())

+#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))

+#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N

+#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

+

+#define FMT_CONCAT(a, b) a##b

+#define FMT_FOR_EACH_(N, f, ...) \

+  FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))

+#define FMT_FOR_EACH(f, ...) \

+  FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))

+

+#define FMT_ADD_ARG_NAME(type, index) type arg##index

+#define FMT_GET_ARG_NAME(type, index) arg##index

+

+#if FMT_USE_VARIADIC_TEMPLATES

+# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \

+  template <typename... Args> \

+  ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \

+      const Args & ... args) { \

+    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \

+    typename ArgArray::Type array{ \

+      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \

+    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \

+      fmt::ArgList(fmt::internal::make_type(args...), array)); \

+  }

+#else

+// Defines a wrapper for a function taking __VA_ARGS__ arguments

+// and n additional arguments of arbitrary types.

+# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \

+  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \

+  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \

+      FMT_GEN(n, FMT_MAKE_ARG)) { \

+    fmt::internal::ArgArray<n>::Type arr; \

+    FMT_GEN(n, FMT_ASSIGN_##Char); \

+    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \

+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \

+  }

+

+# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \

+  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \

+    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \

+  } \

+  FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \

+  FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)

+#endif  // FMT_USE_VARIADIC_TEMPLATES

+

+/**

+\rst

+Defines a variadic function with the specified return type, function name

+and argument types passed as variable arguments to this macro.

+

+**Example**::

+

+void print_error(const char *file, int line, const char *format,

+fmt::ArgList args) {

+fmt::print("{}: {}: ", file, line);

+fmt::print(format, args);

+}

+FMT_VARIADIC(void, print_error, const char *, int, const char *)

+

+``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that

+don't implement variadic templates. You don't have to use this macro if

+you don't need legacy compiler support and can use variadic templates

+directly::

+

+template <typename... Args>

+void print_error(const char *file, int line, const char *format,

+const Args & ... args) {

+fmt::print("{}: {}: ", file, line);

+fmt::print(format, args...);

+}

+\endrst

+*/

+#define FMT_VARIADIC(ReturnType, func, ...) \

+  FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)

+

+#define FMT_VARIADIC_W(ReturnType, func, ...) \

+  FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)

+

+#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)

+

+#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)

+

+/**

+\rst

+Convenient macro to capture the arguments' names and values into several

+``fmt::arg(name, value)``.

+

+**Example**::

+

+int x = 1, y = 2;

+print("point: ({x}, {y})", FMT_CAPTURE(x, y));

+// same as:

+// print("point: ({x}, {y})", arg("x", x), arg("y", y));

+

+\endrst

+*/

+#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)

+

+#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)

+

+namespace fmt

+{

+FMT_VARIADIC(std::string, format, CStringRef)

+FMT_VARIADIC_W(std::wstring, format, WCStringRef)

+FMT_VARIADIC(void, print, CStringRef)

+FMT_VARIADIC(void, print, std::FILE *, CStringRef)

+

+FMT_VARIADIC(void, print_colored, Color, CStringRef)

+FMT_VARIADIC(std::string, sprintf, CStringRef)

+FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)

+FMT_VARIADIC(int, printf, CStringRef)

+FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)

+

+#if FMT_USE_IOSTREAMS

+/**

+\rst

+Prints formatted data to the stream *os*.

+

+**Example**::

+

+print(cerr, "Don't {}!", "panic");

+\endrst

+*/

+FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);

+FMT_VARIADIC(void, print, std::ostream &, CStringRef)

+

+/**

+\rst

+Prints formatted data to the stream *os*.

+

+**Example**::

+

+fprintf(cerr, "Don't %s!", "panic");

+\endrst

+*/

+FMT_API int fprintf(std::ostream &os, CStringRef format_str, ArgList args);

+FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)

+#endif

+

+namespace internal

+{

+template <typename Char>

+inline bool is_name_start(Char c)

+{

+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;

+}

+

+// Parses an unsigned integer advancing s to the end of the parsed input.

+// This function assumes that the first character of s is a digit.

+template <typename Char>

+unsigned parse_nonnegative_int(const Char *&s)

+{

+    assert('0' <= *s && *s <= '9');

+    unsigned value = 0;

+    do

+    {

+        unsigned new_value = value * 10 + (*s++ - '0');

+        // Check if value wrapped around.

+        if (new_value < value)

+        {

+            value = (std::numeric_limits<unsigned>::max)();

+            break;

+        }

+        value = new_value;

+    }

+    while ('0' <= *s && *s <= '9');

+    // Convert to unsigned to prevent a warning.

+    unsigned max_int = (std::numeric_limits<int>::max)();

+    if (value > max_int)

+        FMT_THROW(FormatError("number is too big"));

+    return value;

+}

+

+inline void require_numeric_argument(const Arg &arg, char spec)

+{

+    if (arg.type > Arg::LAST_NUMERIC_TYPE)

+    {

+        std::string message =

+            fmt::format("format specifier '{}' requires numeric argument", spec);

+        FMT_THROW(fmt::FormatError(message));

+    }

+}

+

+template <typename Char>

+void check_sign(const Char *&s, const Arg &arg)

+{

+    char sign = static_cast<char>(*s);

+    require_numeric_argument(arg, sign);

+    if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG)

+    {

+        FMT_THROW(FormatError(fmt::format(

+                                  "format specifier '{}' requires signed argument", sign)));

+    }

+    ++s;

+}

+}  // namespace internal

+

+template <typename Char, typename AF>

+inline internal::Arg BasicFormatter<Char, AF>::get_arg(

+    BasicStringRef<Char> arg_name, const char *&error)

+{

+    if (check_no_auto_index(error))

+    {

+        map_.init(args());

+        const internal::Arg *arg = map_.find(arg_name);

+        if (arg)

+            return *arg;

+        error = "argument not found";

+    }

+    return internal::Arg();

+}

+

+template <typename Char, typename AF>

+inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s)

+{

+    const char *error = 0;

+    internal::Arg arg = *s < '0' || *s > '9' ?

+                        next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);

+    if (error)

+    {

+        FMT_THROW(FormatError(

+                      *s != '}' && *s != ':' ? "invalid format string" : error));

+    }

+    return arg;

+}

+

+template <typename Char, typename AF>

+inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s)

+{

+    assert(internal::is_name_start(*s));

+    const Char *start = s;

+    Char c;

+    do

+    {

+        c = *++s;

+    }

+    while (internal::is_name_start(c) || ('0' <= c && c <= '9'));

+    const char *error = 0;

+    internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);

+    if (error)

+        FMT_THROW(FormatError(error));

+    return arg;

+}

+

+template <typename Char, typename ArgFormatter>

+const Char *BasicFormatter<Char, ArgFormatter>::format(

+    const Char *&format_str, const internal::Arg &arg)

+{

+    using internal::Arg;

+    const Char *s = format_str;

+    FormatSpec spec;

+    if (*s == ':')

+    {

+        if (arg.type == Arg::CUSTOM)

+        {

+            arg.custom.format(this, arg.custom.value, &s);

+            return s;

+        }

+        ++s;

+        // Parse fill and alignment.

+        if (Char c = *s)

+        {

+            const Char *p = s + 1;

+            spec.align_ = ALIGN_DEFAULT;

+            do

+            {

+                switch (*p)

+                {

+                case '<':

+                    spec.align_ = ALIGN_LEFT;

+                    break;

+                case '>':

+                    spec.align_ = ALIGN_RIGHT;

+                    break;

+                case '=':

+                    spec.align_ = ALIGN_NUMERIC;

+                    break;

+                case '^':

+                    spec.align_ = ALIGN_CENTER;

+                    break;

+                }

+                if (spec.align_ != ALIGN_DEFAULT)

+                {

+                    if (p != s)

+                    {

+                        if (c == '}') break;

+                        if (c == '{')

+                            FMT_THROW(FormatError("invalid fill character '{'"));

+                        s += 2;

+                        spec.fill_ = c;

+                    }

+                    else ++s;

+                    if (spec.align_ == ALIGN_NUMERIC)

+                        require_numeric_argument(arg, '=');

+                    break;

+                }

+            }

+            while (--p >= s);

+        }

+

+        // Parse sign.

+        switch (*s)

+        {

+        case '+':

+            check_sign(s, arg);

+            spec.flags_ |= SIGN_FLAG | PLUS_FLAG;

+            break;

+        case '-':

+            check_sign(s, arg);

+            spec.flags_ |= MINUS_FLAG;

+            break;

+        case ' ':

+            check_sign(s, arg);

+            spec.flags_ |= SIGN_FLAG;

+            break;

+        }

+

+        if (*s == '#')

+        {

+            require_numeric_argument(arg, '#');

+            spec.flags_ |= HASH_FLAG;

+            ++s;

+        }

+

+        // Parse zero flag.

+        if (*s == '0')

+        {

+            require_numeric_argument(arg, '0');

+            spec.align_ = ALIGN_NUMERIC;

+            spec.fill_ = '0';

+            ++s;

+        }

+

+        // Parse width.

+        if ('0' <= *s && *s <= '9')

+        {

+            spec.width_ = internal::parse_nonnegative_int(s);

+        }

+        else if (*s == '{')

+        {

+            ++s;

+            Arg width_arg = internal::is_name_start(*s) ?

+                            parse_arg_name(s) : parse_arg_index(s);

+            if (*s++ != '}')

+                FMT_THROW(FormatError("invalid format string"));

+            ULongLong value = 0;

+            switch (width_arg.type)

+            {

+            case Arg::INT:

+                if (width_arg.int_value < 0)

+                    FMT_THROW(FormatError("negative width"));

+                value = width_arg.int_value;

+                break;

+            case Arg::UINT:

+                value = width_arg.uint_value;

+                break;

+            case Arg::LONG_LONG:

+                if (width_arg.long_long_value < 0)

+                    FMT_THROW(FormatError("negative width"));

+                value = width_arg.long_long_value;

+                break;

+            case Arg::ULONG_LONG:

+                value = width_arg.ulong_long_value;

+                break;

+            default:

+                FMT_THROW(FormatError("width is not integer"));

+            }

+            if (value >(std::numeric_limits<int>::max)())

+                FMT_THROW(FormatError("number is too big"));

+            spec.width_ = static_cast<int>(value);

+        }

+

+        // Parse precision.

+        if (*s == '.')

+        {

+            ++s;

+            spec.precision_ = 0;

+            if ('0' <= *s && *s <= '9')

+            {

+                spec.precision_ = internal::parse_nonnegative_int(s);

+            }

+            else if (*s == '{')

+            {

+                ++s;

+                Arg precision_arg = internal::is_name_start(*s) ?

+                                    parse_arg_name(s) : parse_arg_index(s);

+                if (*s++ != '}')

+                    FMT_THROW(FormatError("invalid format string"));

+                ULongLong value = 0;

+                switch (precision_arg.type)

+                {

+                case Arg::INT:

+                    if (precision_arg.int_value < 0)

+                        FMT_THROW(FormatError("negative precision"));

+                    value = precision_arg.int_value;

+                    break;

+                case Arg::UINT:

+                    value = precision_arg.uint_value;

+                    break;

+                case Arg::LONG_LONG:

+                    if (precision_arg.long_long_value < 0)

+                        FMT_THROW(FormatError("negative precision"));

+                    value = precision_arg.long_long_value;

+                    break;

+                case Arg::ULONG_LONG:

+                    value = precision_arg.ulong_long_value;

+                    break;

+                default:

+                    FMT_THROW(FormatError("precision is not integer"));

+                }

+                if (value >(std::numeric_limits<int>::max)())

+                    FMT_THROW(FormatError("number is too big"));

+                spec.precision_ = static_cast<int>(value);

+            }

+            else

+            {

+                FMT_THROW(FormatError("missing precision specifier"));

+            }

+            if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER)

+            {

+                FMT_THROW(FormatError(

+                              fmt::format("precision not allowed in {} format specifier",

+                                          arg.type == Arg::POINTER ? "pointer" : "integer")));

+            }

+        }

+

+        // Parse type.

+        if (*s != '}' && *s)

+            spec.type_ = static_cast<char>(*s++);

+    }

+

+    if (*s++ != '}')

+        FMT_THROW(FormatError("missing '}' in format string"));

+

+    // Format argument.

+    ArgFormatter(*this, spec, s - 1).visit(arg);

+    return s;

+}

+

+template <typename Char, typename AF>

+void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str)

+{

+    const Char *s = format_str.c_str();

+    const Char *start = s;

+    while (*s)

+    {

+        Char c = *s++;

+        if (c != '{' && c != '}') continue;

+        if (*s == c)

+        {

+            write(writer_, start, s);

+            start = ++s;

+            continue;

+        }

+        if (c == '}')

+            FMT_THROW(FormatError("unmatched '}' in format string"));

+        write(writer_, start, s - 1);

+        internal::Arg arg = internal::is_name_start(*s) ?

+                            parse_arg_name(s) : parse_arg_index(s);

+        start = s = format(s, arg);

+    }

+    write(writer_, start, s);

+}

+}  // namespace fmt

+

+#if FMT_USE_USER_DEFINED_LITERALS

+namespace fmt

+{

+namespace internal

+{

+

+template <typename Char>

+struct UdlFormat

+{

+    const Char *str;

+

+    template <typename... Args>

+    auto operator()(Args && ... args) const

+    -> decltype(format(str, std::forward<Args>(args)...))

+    {

+        return format(str, std::forward<Args>(args)...);

+    }

+};

+

+template <typename Char>

+struct UdlArg

+{

+    const Char *str;

+

+    template <typename T>

+    NamedArg<Char> operator=(T &&value) const

+    {

+        return { str, std::forward<T>(value) };

+    }

+};

+

+} // namespace internal

+

+inline namespace literals

+{

+

+/**

+\rst

+C++11 literal equivalent of :func:`fmt::format`.

+

+**Example**::

+

+using namespace fmt::literals;

+std::string message = "The answer is {}"_format(42);

+\endrst

+*/

+inline internal::UdlFormat<char>

+operator"" _format(const char *s, std::size_t)

+{

+    return { s };

+}

+inline internal::UdlFormat<wchar_t>

+operator"" _format(const wchar_t *s, std::size_t)

+{

+    return { s };

+}

+

+/**

+\rst

+C++11 literal equivalent of :func:`fmt::arg`.

+

+**Example**::

+

+using namespace fmt::literals;

+print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);

+\endrst

+*/

+inline internal::UdlArg<char>

+operator"" _a(const char *s, std::size_t)

+{

+    return { s };

+}

+inline internal::UdlArg<wchar_t>

+operator"" _a(const wchar_t *s, std::size_t)

+{

+    return { s };

+}

+

+} // inline namespace literals

+} // namespace fmt

+#endif // FMT_USE_USER_DEFINED_LITERALS

+

+// Restore warnings.

+#if FMT_GCC_VERSION >= 406

+# pragma GCC diagnostic pop

+#endif

+

+#if defined(__clang__) && !defined(__INTEL_COMPILER)

+# pragma clang diagnostic pop

+#endif

+

+#ifdef FMT_HEADER_ONLY

+# include "format.cc"

+#endif

+

+#endif  // FMT_FORMAT_H_

+

diff --git a/include/spdlog/details/line_logger_fwd.h b/include/spdlog/details/line_logger_fwd.h
index a8bc58ff..212fa193 100644
--- a/include/spdlog/details/line_logger_fwd.h
+++ b/include/spdlog/details/line_logger_fwd.h
@@ -1,78 +1,78 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-#pragma once
-
-#include <spdlog/common.h>
-#include <spdlog/details/log_msg.h>
-
-#include <string>
-
-// Line logger class - aggregates operator<< calls to fast ostream
-// and logs upon destruction
-
-namespace spdlog
-{
-
-// Forward declaration
-class logger;
-
-namespace details
-{
-class line_logger
-{
-public:
-    line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled);
-
-    // No copy intended. Only move
-    line_logger(const line_logger& other) = delete;
-    line_logger& operator=(const line_logger&) = delete;
-    line_logger& operator=(line_logger&&) = delete;
-
-
-    line_logger(line_logger&& other);
-
-    //Log the log message using the callback logger
-    ~line_logger();
-
-    //
-    // Support for format string with variadic args
-    //
-
-
-    void write(const char* what);
-
-    template <typename... Args>
-    void write(const char* fmt, const Args&... args);
-
-    //
-    // Support for operator<<
-    //
-    line_logger& operator<<(const char* what);
-    line_logger& operator<<(const std::string& what);
-    line_logger& operator<<(int what);
-    line_logger& operator<<(unsigned int what);
-    line_logger& operator<<(long what);
-    line_logger& operator<<(unsigned long what);
-    line_logger& operator<<(long long what);
-    line_logger& operator<<(unsigned long long what);
-    line_logger& operator<<(double what);
-    line_logger& operator<<(long double what);
-    line_logger& operator<<(float what);
-    line_logger& operator<<(char what);
-    //Support user types which implements operator<<
-    template<typename T>
-    line_logger& operator<<(const T& what);
-
-    void disable();
-    bool is_enabled() const;
-
-private:
-    logger* _callback_logger;
-    log_msg _log_msg;
-    bool _enabled;
-};
-} //Namespace details
-} // Namespace spdlog
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+#pragma once

+

+#include <spdlog/common.h>

+#include <spdlog/details/log_msg.h>

+

+#include <string>

+

+// Line logger class - aggregates operator<< calls to fast ostream

+// and logs upon destruction

+

+namespace spdlog

+{

+

+// Forward declaration

+class logger;

+

+namespace details

+{

+class line_logger

+{

+public:

+    line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled);

+

+    // No copy intended. Only move

+    line_logger(const line_logger& other) = delete;

+    line_logger& operator=(const line_logger&) = delete;

+    line_logger& operator=(line_logger&&) = delete;

+

+

+    line_logger(line_logger&& other);

+

+    //Log the log message using the callback logger

+    ~line_logger();

+

+    //

+    // Support for format string with variadic args

+    //

+

+

+    void write(const char* what);

+

+    template <typename... Args>

+    void write(const char* fmt, const Args&... args);

+

+    //

+    // Support for operator<<

+    //

+    line_logger& operator<<(const char* what);

+    line_logger& operator<<(const std::string& what);

+    line_logger& operator<<(int what);

+    line_logger& operator<<(unsigned int what);

+    line_logger& operator<<(long what);

+    line_logger& operator<<(unsigned long what);

+    line_logger& operator<<(long long what);

+    line_logger& operator<<(unsigned long long what);

+    line_logger& operator<<(double what);

+    line_logger& operator<<(long double what);

+    line_logger& operator<<(float what);

+    line_logger& operator<<(char what);

+    //Support user types which implements operator<<

+    template<typename T>

+    line_logger& operator<<(const T& what);

+

+    void disable();

+    bool is_enabled() const;

+

+private:

+    logger* _callback_logger;

+    log_msg _log_msg;

+    bool _enabled;

+};

+} //Namespace details

+} // Namespace spdlog

+

diff --git a/include/spdlog/details/line_logger_impl.h b/include/spdlog/details/line_logger_impl.h
index d61225af..f69e0b0d 100644
--- a/include/spdlog/details/line_logger_impl.h
+++ b/include/spdlog/details/line_logger_impl.h
@@ -1,185 +1,185 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-#pragma once
-#include <type_traits>
-
-#include <spdlog/details/line_logger_fwd.h>
-#include <spdlog/common.h>
-#include <spdlog/logger.h>
-
-#include <string>
-#include <utility>
-
-// Line logger class - aggregates operator<< calls to fast ostream
-// and logs upon destruction
-
-inline spdlog::details::line_logger::line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled):
-    _callback_logger(callback_logger),
-    _log_msg(msg_level),
-    _enabled(enabled)
-{}
-
-inline spdlog::details::line_logger::line_logger(line_logger&& other) :
-    _callback_logger(other._callback_logger),
-    _log_msg(std::move(other._log_msg)),
-    _enabled(other._enabled)
-{
-    other.disable();
-}
-
-//Log the log message using the callback logger
-inline spdlog::details::line_logger::~line_logger()
-{
-    if (_enabled)
-    {
-#ifndef SPDLOG_NO_NAME
-        _log_msg.logger_name = _callback_logger->name();
-#endif
-#ifndef SPDLOG_NO_DATETIME
-        _log_msg.time = os::now();
-#endif
-
-#ifndef SPDLOG_NO_THREAD_ID
-        _log_msg.thread_id = os::thread_id();
-#endif
-        _callback_logger->_log_msg(_log_msg);
-    }
-}
-
-//
-// Support for format string with variadic args
-//
-
-
-inline void spdlog::details::line_logger::write(const char* what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-}
-
-template <typename... Args>
-inline void spdlog::details::line_logger::write(const char* fmt, const Args&... args)
-{
-    if (!_enabled)
-        return;
-    try
-    {
-        _log_msg.raw.write(fmt, args...);
-    }
-    catch (const fmt::FormatError& e)
-    {
-        throw spdlog_ex(fmt::format("formatting error while processing format string '{}': {}", fmt, e.what()));
-    }
-}
-
-
-//
-// Support for operator<<
-//
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const char* what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const std::string& what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(int what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned int what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned long what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long long what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned long long what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(double what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long double what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(float what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(char what)
-{
-    if (_enabled)
-        _log_msg.raw << what;
-    return *this;
-}
-
-//Support user types which implements operator<<
-template<typename T>
-inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const T& what)
-{
-    if (_enabled)
-        _log_msg.raw.write("{}", what);
-    return *this;
-}
-
-
-inline void spdlog::details::line_logger::disable()
-{
-    _enabled = false;
-}
-
-inline bool spdlog::details::line_logger::is_enabled() const
-{
-    return _enabled;
-}
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+#pragma once

+#include <type_traits>

+

+#include <spdlog/details/line_logger_fwd.h>

+#include <spdlog/common.h>

+#include <spdlog/logger.h>

+

+#include <string>

+#include <utility>

+

+// Line logger class - aggregates operator<< calls to fast ostream

+// and logs upon destruction

+

+inline spdlog::details::line_logger::line_logger(logger* callback_logger, level::level_enum msg_level, bool enabled):

+    _callback_logger(callback_logger),

+    _log_msg(msg_level),

+    _enabled(enabled)

+{}

+

+inline spdlog::details::line_logger::line_logger(line_logger&& other) :

+    _callback_logger(other._callback_logger),

+    _log_msg(std::move(other._log_msg)),

+    _enabled(other._enabled)

+{

+    other.disable();

+}

+

+//Log the log message using the callback logger

+inline spdlog::details::line_logger::~line_logger()

+{

+    if (_enabled)

+    {

+#ifndef SPDLOG_NO_NAME

+        _log_msg.logger_name = _callback_logger->name();

+#endif

+#ifndef SPDLOG_NO_DATETIME

+        _log_msg.time = os::now();

+#endif

+

+#ifndef SPDLOG_NO_THREAD_ID

+        _log_msg.thread_id = os::thread_id();

+#endif

+        _callback_logger->_log_msg(_log_msg);

+    }

+}

+

+//

+// Support for format string with variadic args

+//

+

+

+inline void spdlog::details::line_logger::write(const char* what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+}

+

+template <typename... Args>

+inline void spdlog::details::line_logger::write(const char* fmt, const Args&... args)

+{

+    if (!_enabled)

+        return;

+    try

+    {

+        _log_msg.raw.write(fmt, args...);

+    }

+    catch (const fmt::FormatError& e)

+    {

+        throw spdlog_ex(fmt::format("formatting error while processing format string '{}': {}", fmt, e.what()));

+    }

+}

+

+

+//

+// Support for operator<<

+//

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const char* what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const std::string& what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(int what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned int what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned long what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long long what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(unsigned long long what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(double what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(long double what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(float what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(char what)

+{

+    if (_enabled)

+        _log_msg.raw << what;

+    return *this;

+}

+

+//Support user types which implements operator<<

+template<typename T>

+inline spdlog::details::line_logger& spdlog::details::line_logger::operator<<(const T& what)

+{

+    if (_enabled)

+        _log_msg.raw.write("{}", what);

+    return *this;

+}

+

+

+inline void spdlog::details::line_logger::disable()

+{

+    _enabled = false;

+}

+

+inline bool spdlog::details::line_logger::is_enabled() const

+{

+    return _enabled;

+}

+

diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h
index 0d50b684..9fe6c2fe 100644
--- a/include/spdlog/details/log_msg.h
+++ b/include/spdlog/details/log_msg.h
@@ -1,81 +1,81 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/common.h>
-#include <spdlog/details/format.h>
-
-#include <string>
-#include <utility>
-
-namespace spdlog
-{
-namespace details
-{
-struct log_msg
-{
-    log_msg() = default;
-    log_msg(level::level_enum l):
-        logger_name(),
-        level(l),
-        raw(),
-        formatted() {}
-
-
-    log_msg(const log_msg& other) :
-        logger_name(other.logger_name),
-        level(other.level),
-        time(other.time),
-        thread_id(other.thread_id)
-    {
-        if (other.raw.size())
-            raw << fmt::BasicStringRef<char>(other.raw.data(), other.raw.size());
-        if (other.formatted.size())
-            formatted << fmt::BasicStringRef<char>(other.formatted.data(), other.formatted.size());
-    }
-
-    log_msg(log_msg&& other) :
-        logger_name(std::move(other.logger_name)),
-        level(other.level),
-        time(std::move(other.time)),
-        thread_id(other.thread_id),
-        raw(std::move(other.raw)),
-        formatted(std::move(other.formatted))
-    {
-        other.clear();
-    }
-
-    log_msg& operator=(log_msg&& other)
-    {
-        if (this == &other)
-            return *this;
-
-        logger_name = std::move(other.logger_name);
-        level = other.level;
-        time = std::move(other.time);
-        thread_id = other.thread_id;
-        raw = std::move(other.raw);
-        formatted = std::move(other.formatted);
-        other.clear();
-        return *this;
-    }
-
-    void clear()
-    {
-        level = level::off;
-        raw.clear();
-        formatted.clear();
-    }
-
-    std::string logger_name;
-    level::level_enum level;
-    log_clock::time_point time;
-    size_t thread_id;
-    fmt::MemoryWriter raw;
-    fmt::MemoryWriter formatted;
-};
-}
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/common.h>

+#include <spdlog/details/format.h>

+

+#include <string>

+#include <utility>

+

+namespace spdlog

+{

+namespace details

+{

+struct log_msg

+{

+    log_msg() = default;

+    log_msg(level::level_enum l):

+        logger_name(),

+        level(l),

+        raw(),

+        formatted() {}

+

+

+    log_msg(const log_msg& other) :

+        logger_name(other.logger_name),

+        level(other.level),

+        time(other.time),

+        thread_id(other.thread_id)

+    {

+        if (other.raw.size())

+            raw << fmt::BasicStringRef<char>(other.raw.data(), other.raw.size());

+        if (other.formatted.size())

+            formatted << fmt::BasicStringRef<char>(other.formatted.data(), other.formatted.size());

+    }

+

+    log_msg(log_msg&& other) :

+        logger_name(std::move(other.logger_name)),

+        level(other.level),

+        time(std::move(other.time)),

+        thread_id(other.thread_id),

+        raw(std::move(other.raw)),

+        formatted(std::move(other.formatted))

+    {

+        other.clear();

+    }

+

+    log_msg& operator=(log_msg&& other)

+    {

+        if (this == &other)

+            return *this;

+

+        logger_name = std::move(other.logger_name);

+        level = other.level;

+        time = std::move(other.time);

+        thread_id = other.thread_id;

+        raw = std::move(other.raw);

+        formatted = std::move(other.formatted);

+        other.clear();

+        return *this;

+    }

+

+    void clear()

+    {

+        level = level::off;

+        raw.clear();

+        formatted.clear();

+    }

+

+    std::string logger_name;

+    level::level_enum level;

+    log_clock::time_point time;

+    size_t thread_id;

+    fmt::MemoryWriter raw;

+    fmt::MemoryWriter formatted;

+};

+}

+}

diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h
index c0963828..e3c6611c 100644
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
@@ -1,303 +1,303 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/logger.h>
-
-#include <atomic>
-#include <memory>
-#include <string>
-
-// create logger with given name, sinks and the default pattern formatter
-// all other ctors will call this one
-template<class It>
-inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end) :
-    _name(logger_name),
-    _sinks(begin, end),
-    _formatter(std::make_shared<pattern_formatter>("%+"))
-{
-
-    // no support under vs2013 for member initialization for std::atomic
-    _level = level::info;
-}
-
-// ctor with sinks as init list
-inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list) :
-    logger(logger_name, sinks_list.begin(), sinks_list.end()) {}
-
-
-// ctor with single sink
-inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink) :
-    logger(logger_name,
-{
-    single_sink
-}) {}
-
-
-inline spdlog::logger::~logger() = default;
-
-
-inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
-{
-    _set_formatter(msg_formatter);
-}
-
-inline void spdlog::logger::set_pattern(const std::string& pattern)
-{
-    _set_pattern(pattern);
-}
-
-//
-// log only if given level>=logger's log level
-//
-
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::_log_if_enabled(level::level_enum lvl, const char* fmt, const Args&... args)
-{
-    bool msg_enabled = should_log(lvl);
-    details::line_logger l(this, lvl, msg_enabled);
-    l.write(fmt, args...);
-    return l;
-}
-
-inline spdlog::details::line_logger spdlog::logger::_log_if_enabled(level::level_enum lvl)
-{
-    return details::line_logger(this, lvl, should_log(lvl));
-}
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::_log_if_enabled(level::level_enum lvl, const T& msg)
-{
-    bool msg_enabled = should_log(lvl);
-    details::line_logger l(this, lvl, msg_enabled);
-    l << msg;
-    return l;
-}
-
-//
-// logger.info(cppformat_string, arg1, arg2, arg3, ...) call style
-//
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::trace(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::trace, fmt, args...);
-}
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::debug(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::debug, fmt, args...);
-}
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::info(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::info, fmt, args...);
-}
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::notice(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::notice, fmt, args...);
-}
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::warn(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::warn, fmt, args...);
-}
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::error(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::err, fmt, args...);
-}
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::critical(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::critical, fmt, args...);
-}
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::alert(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::alert, fmt, args...);
-}
-
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::emerg(const char* fmt, const Args&... args)
-{
-    return _log_if_enabled(level::emerg, fmt, args...);
-}
-
-//
-// logger.info(msg) << ".." call style
-//
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::trace(const T& msg)
-{
-    return _log_if_enabled(level::trace, msg);
-}
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::debug(const T& msg)
-{
-    return _log_if_enabled(level::debug, msg);
-}
-
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::info(const T& msg)
-{
-    return _log_if_enabled(level::info, msg);
-}
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::notice(const T& msg)
-{
-    return _log_if_enabled(level::notice, msg);
-}
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::warn(const T& msg)
-{
-    return _log_if_enabled(level::warn, msg);
-}
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::error(const T& msg)
-{
-    return _log_if_enabled(level::err, msg);
-}
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::critical(const T& msg)
-{
-    return _log_if_enabled(level::critical, msg);
-}
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::alert(const T& msg)
-{
-    return _log_if_enabled(level::alert, msg);
-}
-
-template<typename T>
-inline spdlog::details::line_logger spdlog::logger::emerg(const T& msg)
-{
-    return _log_if_enabled(level::emerg, msg);
-}
-
-
-
-
-//
-// logger.info() << ".." call  style
-//
-inline spdlog::details::line_logger spdlog::logger::trace()
-{
-    return _log_if_enabled(level::trace);
-}
-
-inline spdlog::details::line_logger spdlog::logger::debug()
-{
-    return _log_if_enabled(level::debug);
-}
-
-inline spdlog::details::line_logger spdlog::logger::info()
-{
-    return _log_if_enabled(level::info);
-}
-
-inline spdlog::details::line_logger spdlog::logger::notice()
-{
-    return _log_if_enabled(level::notice);
-}
-
-inline spdlog::details::line_logger spdlog::logger::warn()
-{
-    return _log_if_enabled(level::warn);
-}
-
-inline spdlog::details::line_logger spdlog::logger::error()
-{
-    return _log_if_enabled(level::err);
-}
-
-inline spdlog::details::line_logger spdlog::logger::critical()
-{
-    return _log_if_enabled(level::critical);
-}
-
-inline spdlog::details::line_logger spdlog::logger::alert()
-{
-    return _log_if_enabled(level::alert);
-}
-
-inline spdlog::details::line_logger spdlog::logger::emerg()
-{
-    return _log_if_enabled(level::emerg);
-}
-
-
-// always log, no matter what is the actual logger's log level
-template <typename... Args>
-inline spdlog::details::line_logger spdlog::logger::force_log(level::level_enum lvl, const char* fmt, const Args&... args)
-{
-    details::line_logger l(this, lvl, true);
-    l.write(fmt, args...);
-    return l;
-}
-
-//
-// name and level
-//
-inline const std::string& spdlog::logger::name() const
-{
-    return _name;
-}
-
-inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
-{
-    _level.store(log_level);
-}
-
-inline spdlog::level::level_enum spdlog::logger::level() const
-{
-    return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
-}
-
-inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
-{
-    return msg_level >= _level.load(std::memory_order_relaxed);
-}
-
-//
-// protected virtual called at end of each user log call (if enabled) by the line_logger
-//
-inline void spdlog::logger::_log_msg(details::log_msg& msg)
-{
-    _formatter->format(msg);
-    for (auto &sink : _sinks)
-        sink->log(msg);
-}
-
-inline void spdlog::logger::_set_pattern(const std::string& pattern)
-{
-    _formatter = std::make_shared<pattern_formatter>(pattern);
-}
-inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
-{
-    _formatter = msg_formatter;
-}
-
-inline void spdlog::logger::flush()
-{
-    for (auto& sink : _sinks)
-        sink->flush();
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/logger.h>

+

+#include <atomic>

+#include <memory>

+#include <string>

+

+// create logger with given name, sinks and the default pattern formatter

+// all other ctors will call this one

+template<class It>

+inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end) :

+    _name(logger_name),

+    _sinks(begin, end),

+    _formatter(std::make_shared<pattern_formatter>("%+"))

+{

+

+    // no support under vs2013 for member initialization for std::atomic

+    _level = level::info;

+}

+

+// ctor with sinks as init list

+inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list) :

+    logger(logger_name, sinks_list.begin(), sinks_list.end()) {}

+

+

+// ctor with single sink

+inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink) :

+    logger(logger_name,

+{

+    single_sink

+}) {}

+

+

+inline spdlog::logger::~logger() = default;

+

+

+inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)

+{

+    _set_formatter(msg_formatter);

+}

+

+inline void spdlog::logger::set_pattern(const std::string& pattern)

+{

+    _set_pattern(pattern);

+}

+

+//

+// log only if given level>=logger's log level

+//

+

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::_log_if_enabled(level::level_enum lvl, const char* fmt, const Args&... args)

+{

+    bool msg_enabled = should_log(lvl);

+    details::line_logger l(this, lvl, msg_enabled);

+    l.write(fmt, args...);

+    return l;

+}

+

+inline spdlog::details::line_logger spdlog::logger::_log_if_enabled(level::level_enum lvl)

+{

+    return details::line_logger(this, lvl, should_log(lvl));

+}

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::_log_if_enabled(level::level_enum lvl, const T& msg)

+{

+    bool msg_enabled = should_log(lvl);

+    details::line_logger l(this, lvl, msg_enabled);

+    l << msg;

+    return l;

+}

+

+//

+// logger.info(cppformat_string, arg1, arg2, arg3, ...) call style

+//

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::trace(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::trace, fmt, args...);

+}

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::debug(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::debug, fmt, args...);

+}

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::info(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::info, fmt, args...);

+}

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::notice(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::notice, fmt, args...);

+}

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::warn(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::warn, fmt, args...);

+}

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::error(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::err, fmt, args...);

+}

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::critical(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::critical, fmt, args...);

+}

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::alert(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::alert, fmt, args...);

+}

+

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::emerg(const char* fmt, const Args&... args)

+{

+    return _log_if_enabled(level::emerg, fmt, args...);

+}

+

+//

+// logger.info(msg) << ".." call style

+//

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::trace(const T& msg)

+{

+    return _log_if_enabled(level::trace, msg);

+}

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::debug(const T& msg)

+{

+    return _log_if_enabled(level::debug, msg);

+}

+

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::info(const T& msg)

+{

+    return _log_if_enabled(level::info, msg);

+}

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::notice(const T& msg)

+{

+    return _log_if_enabled(level::notice, msg);

+}

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::warn(const T& msg)

+{

+    return _log_if_enabled(level::warn, msg);

+}

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::error(const T& msg)

+{

+    return _log_if_enabled(level::err, msg);

+}

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::critical(const T& msg)

+{

+    return _log_if_enabled(level::critical, msg);

+}

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::alert(const T& msg)

+{

+    return _log_if_enabled(level::alert, msg);

+}

+

+template<typename T>

+inline spdlog::details::line_logger spdlog::logger::emerg(const T& msg)

+{

+    return _log_if_enabled(level::emerg, msg);

+}

+

+

+

+

+//

+// logger.info() << ".." call  style

+//

+inline spdlog::details::line_logger spdlog::logger::trace()

+{

+    return _log_if_enabled(level::trace);

+}

+

+inline spdlog::details::line_logger spdlog::logger::debug()

+{

+    return _log_if_enabled(level::debug);

+}

+

+inline spdlog::details::line_logger spdlog::logger::info()

+{

+    return _log_if_enabled(level::info);

+}

+

+inline spdlog::details::line_logger spdlog::logger::notice()

+{

+    return _log_if_enabled(level::notice);

+}

+

+inline spdlog::details::line_logger spdlog::logger::warn()

+{

+    return _log_if_enabled(level::warn);

+}

+

+inline spdlog::details::line_logger spdlog::logger::error()

+{

+    return _log_if_enabled(level::err);

+}

+

+inline spdlog::details::line_logger spdlog::logger::critical()

+{

+    return _log_if_enabled(level::critical);

+}

+

+inline spdlog::details::line_logger spdlog::logger::alert()

+{

+    return _log_if_enabled(level::alert);

+}

+

+inline spdlog::details::line_logger spdlog::logger::emerg()

+{

+    return _log_if_enabled(level::emerg);

+}

+

+

+// always log, no matter what is the actual logger's log level

+template <typename... Args>

+inline spdlog::details::line_logger spdlog::logger::force_log(level::level_enum lvl, const char* fmt, const Args&... args)

+{

+    details::line_logger l(this, lvl, true);

+    l.write(fmt, args...);

+    return l;

+}

+

+//

+// name and level

+//

+inline const std::string& spdlog::logger::name() const

+{

+    return _name;

+}

+

+inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)

+{

+    _level.store(log_level);

+}

+

+inline spdlog::level::level_enum spdlog::logger::level() const

+{

+    return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));

+}

+

+inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const

+{

+    return msg_level >= _level.load(std::memory_order_relaxed);

+}

+

+//

+// protected virtual called at end of each user log call (if enabled) by the line_logger

+//

+inline void spdlog::logger::_log_msg(details::log_msg& msg)

+{

+    _formatter->format(msg);

+    for (auto &sink : _sinks)

+        sink->log(msg);

+}

+

+inline void spdlog::logger::_set_pattern(const std::string& pattern)

+{

+    _formatter = std::make_shared<pattern_formatter>(pattern);

+}

+inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)

+{

+    _formatter = msg_formatter;

+}

+

+inline void spdlog::logger::flush()

+{

+    for (auto& sink : _sinks)

+        sink->flush();

+}

diff --git a/include/spdlog/details/mpmc_bounded_q.h b/include/spdlog/details/mpmc_bounded_q.h
index ad14d6f2..f13605a7 100644
--- a/include/spdlog/details/mpmc_bounded_q.h
+++ b/include/spdlog/details/mpmc_bounded_q.h
@@ -1,159 +1,159 @@
-/*
-A modified version of Bounded MPMC queue by Dmitry Vyukov.
-
-Original code from:
-http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
-
-licensed by Dmitry Vyukov under the terms below:
-
-Simplified BSD license
-
-Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved.
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice, this list of
-conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list
-of conditions and the following disclaimer in the documentation and/or other materials
-provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
-SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-The views and conclusions contained in the software and documentation are those of the authors and
-should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov.
-*/
-
-/*
-The code in its current form adds the license below:
-
-Copyright(c) 2015 Gabi Melman.
-Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-*/
-
-#pragma once
-
-#include <spdlog/common.h>
-
-#include <atomic>
-#include <utility>
-
-namespace spdlog
-{
-namespace details
-{
-
-template<typename T>
-class mpmc_bounded_queue
-{
-public:
-
-    using item_type = T;
-    mpmc_bounded_queue(size_t buffer_size)
-        : buffer_(new cell_t [buffer_size]),
-          buffer_mask_(buffer_size - 1)
-    {
-        //queue size must be power of two
-        if(!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
-            throw spdlog_ex("async logger queue size must be power of two");
-
-        for (size_t i = 0; i != buffer_size; i += 1)
-            buffer_[i].sequence_.store(i, std::memory_order_relaxed);
-        enqueue_pos_.store(0, std::memory_order_relaxed);
-        dequeue_pos_.store(0, std::memory_order_relaxed);
-    }
-
-    ~mpmc_bounded_queue()
-    {
-        delete [] buffer_;
-    }
-
-
-    bool enqueue(T&& data)
-    {
-        cell_t* cell;
-        size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
-        for (;;)
-        {
-            cell = &buffer_[pos & buffer_mask_];
-            size_t seq = cell->sequence_.load(std::memory_order_acquire);
-            intptr_t dif = (intptr_t)seq - (intptr_t)pos;
-            if (dif == 0)
-            {
-                if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-                    break;
-            }
-            else if (dif < 0)
-            {
-                return false;
-            }
-            else
-            {
-                pos = enqueue_pos_.load(std::memory_order_relaxed);
-            }
-        }
-        cell->data_ = std::move(data);
-        cell->sequence_.store(pos + 1, std::memory_order_release);
-        return true;
-    }
-
-    bool dequeue(T& data)
-    {
-        cell_t* cell;
-        size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
-        for (;;)
-        {
-            cell = &buffer_[pos & buffer_mask_];
-            size_t seq =
-                cell->sequence_.load(std::memory_order_acquire);
-            intptr_t dif = (intptr_t)seq - (intptr_t)(pos + 1);
-            if (dif == 0)
-            {
-                if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-                    break;
-            }
-            else if (dif < 0)
-                return false;
-            else
-                pos = dequeue_pos_.load(std::memory_order_relaxed);
-        }
-        data = std::move(cell->data_);
-        cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
-        return true;
-    }
-
-private:
-    struct cell_t
-    {
-        std::atomic<size_t>   sequence_;
-        T                     data_;
-    };
-
-    static size_t const     cacheline_size = 64;
-    typedef char            cacheline_pad_t [cacheline_size];
-
-    cacheline_pad_t         pad0_;
-    cell_t* const           buffer_;
-    size_t const            buffer_mask_;
-    cacheline_pad_t         pad1_;
-    std::atomic<size_t>     enqueue_pos_;
-    cacheline_pad_t         pad2_;
-    std::atomic<size_t>     dequeue_pos_;
-    cacheline_pad_t         pad3_;
-
-    mpmc_bounded_queue(mpmc_bounded_queue const&);
-    void operator = (mpmc_bounded_queue const&);
-};
-
-} // ns details
-} // ns spdlog
+/*

+A modified version of Bounded MPMC queue by Dmitry Vyukov.

+

+Original code from:

+http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue

+

+licensed by Dmitry Vyukov under the terms below:

+

+Simplified BSD license

+

+Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved.

+Redistribution and use in source and binary forms, with or without modification,

+are permitted provided that the following conditions are met:

+1. Redistributions of source code must retain the above copyright notice, this list of

+conditions and the following disclaimer.

+

+2. Redistributions in binary form must reproduce the above copyright notice, this list

+of conditions and the following disclaimer in the documentation and/or other materials

+provided with the distribution.

+

+THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED

+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT

+SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,

+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE

+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

+The views and conclusions contained in the software and documentation are those of the authors and

+should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov.

+*/

+

+/*

+The code in its current form adds the license below:

+

+Copyright(c) 2015 Gabi Melman.

+Distributed under the MIT License (http://opensource.org/licenses/MIT)

+

+*/

+

+#pragma once

+

+#include <spdlog/common.h>

+

+#include <atomic>

+#include <utility>

+

+namespace spdlog

+{

+namespace details

+{

+

+template<typename T>

+class mpmc_bounded_queue

+{

+public:

+

+    using item_type = T;

+    mpmc_bounded_queue(size_t buffer_size)

+        : buffer_(new cell_t [buffer_size]),

+          buffer_mask_(buffer_size - 1)

+    {

+        //queue size must be power of two

+        if(!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))

+            throw spdlog_ex("async logger queue size must be power of two");

+

+        for (size_t i = 0; i != buffer_size; i += 1)

+            buffer_[i].sequence_.store(i, std::memory_order_relaxed);

+        enqueue_pos_.store(0, std::memory_order_relaxed);

+        dequeue_pos_.store(0, std::memory_order_relaxed);

+    }

+

+    ~mpmc_bounded_queue()

+    {

+        delete [] buffer_;

+    }

+

+

+    bool enqueue(T&& data)

+    {

+        cell_t* cell;

+        size_t pos = enqueue_pos_.load(std::memory_order_relaxed);

+        for (;;)

+        {

+            cell = &buffer_[pos & buffer_mask_];

+            size_t seq = cell->sequence_.load(std::memory_order_acquire);

+            intptr_t dif = (intptr_t)seq - (intptr_t)pos;

+            if (dif == 0)

+            {

+                if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))

+                    break;

+            }

+            else if (dif < 0)

+            {

+                return false;

+            }

+            else

+            {

+                pos = enqueue_pos_.load(std::memory_order_relaxed);

+            }

+        }

+        cell->data_ = std::move(data);

+        cell->sequence_.store(pos + 1, std::memory_order_release);

+        return true;

+    }

+

+    bool dequeue(T& data)

+    {

+        cell_t* cell;

+        size_t pos = dequeue_pos_.load(std::memory_order_relaxed);

+        for (;;)

+        {

+            cell = &buffer_[pos & buffer_mask_];

+            size_t seq =

+                cell->sequence_.load(std::memory_order_acquire);

+            intptr_t dif = (intptr_t)seq - (intptr_t)(pos + 1);

+            if (dif == 0)

+            {

+                if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))

+                    break;

+            }

+            else if (dif < 0)

+                return false;

+            else

+                pos = dequeue_pos_.load(std::memory_order_relaxed);

+        }

+        data = std::move(cell->data_);

+        cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);

+        return true;

+    }

+

+private:

+    struct cell_t

+    {

+        std::atomic<size_t>   sequence_;

+        T                     data_;

+    };

+

+    static size_t const     cacheline_size = 64;

+    typedef char            cacheline_pad_t [cacheline_size];

+

+    cacheline_pad_t         pad0_;

+    cell_t* const           buffer_;

+    size_t const            buffer_mask_;

+    cacheline_pad_t         pad1_;

+    std::atomic<size_t>     enqueue_pos_;

+    cacheline_pad_t         pad2_;

+    std::atomic<size_t>     dequeue_pos_;

+    cacheline_pad_t         pad3_;

+

+    mpmc_bounded_queue(mpmc_bounded_queue const&);

+    void operator = (mpmc_bounded_queue const&);

+};

+

+} // ns details

+} // ns spdlog

diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h
index 0f01ffb9..aedc4942 100644
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@@ -1,222 +1,222 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-#pragma once
-
-#include <spdlog/common.h>
-
-#include <cstdio>
-#include <ctime>
-#include <functional>
-#include <string>
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX //prevent windows redefining min/max
-#endif 
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-
-#ifdef __MINGW32__
-#include <share.h>
-#endif
-
-#elif __linux__
-#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
-#include <sys/stat.h>
-#include <unistd.h>
-#include <chrono>
-#else
-#include <thread>
-#endif
-
-namespace spdlog
-{
-namespace details
-{
-namespace os
-{
-
-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>(
-               std::chrono::duration_cast<typename log_clock::duration>(
-                   std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
-
-
-#else
-    return log_clock::now();
-#endif
-
-}
-inline std::tm localtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
-    std::tm tm;
-    localtime_s(&tm, &time_tt);
-#else
-    std::tm tm;
-    localtime_r(&time_tt, &tm);
-#endif
-    return tm;
-}
-
-inline std::tm localtime()
-{
-    std::time_t now_t = time(nullptr);
-    return localtime(now_t);
-}
-
-
-inline std::tm gmtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
-    std::tm tm;
-    gmtime_s(&tm, &time_tt);
-#else
-    std::tm tm;
-    gmtime_r(&time_tt, &tm);
-#endif
-    return tm;
-}
-
-inline std::tm gmtime()
-{
-    std::time_t now_t = time(nullptr);
-    return gmtime(now_t);
-}
-inline bool operator==(const std::tm& tm1, const std::tm& tm2)
-{
-    return (tm1.tm_sec == tm2.tm_sec &&
-            tm1.tm_min == tm2.tm_min &&
-            tm1.tm_hour == tm2.tm_hour &&
-            tm1.tm_mday == tm2.tm_mday &&
-            tm1.tm_mon == tm2.tm_mon &&
-            tm1.tm_year == tm2.tm_year &&
-            tm1.tm_isdst == tm2.tm_isdst);
-}
-
-inline bool operator!=(const std::tm& tm1, const std::tm& tm2)
-{
-    return !(tm1 == tm2);
-}
-
-#ifdef _WIN32
-inline const char* eol()
-{
-    return "\r\n";
-}
-#else
-constexpr inline const char* eol()
-{
-    return "\n";
-}
-#endif
-
-#ifdef _WIN32
-inline unsigned short eol_size()
-{
-    return 2;
-}
-#else
-constexpr inline unsigned short eol_size()
-{
-    return 1;
-}
-#endif
-
-//fopen_s on non windows for writing
-inline int fopen_s(FILE** fp, const std::string& filename, const char* mode)
-{
-#ifdef _WIN32
-    *fp = _fsopen((filename.c_str()), mode, _SH_DENYWR);
-    return *fp == nullptr;
-#else
-    *fp = fopen((filename.c_str()), mode);
-    return *fp == nullptr;
-#endif
-
-}
-
-
-//Return if file exists
-inline bool file_exists(const std::string& filename)
-{
-#ifdef _WIN32
-    auto attribs = GetFileAttributesA(filename.c_str());
-    return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
-#elif __linux__
-    struct stat buffer;
-    return (stat (filename.c_str(), &buffer) == 0);
-#else
-    auto *file = fopen(filename.c_str(), "r");
-    if (file != nullptr)
-    {
-        fclose(file);
-        return true;
-    }
-    return false;
-
-#endif
-
-}
-
-//Return utc offset in minutes or throw spdlog_ex on failure
-inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
-{
-
-#ifdef _WIN32
-#if _WIN32_WINNT < _WIN32_WINNT_WS08
-    TIME_ZONE_INFORMATION tzinfo;
-    auto rv = GetTimeZoneInformation(&tzinfo);
-#else
-    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
-    auto rv = GetDynamicTimeZoneInformation(&tzinfo);
-#endif
-    if (rv == TIME_ZONE_ID_INVALID)
-        throw spdlog::spdlog_ex("Failed getting timezone info. Last error: " + GetLastError());
-
-    int offset = -tzinfo.Bias;
-    if (tm.tm_isdst)
-        offset -= tzinfo.DaylightBias;
-    else
-        offset -= tzinfo.StandardBias;
-    return offset;
-#else
-    return static_cast<int>(tm.tm_gmtoff / 60);
-#endif
-}
-
-//Return current thread id as size_t
-//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013)
-inline size_t thread_id()
-{
-#ifdef _WIN32
-    return  static_cast<size_t>(::GetCurrentThreadId());
-#elif __linux__
-# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-#  define SYS_gettid __NR_gettid
-# endif
-    return  static_cast<size_t>(syscall(SYS_gettid));
-#else //Default to standard C++11 (OSX and other Unix)
-    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
-#endif
-
-}
-
-} //os
-} //details
-} //spdlog
-
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+#pragma once

+

+#include <spdlog/common.h>

+

+#include <cstdio>

+#include <ctime>

+#include <functional>

+#include <string>

+

+#ifdef _WIN32

+

+#ifndef NOMINMAX

+#define NOMINMAX //prevent windows redefining min/max

+#endif

+

+#ifndef WIN32_LEAN_AND_MEAN

+#define WIN32_LEAN_AND_MEAN

+#endif

+#include <windows.h>

+

+#ifdef __MINGW32__

+#include <share.h>

+#endif

+

+#elif __linux__

+#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id

+#include <sys/stat.h>

+#include <unistd.h>

+#include <chrono>

+#else

+#include <thread>

+#endif

+

+namespace spdlog

+{

+namespace details

+{

+namespace os

+{

+

+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>(

+               std::chrono::duration_cast<typename log_clock::duration>(

+                   std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));

+

+

+#else

+    return log_clock::now();

+#endif

+

+}

+inline std::tm localtime(const std::time_t &time_tt)

+{

+

+#ifdef _WIN32

+    std::tm tm;

+    localtime_s(&tm, &time_tt);

+#else

+    std::tm tm;

+    localtime_r(&time_tt, &tm);

+#endif

+    return tm;

+}

+

+inline std::tm localtime()

+{

+    std::time_t now_t = time(nullptr);

+    return localtime(now_t);

+}

+

+

+inline std::tm gmtime(const std::time_t &time_tt)

+{

+

+#ifdef _WIN32

+    std::tm tm;

+    gmtime_s(&tm, &time_tt);

+#else

+    std::tm tm;

+    gmtime_r(&time_tt, &tm);

+#endif

+    return tm;

+}

+

+inline std::tm gmtime()

+{

+    std::time_t now_t = time(nullptr);

+    return gmtime(now_t);

+}

+inline bool operator==(const std::tm& tm1, const std::tm& tm2)

+{

+    return (tm1.tm_sec == tm2.tm_sec &&

+            tm1.tm_min == tm2.tm_min &&

+            tm1.tm_hour == tm2.tm_hour &&

+            tm1.tm_mday == tm2.tm_mday &&

+            tm1.tm_mon == tm2.tm_mon &&

+            tm1.tm_year == tm2.tm_year &&

+            tm1.tm_isdst == tm2.tm_isdst);

+}

+

+inline bool operator!=(const std::tm& tm1, const std::tm& tm2)

+{

+    return !(tm1 == tm2);

+}

+

+#ifdef _WIN32

+inline const char* eol()

+{

+    return "\r\n";

+}

+#else

+constexpr inline const char* eol()

+{

+    return "\n";

+}

+#endif

+

+#ifdef _WIN32

+inline unsigned short eol_size()

+{

+    return 2;

+}

+#else

+constexpr inline unsigned short eol_size()

+{

+    return 1;

+}

+#endif

+

+//fopen_s on non windows for writing

+inline int fopen_s(FILE** fp, const std::string& filename, const char* mode)

+{

+#ifdef _WIN32

+    *fp = _fsopen((filename.c_str()), mode, _SH_DENYWR);

+    return *fp == nullptr;

+#else

+    *fp = fopen((filename.c_str()), mode);

+    return *fp == nullptr;

+#endif

+

+}

+

+

+//Return if file exists

+inline bool file_exists(const std::string& filename)

+{

+#ifdef _WIN32

+    auto attribs = GetFileAttributesA(filename.c_str());

+    return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));

+#elif __linux__

+    struct stat buffer;

+    return (stat (filename.c_str(), &buffer) == 0);

+#else

+    auto *file = fopen(filename.c_str(), "r");

+    if (file != nullptr)

+    {

+        fclose(file);

+        return true;

+    }

+    return false;

+

+#endif

+

+}

+

+//Return utc offset in minutes or throw spdlog_ex on failure

+inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())

+{

+

+#ifdef _WIN32

+#if _WIN32_WINNT < _WIN32_WINNT_WS08

+    TIME_ZONE_INFORMATION tzinfo;

+    auto rv = GetTimeZoneInformation(&tzinfo);

+#else

+    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;

+    auto rv = GetDynamicTimeZoneInformation(&tzinfo);

+#endif

+    if (rv == TIME_ZONE_ID_INVALID)

+        throw spdlog::spdlog_ex("Failed getting timezone info. Last error: " + GetLastError());

+

+    int offset = -tzinfo.Bias;

+    if (tm.tm_isdst)

+        offset -= tzinfo.DaylightBias;

+    else

+        offset -= tzinfo.StandardBias;

+    return offset;

+#else

+    return static_cast<int>(tm.tm_gmtoff / 60);

+#endif

+}

+

+//Return current thread id as size_t

+//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013)

+inline size_t thread_id()

+{

+#ifdef _WIN32

+    return  static_cast<size_t>(::GetCurrentThreadId());

+#elif __linux__

+# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)

+#  define SYS_gettid __NR_gettid

+# endif

+    return  static_cast<size_t>(syscall(SYS_gettid));

+#else //Default to standard C++11 (OSX and other Unix)

+    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));

+#endif

+

+}

+

+} //os

+} //details

+} //spdlog

+

+

diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h
index 3965b831..7b8a9199 100644
--- a/include/spdlog/details/pattern_formatter_impl.h
+++ b/include/spdlog/details/pattern_formatter_impl.h
@@ -1,628 +1,628 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/formatter.h>
-#include <spdlog/details/log_msg.h>
-#include <spdlog/details/os.h>
-#include <spdlog/details/format.h>
-
-#include <chrono>
-#include <ctime>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace spdlog
-{
-namespace details
-{
-class flag_formatter
-{
-public:
-    virtual ~flag_formatter() {}
-    virtual void format(details::log_msg& msg, const std::tm& tm_time) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////
-// name & level pattern appenders
-///////////////////////////////////////////////////////////////////////
-namespace
-{
-class name_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << msg.logger_name;
-    }
-};
-}
-
-// log level appender
-class level_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << level::to_str(msg.level);
-    }
-};
-
-// short log level appender
-class short_level_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << level::to_short_str(msg.level);
-    }
-};
-
-///////////////////////////////////////////////////////////////////////
-// Date time pattern appenders
-///////////////////////////////////////////////////////////////////////
-
-static const char* ampm(const tm& t)
-{
-    return t.tm_hour >= 12 ? "PM" : "AM";
-}
-
-static int to12h(const tm& t)
-{
-    return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
-}
-
-//Abbreviated weekday name
-static const std::string days[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-class a_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << days[tm_time.tm_wday];
-    }
-};
-
-//Full weekday name
-static const std::string full_days[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
-class A_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << full_days[tm_time.tm_wday];
-    }
-};
-
-//Abbreviated month
-static const std::string  months[] { "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sept", "Oct", "Nov", "Dec" };
-class b_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted<< months[tm_time.tm_mon];
-    }
-};
-
-//Full month name
-static const std::string full_months[] { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
-class B_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << full_months[tm_time.tm_mon];
-    }
-};
-
-
-//write 2 ints seperated by sep with padding of 2
-static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, char sep)
-{
-    w << fmt::pad(v1, 2, '0') << sep << fmt::pad(v2, 2, '0');
-    return w;
-}
-
-//write 3 ints seperated by sep with padding of 2
-static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, int v3, char sep)
-{
-    w << fmt::pad(v1, 2, '0') << sep << fmt::pad(v2, 2, '0') << sep << fmt::pad(v3, 2, '0');
-    return w;
-}
-
-
-//Date and time representation (Thu Aug 23 15:35:46 2014)
-class c_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << days[tm_time.tm_wday] << ' ' << months[tm_time.tm_mon] << ' ' << tm_time.tm_mday << ' ';
-        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << tm_time.tm_year + 1900;
-    }
-};
-
-
-// year - 2 digit
-class C_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_year % 100, 2, '0');
-    }
-};
-
-
-
-// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
-class D_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        pad_n_join(msg.formatted, tm_time.tm_mon + 1, tm_time.tm_mday, tm_time.tm_year % 100, '/');
-    }
-};
-
-
-// year - 4 digit
-class Y_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << tm_time.tm_year + 1900;
-    }
-};
-
-// month 1-12
-class m_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_mon + 1, 2, '0');
-    }
-};
-
-// day of month 1-31
-class d_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_mday, 2, '0');
-    }
-};
-
-// hours in 24 format  0-23
-class H_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_hour, 2, '0');
-    }
-};
-
-// hours in 12 format  1-12
-class I_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(to12h(tm_time), 2, '0');
-    }
-};
-
-// minutes 0-59
-class M_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_min, 2, '0');
-    }
-};
-
-// seconds 0-59
-class S_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_sec, 2, '0');
-    }
-};
-
-// milliseconds
-class e_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        auto duration = msg.time.time_since_epoch();
-        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
-        msg.formatted << fmt::pad(static_cast<int>(millis), 3, '0');
-    }
-};
-
-// microseconds
-class f_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        auto duration = msg.time.time_since_epoch();
-        auto micros = std::chrono::duration_cast<std::chrono::microseconds>(duration).count() % 1000000;
-        msg.formatted << fmt::pad(static_cast<int>(micros), 6, '0');
-    }
-};
-
-// nanoseconds
-class F_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        auto duration = msg.time.time_since_epoch();
-        auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count() % 1000000000;
-        msg.formatted << fmt::pad(static_cast<int>(ns), 9, '0');
-    }
-};
-
-// AM/PM
-class p_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << ampm(tm_time);
-    }
-};
-
-
-// 12 hour clock 02:55:02 pm
-class r_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        pad_n_join(msg.formatted, to12h(tm_time), tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << ampm(tm_time);
-    }
-};
-
-// 24-hour HH:MM time, equivalent to %H:%M
-class R_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, ':');
-    }
-};
-
-// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
-class T_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':');
-    }
-};
-
-
-// ISO 8601 offset from UTC in timezone (+-HH:MM)
-class z_formatter :public flag_formatter
-{
-public:
-    const std::chrono::seconds cache_refresh = std::chrono::seconds(5);
-
-    z_formatter() :_last_update(std::chrono::seconds(0)) {}
-    z_formatter(const z_formatter&) = delete;
-    z_formatter& operator=(const z_formatter&) = delete;
-
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-#ifdef _WIN32
-        int total_minutes = get_cached_offset(msg, tm_time);
-#else
-        // No need to chache under gcc,
-        // it is very fast (already stored in tm.tm_gmtoff)
-        int total_minutes = os::utc_minutes_offset(tm_time);
-#endif
-
-        int h = total_minutes / 60;
-        int m = total_minutes % 60;
-        if (h >= 0) //minus sign will be printed anyway if negative
-        {
-            msg.formatted << '+';
-        }
-        pad_n_join(msg.formatted, h, m, ':');
-    }
-private:
-    log_clock::time_point _last_update;
-    int _offset_minutes;
-    std::mutex _mutex;
-
-    int get_cached_offset(const log_msg& msg, const std::tm& tm_time)
-    {
-        using namespace std::chrono;
-        std::lock_guard<std::mutex> l(_mutex);
-        if (msg.time - _last_update >= cache_refresh)
-        {
-            _offset_minutes = os::utc_minutes_offset(tm_time);
-            _last_update = msg.time;
-        }
-        return _offset_minutes;
-    }
-};
-
-
-
-//Thread id
-class t_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << msg.thread_id;
-    }
-};
-
-
-class v_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());
-    }
-};
-
-class ch_formatter :public flag_formatter
-{
-public:
-    explicit ch_formatter(char ch) : _ch(ch)
-    {}
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << _ch;
-    }
-private:
-    char _ch;
-};
-
-
-//aggregate user chars to display as is
-class aggregate_formatter :public flag_formatter
-{
-public:
-    aggregate_formatter()
-    {}
-    void add_ch(char ch)
-    {
-        _str += ch;
-    }
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << _str;
-    }
-private:
-    std::string _str;
-};
-
-// Full info formatter
-// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
-class full_formatter :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-#ifndef SPDLOG_NO_DATETIME
-        auto duration = msg.time.time_since_epoch();
-        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
-
-        /* Slower version(while still very fast - about 3.2 million lines/sec under 10 threads),
-        msg.formatted.write("[{:d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}.{:03d}] [{}] [{}] {} ",
-        tm_time.tm_year + 1900,
-        tm_time.tm_mon + 1,
-        tm_time.tm_mday,
-        tm_time.tm_hour,
-        tm_time.tm_min,
-        tm_time.tm_sec,
-        static_cast<int>(millis),
-        msg.logger_name,
-        level::to_str(msg.level),
-        msg.raw.str());*/
-
-
-        // Faster (albeit uglier) way to format the line (5.6 million lines/sec under 10 threads)
-        msg.formatted << '[' << static_cast<unsigned int>(tm_time.tm_year + 1900) << '-'
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_mon + 1), 2, '0') << '-'
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_mday), 2, '0') << ' '
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_hour), 2, '0') << ':'
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_min), 2, '0') << ':'
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_sec), 2, '0') << '.'
-                      << fmt::pad(static_cast<unsigned int>(millis), 3, '0') << "] ";
-
-//no datetime needed
-#else
-        (void)tm_time;
-#endif
-
-#ifndef SPDLOG_NO_NAME
-        msg.formatted << '[' << msg.logger_name << "] ";
-#endif
-
-        msg.formatted << '[' << level::to_str(msg.level) << "] ";
-        msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());
-    }
-};
-
-}
-}
-///////////////////////////////////////////////////////////////////////////////
-// pattern_formatter inline impl
-///////////////////////////////////////////////////////////////////////////////
-inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern)
-{
-    compile_pattern(pattern);
-}
-
-inline void spdlog::pattern_formatter::compile_pattern(const std::string& pattern)
-{
-    auto end = pattern.end();
-    std::unique_ptr<details::aggregate_formatter> user_chars;
-    for (auto it = pattern.begin(); it != end; ++it)
-    {
-        if (*it == '%')
-        {
-            if (user_chars) //append user chars found so far
-                _formatters.push_back(std::move(user_chars));
-
-            if (++it != end)
-                handle_flag(*it);
-            else
-                break;
-        }
-        else // chars not following the % sign should be displayed as is
-        {
-            if (!user_chars)
-                user_chars = std::unique_ptr<details::aggregate_formatter>(new details::aggregate_formatter());
-            user_chars->add_ch(*it);
-        }
-    }
-    if (user_chars) //append raw chars found so far
-    {
-        _formatters.push_back(std::move(user_chars));
-    }
-
-}
-inline void spdlog::pattern_formatter::handle_flag(char flag)
-{
-    switch (flag)
-    {
-    // logger name
-    case 'n':
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::name_formatter()));
-        break;
-
-    case 'l':
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::level_formatter()));
-        break;
-
-    case 'L':
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::short_level_formatter()));
-        break;
-
-    case('t') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::t_formatter()));
-        break;
-
-    case('v') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::v_formatter()));
-        break;
-
-    case('a') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::a_formatter()));
-        break;
-
-    case('A') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::A_formatter()));
-        break;
-
-    case('b') :
-    case('h') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::b_formatter()));
-        break;
-
-    case('B') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::B_formatter()));
-        break;
-    case('c') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::c_formatter()));
-        break;
-
-    case('C') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::C_formatter()));
-        break;
-
-    case('Y') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::Y_formatter()));
-        break;
-
-    case('D') :
-    case('x') :
-
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::D_formatter()));
-        break;
-
-    case('m') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::m_formatter()));
-        break;
-
-    case('d') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::d_formatter()));
-        break;
-
-    case('H') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::H_formatter()));
-        break;
-
-    case('I') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::I_formatter()));
-        break;
-
-    case('M') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::M_formatter()));
-        break;
-
-    case('S') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::S_formatter()));
-        break;
-
-    case('e') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::e_formatter()));
-        break;
-
-    case('f') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::f_formatter()));
-        break;
-    case('F') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::F_formatter()));
-        break;
-
-    case('p') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::p_formatter()));
-        break;
-
-    case('r') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::r_formatter()));
-        break;
-
-    case('R') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::R_formatter()));
-        break;
-
-    case('T') :
-    case('X') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::T_formatter()));
-        break;
-
-    case('z') :
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::z_formatter()));
-        break;
-
-    case ('+'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::full_formatter()));
-        break;
-
-    default: //Unkown flag appears as is
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter('%')));
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter(flag)));
-        break;
-    }
-}
-
-
-inline void spdlog::pattern_formatter::format(details::log_msg& msg)
-{
-    try
-    {
-        auto tm_time = details::os::localtime(log_clock::to_time_t(msg.time));
-        for (auto &f : _formatters)
-        {
-            f->format(msg, tm_time);
-        }
-        //write eol
-        msg.formatted << details::os::eol();
-    }
-    catch(const fmt::FormatError& e)
-    {
-        throw spdlog_ex(fmt::format("formatting error while processing format string: {}", e.what()));
-    }
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/formatter.h>

+#include <spdlog/details/log_msg.h>

+#include <spdlog/details/os.h>

+#include <spdlog/details/format.h>

+

+#include <chrono>

+#include <ctime>

+#include <memory>

+#include <mutex>

+#include <string>

+#include <thread>

+#include <utility>

+#include <vector>

+

+namespace spdlog

+{

+namespace details

+{

+class flag_formatter

+{

+public:

+    virtual ~flag_formatter() {}

+    virtual void format(details::log_msg& msg, const std::tm& tm_time) = 0;

+};

+

+///////////////////////////////////////////////////////////////////////

+// name & level pattern appenders

+///////////////////////////////////////////////////////////////////////

+namespace

+{

+class name_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        msg.formatted << msg.logger_name;

+    }

+};

+}

+

+// log level appender

+class level_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        msg.formatted << level::to_str(msg.level);

+    }

+};

+

+// short log level appender

+class short_level_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        msg.formatted << level::to_short_str(msg.level);

+    }

+};

+

+///////////////////////////////////////////////////////////////////////

+// Date time pattern appenders

+///////////////////////////////////////////////////////////////////////

+

+static const char* ampm(const tm& t)

+{

+    return t.tm_hour >= 12 ? "PM" : "AM";

+}

+

+static int to12h(const tm& t)

+{

+    return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;

+}

+

+//Abbreviated weekday name

+static const std::string days[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

+class a_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << days[tm_time.tm_wday];

+    }

+};

+

+//Full weekday name

+static const std::string full_days[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

+class A_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << full_days[tm_time.tm_wday];

+    }

+};

+

+//Abbreviated month

+static const std::string  months[] { "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sept", "Oct", "Nov", "Dec" };

+class b_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted<< months[tm_time.tm_mon];

+    }

+};

+

+//Full month name

+static const std::string full_months[] { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };

+class B_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << full_months[tm_time.tm_mon];

+    }

+};

+

+

+//write 2 ints seperated by sep with padding of 2

+static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, char sep)

+{

+    w << fmt::pad(v1, 2, '0') << sep << fmt::pad(v2, 2, '0');

+    return w;

+}

+

+//write 3 ints seperated by sep with padding of 2

+static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, int v3, char sep)

+{

+    w << fmt::pad(v1, 2, '0') << sep << fmt::pad(v2, 2, '0') << sep << fmt::pad(v3, 2, '0');

+    return w;

+}

+

+

+//Date and time representation (Thu Aug 23 15:35:46 2014)

+class c_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << days[tm_time.tm_wday] << ' ' << months[tm_time.tm_mon] << ' ' << tm_time.tm_mday << ' ';

+        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << tm_time.tm_year + 1900;

+    }

+};

+

+

+// year - 2 digit

+class C_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << fmt::pad(tm_time.tm_year % 100, 2, '0');

+    }

+};

+

+

+

+// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01

+class D_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        pad_n_join(msg.formatted, tm_time.tm_mon + 1, tm_time.tm_mday, tm_time.tm_year % 100, '/');

+    }

+};

+

+

+// year - 4 digit

+class Y_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << tm_time.tm_year + 1900;

+    }

+};

+

+// month 1-12

+class m_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << fmt::pad(tm_time.tm_mon + 1, 2, '0');

+    }

+};

+

+// day of month 1-31

+class d_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << fmt::pad(tm_time.tm_mday, 2, '0');

+    }

+};

+

+// hours in 24 format  0-23

+class H_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << fmt::pad(tm_time.tm_hour, 2, '0');

+    }

+};

+

+// hours in 12 format  1-12

+class I_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << fmt::pad(to12h(tm_time), 2, '0');

+    }

+};

+

+// minutes 0-59

+class M_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << fmt::pad(tm_time.tm_min, 2, '0');

+    }

+};

+

+// seconds 0-59

+class S_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << fmt::pad(tm_time.tm_sec, 2, '0');

+    }

+};

+

+// milliseconds

+class e_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        auto duration = msg.time.time_since_epoch();

+        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;

+        msg.formatted << fmt::pad(static_cast<int>(millis), 3, '0');

+    }

+};

+

+// microseconds

+class f_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        auto duration = msg.time.time_since_epoch();

+        auto micros = std::chrono::duration_cast<std::chrono::microseconds>(duration).count() % 1000000;

+        msg.formatted << fmt::pad(static_cast<int>(micros), 6, '0');

+    }

+};

+

+// nanoseconds

+class F_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        auto duration = msg.time.time_since_epoch();

+        auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count() % 1000000000;

+        msg.formatted << fmt::pad(static_cast<int>(ns), 9, '0');

+    }

+};

+

+// AM/PM

+class p_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        msg.formatted << ampm(tm_time);

+    }

+};

+

+

+// 12 hour clock 02:55:02 pm

+class r_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        pad_n_join(msg.formatted, to12h(tm_time), tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << ampm(tm_time);

+    }

+};

+

+// 24-hour HH:MM time, equivalent to %H:%M

+class R_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, ':');

+    }

+};

+

+// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S

+class T_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':');

+    }

+};

+

+

+// ISO 8601 offset from UTC in timezone (+-HH:MM)

+class z_formatter :public flag_formatter

+{

+public:

+    const std::chrono::seconds cache_refresh = std::chrono::seconds(5);

+

+    z_formatter() :_last_update(std::chrono::seconds(0)) {}

+    z_formatter(const z_formatter&) = delete;

+    z_formatter& operator=(const z_formatter&) = delete;

+

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+#ifdef _WIN32

+        int total_minutes = get_cached_offset(msg, tm_time);

+#else

+        // No need to chache under gcc,

+        // it is very fast (already stored in tm.tm_gmtoff)

+        int total_minutes = os::utc_minutes_offset(tm_time);

+#endif

+

+        int h = total_minutes / 60;

+        int m = total_minutes % 60;

+        if (h >= 0) //minus sign will be printed anyway if negative

+        {

+            msg.formatted << '+';

+        }

+        pad_n_join(msg.formatted, h, m, ':');

+    }

+private:

+    log_clock::time_point _last_update;

+    int _offset_minutes;

+    std::mutex _mutex;

+

+    int get_cached_offset(const log_msg& msg, const std::tm& tm_time)

+    {

+        using namespace std::chrono;

+        std::lock_guard<std::mutex> l(_mutex);

+        if (msg.time - _last_update >= cache_refresh)

+        {

+            _offset_minutes = os::utc_minutes_offset(tm_time);

+            _last_update = msg.time;

+        }

+        return _offset_minutes;

+    }

+};

+

+

+

+//Thread id

+class t_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        msg.formatted << msg.thread_id;

+    }

+};

+

+

+class v_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());

+    }

+};

+

+class ch_formatter :public flag_formatter

+{

+public:

+    explicit ch_formatter(char ch) : _ch(ch)

+    {}

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        msg.formatted << _ch;

+    }

+private:

+    char _ch;

+};

+

+

+//aggregate user chars to display as is

+class aggregate_formatter :public flag_formatter

+{

+public:

+    aggregate_formatter()

+    {}

+    void add_ch(char ch)

+    {

+        _str += ch;

+    }

+    void format(details::log_msg& msg, const std::tm&) override

+    {

+        msg.formatted << _str;

+    }

+private:

+    std::string _str;

+};

+

+// Full info formatter

+// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v

+class full_formatter :public flag_formatter

+{

+    void format(details::log_msg& msg, const std::tm& tm_time) override

+    {

+#ifndef SPDLOG_NO_DATETIME

+        auto duration = msg.time.time_since_epoch();

+        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;

+

+        /* Slower version(while still very fast - about 3.2 million lines/sec under 10 threads),

+        msg.formatted.write("[{:d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}.{:03d}] [{}] [{}] {} ",

+        tm_time.tm_year + 1900,

+        tm_time.tm_mon + 1,

+        tm_time.tm_mday,

+        tm_time.tm_hour,

+        tm_time.tm_min,

+        tm_time.tm_sec,

+        static_cast<int>(millis),

+        msg.logger_name,

+        level::to_str(msg.level),

+        msg.raw.str());*/

+

+

+        // Faster (albeit uglier) way to format the line (5.6 million lines/sec under 10 threads)

+        msg.formatted << '[' << static_cast<unsigned int>(tm_time.tm_year + 1900) << '-'

+                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_mon + 1), 2, '0') << '-'

+                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_mday), 2, '0') << ' '

+                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_hour), 2, '0') << ':'

+                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_min), 2, '0') << ':'

+                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_sec), 2, '0') << '.'

+                      << fmt::pad(static_cast<unsigned int>(millis), 3, '0') << "] ";

+

+//no datetime needed

+#else

+        (void)tm_time;

+#endif

+

+#ifndef SPDLOG_NO_NAME

+        msg.formatted << '[' << msg.logger_name << "] ";

+#endif

+

+        msg.formatted << '[' << level::to_str(msg.level) << "] ";

+        msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());

+    }

+};

+

+}

+}

+///////////////////////////////////////////////////////////////////////////////

+// pattern_formatter inline impl

+///////////////////////////////////////////////////////////////////////////////

+inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern)

+{

+    compile_pattern(pattern);

+}

+

+inline void spdlog::pattern_formatter::compile_pattern(const std::string& pattern)

+{

+    auto end = pattern.end();

+    std::unique_ptr<details::aggregate_formatter> user_chars;

+    for (auto it = pattern.begin(); it != end; ++it)

+    {

+        if (*it == '%')

+        {

+            if (user_chars) //append user chars found so far

+                _formatters.push_back(std::move(user_chars));

+

+            if (++it != end)

+                handle_flag(*it);

+            else

+                break;

+        }

+        else // chars not following the % sign should be displayed as is

+        {

+            if (!user_chars)

+                user_chars = std::unique_ptr<details::aggregate_formatter>(new details::aggregate_formatter());

+            user_chars->add_ch(*it);

+        }

+    }

+    if (user_chars) //append raw chars found so far

+    {

+        _formatters.push_back(std::move(user_chars));

+    }

+

+}

+inline void spdlog::pattern_formatter::handle_flag(char flag)

+{

+    switch (flag)

+    {

+    // logger name

+    case 'n':

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::name_formatter()));

+        break;

+

+    case 'l':

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::level_formatter()));

+        break;

+

+    case 'L':

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::short_level_formatter()));

+        break;

+

+    case('t') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::t_formatter()));

+        break;

+

+    case('v') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::v_formatter()));

+        break;

+

+    case('a') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::a_formatter()));

+        break;

+

+    case('A') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::A_formatter()));

+        break;

+

+    case('b') :

+    case('h') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::b_formatter()));

+        break;

+

+    case('B') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::B_formatter()));

+        break;

+    case('c') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::c_formatter()));

+        break;

+

+    case('C') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::C_formatter()));

+        break;

+

+    case('Y') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::Y_formatter()));

+        break;

+

+    case('D') :

+    case('x') :

+

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::D_formatter()));

+        break;

+

+    case('m') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::m_formatter()));

+        break;

+

+    case('d') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::d_formatter()));

+        break;

+

+    case('H') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::H_formatter()));

+        break;

+

+    case('I') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::I_formatter()));

+        break;

+

+    case('M') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::M_formatter()));

+        break;

+

+    case('S') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::S_formatter()));

+        break;

+

+    case('e') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::e_formatter()));

+        break;

+

+    case('f') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::f_formatter()));

+        break;

+    case('F') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::F_formatter()));

+        break;

+

+    case('p') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::p_formatter()));

+        break;

+

+    case('r') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::r_formatter()));

+        break;

+

+    case('R') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::R_formatter()));

+        break;

+

+    case('T') :

+    case('X') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::T_formatter()));

+        break;

+

+    case('z') :

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::z_formatter()));

+        break;

+

+    case ('+'):

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::full_formatter()));

+        break;

+

+    default: //Unkown flag appears as is

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter('%')));

+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter(flag)));

+        break;

+    }

+}

+

+

+inline void spdlog::pattern_formatter::format(details::log_msg& msg)

+{

+    try

+    {

+        auto tm_time = details::os::localtime(log_clock::to_time_t(msg.time));

+        for (auto &f : _formatters)

+        {

+            f->format(msg, tm_time);

+        }

+        //write eol

+        msg.formatted << details::os::eol();

+    }

+    catch(const fmt::FormatError& e)

+    {

+        throw spdlog_ex(fmt::format("formatting error while processing format string: {}", e.what()));

+    }

+}

diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index 78a47fec..131a2361 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -1,163 +1,163 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Loggers registy of unique name->logger pointer
-// An attempt to create a logger with an already existing name will be ignored
-// If user requests a non existing logger, nullptr will be returned
-// This class is thread safe
-
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/logger.h>
-#include <spdlog/async_logger.h>
-#include <spdlog/common.h>
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <unordered_map>
-
-namespace spdlog
-{
-namespace details
-{
-template <class Mutex> class registry_t
-{
-public:
-
-    void register_logger(std::shared_ptr<logger> logger)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-		auto logger_name = logger->name();
-		throw_if_exists(logger_name);		
-		_loggers[logger_name] = logger;
-    }
-
-
-    std::shared_ptr<logger> get(const std::string& logger_name)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        auto found = _loggers.find(logger_name);
-        return found == _loggers.end() ? nullptr : found->second;
-    }
-
-    template<class It>
-    std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
-    {        
-        std::lock_guard<Mutex> lock(_mutex);
-		throw_if_exists(logger_name);
-		std::shared_ptr<logger> new_logger;
-        if (_async_mode)
-            new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb, _flush_interval_ms);
-        else
-            new_logger = std::make_shared<logger>(logger_name, sinks_begin, sinks_end);
-
-        if (_formatter)
-            new_logger->set_formatter(_formatter);
-
-        new_logger->set_level(_level);
-		//Add to registry
-		_loggers[logger_name] = new_logger;
-        return new_logger;
-    }
-
-    void drop(const std::string& logger_name)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _loggers.erase(logger_name);
-    }
-
-    void drop_all()
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _loggers.clear();
-    }
-    std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks)
-    {
-        return create(logger_name, sinks.begin(), sinks.end());
-    }
-
-    std::shared_ptr<logger> create(const std::string& logger_name, sink_ptr sink)
-    {
-        return create(logger_name, { sink });
-    }
-
-
-    void formatter(formatter_ptr f)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _formatter = f;
-        for (auto& l : _loggers)
-            l.second->set_formatter(_formatter);
-    }
-
-    void set_pattern(const std::string& pattern)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _formatter = std::make_shared<pattern_formatter>(pattern);
-        for (auto& l : _loggers)
-            l.second->set_formatter(_formatter);
-    }
-
-    void set_level(level::level_enum log_level)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        for (auto& l : _loggers)
-            l.second->set_level(log_level);
-        _level = log_level;
-    }
-
-    void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _async_mode = true;
-        _async_q_size = q_size;
-        _overflow_policy = overflow_policy;
-        _worker_warmup_cb = worker_warmup_cb;
-        _flush_interval_ms = flush_interval_ms;
-    }
-
-    void set_sync_mode()
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _async_mode = false;
-    }
-
-    static registry_t<Mutex>& instance()
-    {
-        static registry_t<Mutex> s_instance;
-        return s_instance;
-    }
-
-private:    
-    registry_t<Mutex>() {}
-    registry_t<Mutex>(const registry_t<Mutex>&) = delete;
-    registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
-
-	void throw_if_exists(const std::string &logger_name)
-	{
-		if (_loggers.find(logger_name) != _loggers.end())
-			throw spdlog_ex("logger with name '" + logger_name + "' already exists");
-	}
-    Mutex _mutex;
-    std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
-    formatter_ptr _formatter;
-    level::level_enum _level = level::info;
-    bool _async_mode = false;
-    size_t _async_q_size = 0;
-    async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;
-    std::function<void()> _worker_warmup_cb = nullptr;
-    std::chrono::milliseconds _flush_interval_ms;
-};
-#ifdef SPDLOG_NO_REGISTRY_MUTEX
-typedef registry_t<spdlog::details::null_mutex> registry;
-#else
-typedef registry_t<std::mutex> registry;
-#endif
-}
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+// Loggers registy of unique name->logger pointer

+// An attempt to create a logger with an already existing name will be ignored

+// If user requests a non existing logger, nullptr will be returned

+// This class is thread safe

+

+#include <spdlog/details/null_mutex.h>

+#include <spdlog/logger.h>

+#include <spdlog/async_logger.h>

+#include <spdlog/common.h>

+

+#include <chrono>

+#include <functional>

+#include <memory>

+#include <mutex>

+#include <string>

+#include <unordered_map>

+

+namespace spdlog

+{

+namespace details

+{

+template <class Mutex> class registry_t

+{

+public:

+

+    void register_logger(std::shared_ptr<logger> logger)

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        auto logger_name = logger->name();

+        throw_if_exists(logger_name);

+        _loggers[logger_name] = logger;

+    }

+

+

+    std::shared_ptr<logger> get(const std::string& logger_name)

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        auto found = _loggers.find(logger_name);

+        return found == _loggers.end() ? nullptr : found->second;

+    }

+

+    template<class It>

+    std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        throw_if_exists(logger_name);

+        std::shared_ptr<logger> new_logger;

+        if (_async_mode)

+            new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb, _flush_interval_ms);

+        else

+            new_logger = std::make_shared<logger>(logger_name, sinks_begin, sinks_end);

+

+        if (_formatter)

+            new_logger->set_formatter(_formatter);

+

+        new_logger->set_level(_level);

+        //Add to registry

+        _loggers[logger_name] = new_logger;

+        return new_logger;

+    }

+

+    void drop(const std::string& logger_name)

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        _loggers.erase(logger_name);

+    }

+

+    void drop_all()

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        _loggers.clear();

+    }

+    std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks)

+    {

+        return create(logger_name, sinks.begin(), sinks.end());

+    }

+

+    std::shared_ptr<logger> create(const std::string& logger_name, sink_ptr sink)

+    {

+        return create(logger_name, { sink });

+    }

+

+

+    void formatter(formatter_ptr f)

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        _formatter = f;

+        for (auto& l : _loggers)

+            l.second->set_formatter(_formatter);

+    }

+

+    void set_pattern(const std::string& pattern)

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        _formatter = std::make_shared<pattern_formatter>(pattern);

+        for (auto& l : _loggers)

+            l.second->set_formatter(_formatter);

+    }

+

+    void set_level(level::level_enum log_level)

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        for (auto& l : _loggers)

+            l.second->set_level(log_level);

+        _level = log_level;

+    }

+

+    void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms)

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        _async_mode = true;

+        _async_q_size = q_size;

+        _overflow_policy = overflow_policy;

+        _worker_warmup_cb = worker_warmup_cb;

+        _flush_interval_ms = flush_interval_ms;

+    }

+

+    void set_sync_mode()

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        _async_mode = false;

+    }

+

+    static registry_t<Mutex>& instance()

+    {

+        static registry_t<Mutex> s_instance;

+        return s_instance;

+    }

+

+private:

+    registry_t<Mutex>() {}

+    registry_t<Mutex>(const registry_t<Mutex>&) = delete;

+    registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;

+

+    void throw_if_exists(const std::string &logger_name)

+    {

+        if (_loggers.find(logger_name) != _loggers.end())

+            throw spdlog_ex("logger with name '" + logger_name + "' already exists");

+    }

+    Mutex _mutex;

+    std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;

+    formatter_ptr _formatter;

+    level::level_enum _level = level::info;

+    bool _async_mode = false;

+    size_t _async_q_size = 0;

+    async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;

+    std::function<void()> _worker_warmup_cb = nullptr;

+    std::chrono::milliseconds _flush_interval_ms;

+};

+#ifdef SPDLOG_NO_REGISTRY_MUTEX

+typedef registry_t<spdlog::details::null_mutex> registry;

+#else

+typedef registry_t<std::mutex> registry;

+#endif

+}

+}

diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h
index 2d67774d..61c3a217 100644
--- a/include/spdlog/details/spdlog_impl.h
+++ b/include/spdlog/details/spdlog_impl.h
@@ -1,148 +1,148 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-//
-// Global registry functions
-//
-#include <spdlog/spdlog.h>
-#include <spdlog/details/registry.h>
-#include <spdlog/sinks/file_sinks.h>
-#include <spdlog/sinks/stdout_sinks.h>
-#include <spdlog/sinks/syslog_sink.h>
-#include <spdlog/sinks/ansicolor_sink.h>
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <string>
-
-inline void spdlog::register_logger(std::shared_ptr<logger> logger)
-{
-    return details::registry::instance().register_logger(logger);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::get(const std::string& name)
-{
-    return details::registry::instance().get(name);
-}
-
-inline void spdlog::drop(const std::string &name)
-{
-    details::registry::instance().drop(name);
-}
-
-// Create multi/single threaded rotating file logger
-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush)
-{
-    return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, "txt", max_file_size, max_files, force_flush);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush)
-{
-    return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, "txt", max_file_size, max_files, force_flush);
-}
-
-// Create file logger which creates new file at midnight):
-inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush)
-{
-    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, "txt", hour, minute, force_flush);
-}
-inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush)
-{
-    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", hour, minute, force_flush);
-}
-
-// Create stdout/stderr loggers (with optinal color support)
-inline std::shared_ptr<spdlog::logger> create_console_logger(const std::string& logger_name, spdlog::sink_ptr sink, bool color)
-{
-	if (color) //use color wrapper sink
-		sink = std::make_shared<spdlog::sinks::ansicolor_sink>(sink);
-	return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt(const std::string& logger_name, bool color)
-{
-	return create_console_logger(logger_name, sinks::stdout_sink_mt::instance(), color);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st(const std::string& logger_name, bool color)
-{
-	return create_console_logger(logger_name, sinks::stdout_sink_st::instance(), color);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt(const std::string& logger_name, bool color)
-{
-	return create_console_logger(logger_name, sinks::stderr_sink_mt::instance(), color);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::string& logger_name, bool color)
-{
-	return create_console_logger(logger_name, sinks::stderr_sink_st::instance(), color);
-}
-
-#if defined(__linux__) || defined(__APPLE__)
-// Create syslog logger
-inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string& logger_name, const std::string& syslog_ident, int syslog_option)
-{
-    return create<spdlog::sinks::syslog_sink>(logger_name, syslog_ident, syslog_option);
-}
-#endif
-
-
-//Create logger with multiple sinks
-
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, spdlog::sinks_init_list sinks)
-{
-    return details::registry::instance().create(logger_name, sinks);
-}
-
-
-template <typename Sink, typename... Args>
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, Args... args)
-{
-    sink_ptr sink = std::make_shared<Sink>(args...);
-    return details::registry::instance().create(logger_name, { sink });
-}
-
-
-template<class It>
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
-{
-    return details::registry::instance().create(logger_name, sinks_begin, sinks_end);
-}
-
-inline void spdlog::set_formatter(spdlog::formatter_ptr f)
-{
-    details::registry::instance().formatter(f);
-}
-
-inline void spdlog::set_pattern(const std::string& format_string)
-{
-    return details::registry::instance().set_pattern(format_string);
-}
-
-inline void spdlog::set_level(level::level_enum log_level)
-{
-    return details::registry::instance().set_level(log_level);
-}
-
-
-inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms)
-{
-    details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms);
-}
-
-inline void spdlog::set_sync_mode()
-{
-    details::registry::instance().set_sync_mode();
-}
-
-inline void spdlog::drop_all()
-{
-    details::registry::instance().drop_all();
-}
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+//

+// Global registry functions

+//

+#include <spdlog/spdlog.h>

+#include <spdlog/details/registry.h>

+#include <spdlog/sinks/file_sinks.h>

+#include <spdlog/sinks/stdout_sinks.h>

+#include <spdlog/sinks/syslog_sink.h>

+#include <spdlog/sinks/ansicolor_sink.h>

+

+#include <chrono>

+#include <functional>

+#include <memory>

+#include <string>

+

+inline void spdlog::register_logger(std::shared_ptr<logger> logger)

+{

+    return details::registry::instance().register_logger(logger);

+}

+

+inline std::shared_ptr<spdlog::logger> spdlog::get(const std::string& name)

+{

+    return details::registry::instance().get(name);

+}

+

+inline void spdlog::drop(const std::string &name)

+{

+    details::registry::instance().drop(name);

+}

+

+// Create multi/single threaded rotating file logger

+inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush)

+{

+    return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, "txt", max_file_size, max_files, force_flush);

+}

+

+inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush)

+{

+    return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, "txt", max_file_size, max_files, force_flush);

+}

+

+// Create file logger which creates new file at midnight):

+inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush)

+{

+    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, "txt", hour, minute, force_flush);

+}

+inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush)

+{

+    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", hour, minute, force_flush);

+}

+

+// Create stdout/stderr loggers (with optinal color support)

+inline std::shared_ptr<spdlog::logger> create_console_logger(const std::string& logger_name, spdlog::sink_ptr sink, bool color)

+{

+    if (color) //use color wrapper sink

+        sink = std::make_shared<spdlog::sinks::ansicolor_sink>(sink);

+    return spdlog::details::registry::instance().create(logger_name, sink);

+}

+

+inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt(const std::string& logger_name, bool color)

+{

+    return create_console_logger(logger_name, sinks::stdout_sink_mt::instance(), color);

+}

+

+inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st(const std::string& logger_name, bool color)

+{

+    return create_console_logger(logger_name, sinks::stdout_sink_st::instance(), color);

+}

+

+inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt(const std::string& logger_name, bool color)

+{

+    return create_console_logger(logger_name, sinks::stderr_sink_mt::instance(), color);

+}

+

+inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::string& logger_name, bool color)

+{

+    return create_console_logger(logger_name, sinks::stderr_sink_st::instance(), color);

+}

+

+#if defined(__linux__) || defined(__APPLE__)

+// Create syslog logger

+inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string& logger_name, const std::string& syslog_ident, int syslog_option)

+{

+    return create<spdlog::sinks::syslog_sink>(logger_name, syslog_ident, syslog_option);

+}

+#endif

+

+

+//Create logger with multiple sinks

+

+inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, spdlog::sinks_init_list sinks)

+{

+    return details::registry::instance().create(logger_name, sinks);

+}

+

+

+template <typename Sink, typename... Args>

+inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, Args... args)

+{

+    sink_ptr sink = std::make_shared<Sink>(args...);

+    return details::registry::instance().create(logger_name, { sink });

+}

+

+

+template<class It>

+inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)

+{

+    return details::registry::instance().create(logger_name, sinks_begin, sinks_end);

+}

+

+inline void spdlog::set_formatter(spdlog::formatter_ptr f)

+{

+    details::registry::instance().formatter(f);

+}

+

+inline void spdlog::set_pattern(const std::string& format_string)

+{

+    return details::registry::instance().set_pattern(format_string);

+}

+

+inline void spdlog::set_level(level::level_enum log_level)

+{

+    return details::registry::instance().set_level(log_level);

+}

+

+

+inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms)

+{

+    details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms);

+}

+

+inline void spdlog::set_sync_mode()

+{

+    details::registry::instance().set_sync_mode();

+}

+

+inline void spdlog::drop_all()

+{

+    details::registry::instance().drop_all();

+}

+

diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h
index 0ffcec03..ffbc7eb2 100644
--- a/include/spdlog/formatter.h
+++ b/include/spdlog/formatter.h
@@ -1,45 +1,45 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/details/log_msg.h>
-
-#include <vector>
-#include <string>
-#include <memory>
-
-namespace spdlog
-{
-namespace details
-{
-class flag_formatter;
-}
-
-class formatter
-{
-public:
-    virtual ~formatter() {}
-    virtual void format(details::log_msg& msg) = 0;
-};
-
-class pattern_formatter : public formatter
-{
-
-public:
-    explicit pattern_formatter(const std::string& pattern);
-    pattern_formatter(const pattern_formatter&) = delete;
-    pattern_formatter& operator=(const pattern_formatter&) = delete;
-    void format(details::log_msg& msg) override;
-private:
-    const std::string _pattern;
-    std::vector<std::unique_ptr<details::flag_formatter>> _formatters;
-    void handle_flag(char flag);
-    void compile_pattern(const std::string& pattern);
-};
-}
-
-#include <spdlog/details/pattern_formatter_impl.h>
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/details/log_msg.h>

+

+#include <vector>

+#include <string>

+#include <memory>

+

+namespace spdlog

+{

+namespace details

+{

+class flag_formatter;

+}

+

+class formatter

+{

+public:

+    virtual ~formatter() {}

+    virtual void format(details::log_msg& msg) = 0;

+};

+

+class pattern_formatter : public formatter

+{

+

+public:

+    explicit pattern_formatter(const std::string& pattern);

+    pattern_formatter(const pattern_formatter&) = delete;

+    pattern_formatter& operator=(const pattern_formatter&) = delete;

+    void format(details::log_msg& msg) override;

+private:

+    const std::string _pattern;

+    std::vector<std::unique_ptr<details::flag_formatter>> _formatters;

+    void handle_flag(char flag);

+    void compile_pattern(const std::string& pattern);

+};

+}

+

+#include <spdlog/details/pattern_formatter_impl.h>

+

diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h
index ebd2dd06..e90090f0 100644
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -1,114 +1,114 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Thread safe logger
-// Has name, log level, vector of std::shared sink pointers and formatter
-// Upon each log write the logger:
-// 1. Checks if its log level is enough to log the message
-// 2. Format the message using the formatter function
-// 3. Pass the formatted message to its sinks to performa the actual logging
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/common.h>
-#include <spdlog/details/line_logger_fwd.h>
-
-#include <vector>
-#include <memory>
-#include <atomic>
-#include <string>
-
-namespace spdlog
-{
-
-class logger
-{
-public:
-    logger(const std::string& logger_name, sink_ptr single_sink);
-    logger(const std::string& name, sinks_init_list);
-    template<class It>
-    logger(const std::string& name, const It& begin, const It& end);
-
-    virtual ~logger();
-    logger(const logger&) = delete;
-    logger& operator=(const logger&) = delete;
-
-    void set_level(level::level_enum);
-    level::level_enum level() const;
-
-    const std::string& name() const;
-    bool should_log(level::level_enum) const;
-
-    // logger.info(cppformat_string, arg1, arg2, arg3, ...) call style
-    template <typename... Args> details::line_logger trace(const char* fmt, const Args&... args);
-    template <typename... Args> details::line_logger debug(const char* fmt, const Args&... args);
-    template <typename... Args> details::line_logger info(const char* fmt, const Args&... args);
-    template <typename... Args> details::line_logger notice(const char* fmt, const Args&... args);
-    template <typename... Args> details::line_logger warn(const char* fmt, const Args&... args);
-    template <typename... Args> details::line_logger error(const char* fmt, const Args&... args);
-    template <typename... Args> details::line_logger critical(const char* fmt, const Args&... args);
-    template <typename... Args> details::line_logger alert(const char* fmt, const Args&... args);
-    template <typename... Args> details::line_logger emerg(const char* fmt, const Args&... args);
-
-
-    // logger.info(msg) << ".." call style
-    template <typename T> details::line_logger trace(const T&);
-    template <typename T> details::line_logger debug(const T&);
-    template <typename T> details::line_logger info(const T&);
-    template <typename T> details::line_logger notice(const T&);
-    template <typename T> details::line_logger warn(const T&);
-    template <typename T> details::line_logger error(const T&);
-    template <typename T> details::line_logger critical(const T&);
-    template <typename T> details::line_logger alert(const T&);
-    template <typename T> details::line_logger emerg(const T&);
-
-
-    // logger.info() << ".." call  style
-    details::line_logger trace();
-    details::line_logger debug();
-    details::line_logger info();
-    details::line_logger notice();
-    details::line_logger warn();
-    details::line_logger error();
-    details::line_logger critical();
-    details::line_logger alert();
-    details::line_logger emerg();
-
-
-
-    // Create log message with the given level, no matter what is the actual logger's level
-    template <typename... Args>
-    details::line_logger force_log(level::level_enum lvl, const char* fmt, const Args&... args);
-
-    // Set the format of the log messages from this logger
-    void set_pattern(const std::string&);
-    void set_formatter(formatter_ptr);
-
-    virtual void flush();
-
-protected:
-    virtual void _log_msg(details::log_msg&);
-    virtual void _set_pattern(const std::string&);
-    virtual void _set_formatter(formatter_ptr);
-    details::line_logger _log_if_enabled(level::level_enum lvl);
-    template <typename... Args>
-    details::line_logger _log_if_enabled(level::level_enum lvl, const char* fmt, const Args&... args);
-    template<typename T>
-    inline details::line_logger _log_if_enabled(level::level_enum lvl, const T& msg);
-
-
-    friend details::line_logger;
-    std::string _name;
-    std::vector<sink_ptr> _sinks;
-    formatter_ptr _formatter;
-    std::atomic_int _level;
-
-};
-}
-
-#include <spdlog/details/logger_impl.h>
-#include <spdlog/details/line_logger_impl.h>
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+// Thread safe logger

+// Has name, log level, vector of std::shared sink pointers and formatter

+// Upon each log write the logger:

+// 1. Checks if its log level is enough to log the message

+// 2. Format the message using the formatter function

+// 3. Pass the formatted message to its sinks to performa the actual logging

+

+#include <spdlog/sinks/base_sink.h>

+#include <spdlog/common.h>

+#include <spdlog/details/line_logger_fwd.h>

+

+#include <vector>

+#include <memory>

+#include <atomic>

+#include <string>

+

+namespace spdlog

+{

+

+class logger

+{

+public:

+    logger(const std::string& logger_name, sink_ptr single_sink);

+    logger(const std::string& name, sinks_init_list);

+    template<class It>

+    logger(const std::string& name, const It& begin, const It& end);

+

+    virtual ~logger();

+    logger(const logger&) = delete;

+    logger& operator=(const logger&) = delete;

+

+    void set_level(level::level_enum);

+    level::level_enum level() const;

+

+    const std::string& name() const;

+    bool should_log(level::level_enum) const;

+

+    // logger.info(cppformat_string, arg1, arg2, arg3, ...) call style

+    template <typename... Args> details::line_logger trace(const char* fmt, const Args&... args);

+    template <typename... Args> details::line_logger debug(const char* fmt, const Args&... args);

+    template <typename... Args> details::line_logger info(const char* fmt, const Args&... args);

+    template <typename... Args> details::line_logger notice(const char* fmt, const Args&... args);

+    template <typename... Args> details::line_logger warn(const char* fmt, const Args&... args);

+    template <typename... Args> details::line_logger error(const char* fmt, const Args&... args);

+    template <typename... Args> details::line_logger critical(const char* fmt, const Args&... args);

+    template <typename... Args> details::line_logger alert(const char* fmt, const Args&... args);

+    template <typename... Args> details::line_logger emerg(const char* fmt, const Args&... args);

+

+

+    // logger.info(msg) << ".." call style

+    template <typename T> details::line_logger trace(const T&);

+    template <typename T> details::line_logger debug(const T&);

+    template <typename T> details::line_logger info(const T&);

+    template <typename T> details::line_logger notice(const T&);

+    template <typename T> details::line_logger warn(const T&);

+    template <typename T> details::line_logger error(const T&);

+    template <typename T> details::line_logger critical(const T&);

+    template <typename T> details::line_logger alert(const T&);

+    template <typename T> details::line_logger emerg(const T&);

+

+

+    // logger.info() << ".." call  style

+    details::line_logger trace();

+    details::line_logger debug();

+    details::line_logger info();

+    details::line_logger notice();

+    details::line_logger warn();

+    details::line_logger error();

+    details::line_logger critical();

+    details::line_logger alert();

+    details::line_logger emerg();

+

+

+

+    // Create log message with the given level, no matter what is the actual logger's level

+    template <typename... Args>

+    details::line_logger force_log(level::level_enum lvl, const char* fmt, const Args&... args);

+

+    // Set the format of the log messages from this logger

+    void set_pattern(const std::string&);

+    void set_formatter(formatter_ptr);

+

+    virtual void flush();

+

+protected:

+    virtual void _log_msg(details::log_msg&);

+    virtual void _set_pattern(const std::string&);

+    virtual void _set_formatter(formatter_ptr);

+    details::line_logger _log_if_enabled(level::level_enum lvl);

+    template <typename... Args>

+    details::line_logger _log_if_enabled(level::level_enum lvl, const char* fmt, const Args&... args);

+    template<typename T>

+    inline details::line_logger _log_if_enabled(level::level_enum lvl, const T& msg);

+

+

+    friend details::line_logger;

+    std::string _name;

+    std::vector<sink_ptr> _sinks;

+    formatter_ptr _formatter;

+    std::atomic_int _level;

+

+};

+}

+

+#include <spdlog/details/logger_impl.h>

+#include <spdlog/details/line_logger_impl.h>

+

diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h
index 885f78da..dcfa962c 100644
--- a/include/spdlog/sinks/android_sink.h
+++ b/include/spdlog/sinks/android_sink.h
@@ -1,92 +1,92 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#if defined(__ANDROID__)
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-
-#include <android/log.h>
-
-#include <mutex>
-#include <string>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
-* Android sink (logging using __android_log_write)
-*/
-template<class Mutex>
-class base_android_sink : public base_sink < Mutex >
-{
-public:
-    explicit base_android_sink(std::string tag="spdlog"): _tag(tag)
-    {
-    }
-
-    void flush() override
-    {
-    }
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        const android_LogPriority priority = convert_to_android(msg.level);
-        const int expected_size = msg.formatted.size();
-        const int size = __android_log_write(
-                             priority, _tag.c_str(), msg.formatted.c_str()
-                         );
-        if (size > expected_size)
-        {
-            // Will write a little bit more than original message
-        }
-        else
-        {
-            throw spdlog_ex("Send to Android logcat failed");
-        }
-    }
-
-private:
-    static android_LogPriority convert_to_android(spdlog::level::level_enum level)
-    {
-        switch(level)
-        {
-        case spdlog::level::trace:
-            return ANDROID_LOG_VERBOSE;
-        case spdlog::level::debug:
-            return ANDROID_LOG_DEBUG;
-        case spdlog::level::info:
-            return ANDROID_LOG_INFO;
-        case spdlog::level::notice:
-            return ANDROID_LOG_INFO;
-        case spdlog::level::warn:
-            return ANDROID_LOG_WARN;
-        case spdlog::level::err:
-            return ANDROID_LOG_ERROR;
-        case spdlog::level::critical:
-            return ANDROID_LOG_FATAL;
-        case spdlog::level::alert:
-            return ANDROID_LOG_FATAL;
-        case spdlog::level::emerg:
-            return ANDROID_LOG_FATAL;
-        default:
-            throw spdlog_ex("Incorrect level value");
-        }
-    }
-
-    std::string _tag;
-};
-
-typedef base_android_sink<std::mutex> android_sink_mt;
-typedef base_android_sink<details::null_mutex> android_sink_st;
-
-}
-}
-
-#endif
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#if defined(__ANDROID__)

+

+#include <spdlog/sinks/base_sink.h>

+#include <spdlog/details/null_mutex.h>

+

+#include <android/log.h>

+

+#include <mutex>

+#include <string>

+

+namespace spdlog

+{

+namespace sinks

+{

+/*

+* Android sink (logging using __android_log_write)

+*/

+template<class Mutex>

+class base_android_sink : public base_sink < Mutex >

+{

+public:

+    explicit base_android_sink(std::string tag="spdlog"): _tag(tag)

+    {

+    }

+

+    void flush() override

+    {

+    }

+

+protected:

+    void _sink_it(const details::log_msg& msg) override

+    {

+        const android_LogPriority priority = convert_to_android(msg.level);

+        const int expected_size = msg.formatted.size();

+        const int size = __android_log_write(

+                             priority, _tag.c_str(), msg.formatted.c_str()

+                         );

+        if (size > expected_size)

+        {

+            // Will write a little bit more than original message

+        }

+        else

+        {

+            throw spdlog_ex("Send to Android logcat failed");

+        }

+    }

+

+private:

+    static android_LogPriority convert_to_android(spdlog::level::level_enum level)

+    {

+        switch(level)

+        {

+        case spdlog::level::trace:

+            return ANDROID_LOG_VERBOSE;

+        case spdlog::level::debug:

+            return ANDROID_LOG_DEBUG;

+        case spdlog::level::info:

+            return ANDROID_LOG_INFO;

+        case spdlog::level::notice:

+            return ANDROID_LOG_INFO;

+        case spdlog::level::warn:

+            return ANDROID_LOG_WARN;

+        case spdlog::level::err:

+            return ANDROID_LOG_ERROR;

+        case spdlog::level::critical:

+            return ANDROID_LOG_FATAL;

+        case spdlog::level::alert:

+            return ANDROID_LOG_FATAL;

+        case spdlog::level::emerg:

+            return ANDROID_LOG_FATAL;

+        default:

+            throw spdlog_ex("Incorrect level value");

+        }

+    }

+

+    std::string _tag;

+};

+

+typedef base_android_sink<std::mutex> android_sink_mt;

+typedef base_android_sink<details::null_mutex> android_sink_st;

+

+}

+}

+

+#endif

diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h
index 0c09a205..aa4b93bf 100644
--- a/include/spdlog/sinks/ansicolor_sink.h
+++ b/include/spdlog/sinks/ansicolor_sink.h
@@ -1,112 +1,115 @@
-//
-// Copyright(c) 2016 Kevin M. Godby (a modified version by spdlog).
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/common.h>
-
-#include <string>
-#include <map>
-
-namespace spdlog {
-namespace sinks {
-
-/**
- * @brief The ansi_color_sink is a decorator around another sink and prefixes
- * the output with an ANSI escape sequence color code depending on the severity
- * of the message.
- */
-class ansicolor_sink : public sink {
-public:
-    ansicolor_sink(sink_ptr wrapped_sink);
-    virtual ~ansicolor_sink();
-
-    ansicolor_sink(const ansicolor_sink& other) = delete;
-    ansicolor_sink& operator=(const ansicolor_sink& other) = delete;
-
-    virtual void log(const details::log_msg& msg) override;
-    virtual void flush() override;
-
-    void set_color(level::level_enum level, const std::string& color);
-
-    /// Formatting codes    
-    const std::string reset      = "\033[00m";
-    const std::string bold       = "\033[1m";
-    const std::string dark       = "\033[2m";
-    const std::string underline  = "\033[4m";
-    const std::string blink      = "\033[5m";
-    const std::string reverse    = "\033[7m";
-    const std::string concealed  = "\033[8m";
-    
-    // Foreground colors    
-    const std::string grey       = "\033[30m";
-    const std::string red        = "\033[31m";
-    const std::string green      = "\033[32m";
-    const std::string yellow     = "\033[33m";
-    const std::string blue       = "\033[34m";
-    const std::string magenta    = "\033[35m";
-    const std::string cyan       = "\033[36m";
-    const std::string white      = "\033[37m";
-    
-    /// Background colors    
-    const std::string on_grey    = "\033[40m";
-    const std::string on_red     = "\033[41m";
-    const std::string on_green   = "\033[42m";
-    const std::string on_yellow  = "\033[43m";
-    const std::string on_blue    = "\033[44m";
-    const std::string on_magenta = "\033[45m";
-    const std::string on_cyan    = "\033[46m";
-    const std::string on_white   = "\033[47m";
-    
-
-protected:
-    sink_ptr sink_;
-    std::map<level::level_enum, std::string> colors_;
-};
-
-inline ansicolor_sink::ansicolor_sink(sink_ptr wrapped_sink) : sink_(wrapped_sink)
-{
-    colors_[level::trace]    = cyan;
-    colors_[level::debug]    = cyan;
-    colors_[level::info]     = white;
-    colors_[level::notice]   = bold + white;
-    colors_[level::warn]     = bold + yellow;
-    colors_[level::err]      = red;
-    colors_[level::critical] = bold + red;
-    colors_[level::alert]    = bold + white + on_red;
-    colors_[level::emerg]    = bold + yellow + on_red;
-    colors_[level::off]      = reset;
-}
-
-inline void ansicolor_sink::log(const details::log_msg& msg)
-{
-    // Wrap the originally formatted message in color codes
-    const std::string& prefix = colors_[msg.level];
-    const std::string& s = msg.formatted.str();
-    const std::string& suffix = reset;
-    details::log_msg m;
-    m.formatted << prefix  << s << suffix;
-    sink_->log(m);
-}
-
-inline void ansicolor_sink::flush()
-{
-    sink_->flush();
-}
-
-inline void ansicolor_sink::set_color(level::level_enum level, const std::string& color)
-{
-    colors_[level] = color;
-}
-
-inline ansicolor_sink::~ansicolor_sink()
-{
-	flush();
-}
-
-} // namespace sinks
-} // namespace spdlog
-
+//

+// Copyright(c) 2016 Kevin M. Godby (a modified version by spdlog).

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/sinks/base_sink.h>

+#include <spdlog/common.h>

+

+#include <string>

+#include <map>

+

+namespace spdlog

+{

+namespace sinks

+{

+

+/**

+ * @brief The ansi_color_sink is a decorator around another sink and prefixes

+ * the output with an ANSI escape sequence color code depending on the severity

+ * of the message.

+ */

+class ansicolor_sink : public sink

+{

+public:

+    ansicolor_sink(sink_ptr wrapped_sink);

+    virtual ~ansicolor_sink();

+

+    ansicolor_sink(const ansicolor_sink& other) = delete;

+    ansicolor_sink& operator=(const ansicolor_sink& other) = delete;

+

+    virtual void log(const details::log_msg& msg) override;

+    virtual void flush() override;

+

+    void set_color(level::level_enum level, const std::string& color);

+

+    /// Formatting codes

+    const std::string reset      = "\033[00m";

+    const std::string bold       = "\033[1m";

+    const std::string dark       = "\033[2m";

+    const std::string underline  = "\033[4m";

+    const std::string blink      = "\033[5m";

+    const std::string reverse    = "\033[7m";

+    const std::string concealed  = "\033[8m";

+

+    // Foreground colors

+    const std::string grey       = "\033[30m";

+    const std::string red        = "\033[31m";

+    const std::string green      = "\033[32m";

+    const std::string yellow     = "\033[33m";

+    const std::string blue       = "\033[34m";

+    const std::string magenta    = "\033[35m";

+    const std::string cyan       = "\033[36m";

+    const std::string white      = "\033[37m";

+

+    /// Background colors

+    const std::string on_grey    = "\033[40m";

+    const std::string on_red     = "\033[41m";

+    const std::string on_green   = "\033[42m";

+    const std::string on_yellow  = "\033[43m";

+    const std::string on_blue    = "\033[44m";

+    const std::string on_magenta = "\033[45m";

+    const std::string on_cyan    = "\033[46m";

+    const std::string on_white   = "\033[47m";

+

+

+protected:

+    sink_ptr sink_;

+    std::map<level::level_enum, std::string> colors_;

+};

+

+inline ansicolor_sink::ansicolor_sink(sink_ptr wrapped_sink) : sink_(wrapped_sink)

+{

+    colors_[level::trace]    = cyan;

+    colors_[level::debug]    = cyan;

+    colors_[level::info]     = white;

+    colors_[level::notice]   = bold + white;

+    colors_[level::warn]     = bold + yellow;

+    colors_[level::err]      = red;

+    colors_[level::critical] = bold + red;

+    colors_[level::alert]    = bold + white + on_red;

+    colors_[level::emerg]    = bold + yellow + on_red;

+    colors_[level::off]      = reset;

+}

+

+inline void ansicolor_sink::log(const details::log_msg& msg)

+{

+    // Wrap the originally formatted message in color codes

+    const std::string& prefix = colors_[msg.level];

+    const std::string& s = msg.formatted.str();

+    const std::string& suffix = reset;

+    details::log_msg m;

+    m.formatted << prefix  << s << suffix;

+    sink_->log(m);

+}

+

+inline void ansicolor_sink::flush()

+{

+    sink_->flush();

+}

+

+inline void ansicolor_sink::set_color(level::level_enum level, const std::string& color)

+{

+    colors_[level] = color;

+}

+

+inline ansicolor_sink::~ansicolor_sink()

+{

+    flush();

+}

+

+} // namespace sinks

+} // namespace spdlog

+

diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h
index 615bb6f0..060b6f75 100644
--- a/include/spdlog/sinks/base_sink.h
+++ b/include/spdlog/sinks/base_sink.h
@@ -1,45 +1,45 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-//
-// base sink templated over a mutex (either dummy or realy)
-// concrete implementation should only overrid the _sink_it method.
-// all locking is taken care of here so no locking needed by the implementors..
-//
-
-#include <spdlog/sinks/sink.h>
-#include <spdlog/formatter.h>
-#include <spdlog/common.h>
-#include <spdlog/details/log_msg.h>
-
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class base_sink:public sink
-{
-public:
-    base_sink():_mutex() {}
-    virtual ~base_sink() = default;
-
-    base_sink(const base_sink&) = delete;
-    base_sink& operator=(const base_sink&) = delete;
-
-    void log(const details::log_msg& msg) override
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _sink_it(msg);
-    }
-
-protected:
-    virtual void _sink_it(const details::log_msg& msg) = 0;
-    Mutex _mutex;
-};
-}
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+//

+// base sink templated over a mutex (either dummy or realy)

+// concrete implementation should only overrid the _sink_it method.

+// all locking is taken care of here so no locking needed by the implementors..

+//

+

+#include <spdlog/sinks/sink.h>

+#include <spdlog/formatter.h>

+#include <spdlog/common.h>

+#include <spdlog/details/log_msg.h>

+

+#include <mutex>

+

+namespace spdlog

+{

+namespace sinks

+{

+template<class Mutex>

+class base_sink:public sink

+{

+public:

+    base_sink():_mutex() {}

+    virtual ~base_sink() = default;

+

+    base_sink(const base_sink&) = delete;

+    base_sink& operator=(const base_sink&) = delete;

+

+    void log(const details::log_msg& msg) override

+    {

+        std::lock_guard<Mutex> lock(_mutex);

+        _sink_it(msg);

+    }

+

+protected:

+    virtual void _sink_it(const details::log_msg& msg) = 0;

+    Mutex _mutex;

+};

+}

+}

diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h
index 0e7cfc1e..8ebc3bc6 100644
--- a/include/spdlog/sinks/dist_sink.h
+++ b/include/spdlog/sinks/dist_sink.h
@@ -1,72 +1,72 @@
-//
-// Copyright (c) 2015 David Schury, Gabi Melman
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/details/log_msg.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/sinks/sink.h>
-
-#include <algorithm>
-#include <memory>
-#include <mutex>
-#include <vector>
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class dist_sink: public base_sink<Mutex>
-{
-public:
-    explicit dist_sink() :_sinks() {}
-    dist_sink(const dist_sink&) = delete;
-    dist_sink& operator=(const dist_sink&) = delete;
-    virtual ~dist_sink() = default;
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        for (auto iter = _sinks.begin(); iter != _sinks.end(); iter++)
-            (*iter)->log(msg);
-    }
-
-    std::vector<std::shared_ptr<sink>> _sinks;
-
-public:
-    void flush() override
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        for (auto iter = _sinks.begin(); iter != _sinks.end(); iter++)
-            (*iter)->flush();
-    }
-
-    void add_sink(std::shared_ptr<sink> sink)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        if (sink &&
-                _sinks.end() == std::find(_sinks.begin(), _sinks.end(), sink))
-        {
-            _sinks.push_back(sink);
-        }
-    }
-
-    void remove_sink(std::shared_ptr<sink> sink)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        auto pos = std::find(_sinks.begin(), _sinks.end(), sink);
-        if (pos != _sinks.end())
-        {
-            _sinks.erase(pos);
-        }
-    }
-};
-
-typedef dist_sink<std::mutex> dist_sink_mt;
-typedef dist_sink<details::null_mutex> dist_sink_st;
-}
-}
+//

+// Copyright (c) 2015 David Schury, Gabi Melman

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/details/log_msg.h>

+#include <spdlog/details/null_mutex.h>

+#include <spdlog/sinks/base_sink.h>

+#include <spdlog/sinks/sink.h>

+

+#include <algorithm>

+#include <memory>

+#include <mutex>

+#include <vector>

+

+namespace spdlog

+{

+namespace sinks

+{

+template<class Mutex>

+class dist_sink: public base_sink<Mutex>

+{

+public:

+    explicit dist_sink() :_sinks() {}

+    dist_sink(const dist_sink&) = delete;

+    dist_sink& operator=(const dist_sink&) = delete;

+    virtual ~dist_sink() = default;

+

+protected:

+    void _sink_it(const details::log_msg& msg) override

+    {

+        for (auto iter = _sinks.begin(); iter != _sinks.end(); iter++)

+            (*iter)->log(msg);

+    }

+

+    std::vector<std::shared_ptr<sink>> _sinks;

+

+public:

+    void flush() override

+    {

+        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);

+        for (auto iter = _sinks.begin(); iter != _sinks.end(); iter++)

+            (*iter)->flush();

+    }

+

+    void add_sink(std::shared_ptr<sink> sink)

+    {

+        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);

+        if (sink &&

+                _sinks.end() == std::find(_sinks.begin(), _sinks.end(), sink))

+        {

+            _sinks.push_back(sink);

+        }

+    }

+

+    void remove_sink(std::shared_ptr<sink> sink)

+    {

+        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);

+        auto pos = std::find(_sinks.begin(), _sinks.end(), sink);

+        if (pos != _sinks.end())

+        {

+            _sinks.erase(pos);

+        }

+    }

+};

+

+typedef dist_sink<std::mutex> dist_sink_mt;

+typedef dist_sink<details::null_mutex> dist_sink_st;

+}

+}

diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index c3d214fa..d5932951 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -1,220 +1,220 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/details/file_helper.h>
-#include <spdlog/details/format.h>
-
-#include <algorithm>
-#include <chrono>
-#include <cstdio>
-#include <ctime>
-#include <mutex>
-#include <string>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
-* Trivial file sink with single file as target
-*/
-template<class Mutex>
-class simple_file_sink : public base_sink < Mutex >
-{
-public:
-    explicit simple_file_sink(const std::string &filename,
-                              bool force_flush = false) :
-        _file_helper(force_flush)
-    {
-        _file_helper.open(filename);
-    }
-    void flush() override
-    {
-        _file_helper.flush();
-    }
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        _file_helper.write(msg);
-    }
-private:
-    details::file_helper _file_helper;
-};
-
-typedef simple_file_sink<std::mutex> simple_file_sink_mt;
-typedef simple_file_sink<details::null_mutex> simple_file_sink_st;
-
-/*
-* Rotating file sink based on size
-*/
-template<class Mutex>
-class rotating_file_sink : public base_sink < Mutex >
-{
-public:
-    rotating_file_sink(const std::string &base_filename, const std::string &extension,
-                       std::size_t max_size, std::size_t max_files,
-                       bool force_flush = false) :
-        _base_filename(base_filename),
-        _extension(extension),
-        _max_size(max_size),
-        _max_files(max_files),
-        _current_size(0),
-        _file_helper(force_flush)
-    {
-        _file_helper.open(calc_filename(_base_filename, 0, _extension));
-        _current_size = _file_helper.size(); //expensive. called only once
-    }
-
-    void flush() override
-    {
-        _file_helper.flush();
-    }
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        _current_size += msg.formatted.size();
-        if (_current_size > _max_size)
-        {
-            _rotate();
-            _current_size = msg.formatted.size();
-        }
-        _file_helper.write(msg);
-    }
-
-private:
-    static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
-    {
-        fmt::MemoryWriter w;
-        if (index)
-            w.write("{}.{}.{}", filename, index, extension);
-        else
-            w.write("{}.{}", filename, extension);
-        return w.str();
-    }
-
-    // Rotate files:
-    // log.txt -> log.1.txt
-    // log.1.txt -> log2.txt
-    // log.2.txt -> log3.txt
-    // log.3.txt -> delete
-
-    void _rotate()
-    {
-        _file_helper.close();
-        for (auto i = _max_files; i > 0; --i)
-        {
-            std::string src = calc_filename(_base_filename, i - 1, _extension);
-            std::string target = calc_filename(_base_filename, i, _extension);
-
-            if (details::file_helper::file_exists(target))
-            {
-                if (std::remove(target.c_str()) != 0)
-                {
-                    throw spdlog_ex("rotating_file_sink: failed removing " + target);
-                }
-            }
-            if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str()))
-            {
-                throw spdlog_ex("rotating_file_sink: failed renaming " + src + " to " + target);
-            }
-        }
-        _file_helper.reopen(true);
-    }
-    std::string _base_filename;
-    std::string _extension;
-    std::size_t _max_size;
-    std::size_t _max_files;
-    std::size_t _current_size;
-    details::file_helper _file_helper;
-};
-
-typedef rotating_file_sink<std::mutex> rotating_file_sink_mt;
-typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;
-
-/*
-* Rotating file sink based on date. rotates at midnight
-*/
-template<class Mutex>
-class daily_file_sink :public base_sink < Mutex >
-{
-public:
-    //create daily file sink which rotates on given time
-    daily_file_sink(
-        const std::string& base_filename,
-        const std::string& extension,
-        int rotation_hour,
-        int rotation_minute,
-        bool force_flush = false) : _base_filename(base_filename),
-        _extension(extension),
-        _rotation_h(rotation_hour),
-        _rotation_m(rotation_minute),
-        _file_helper(force_flush)
-    {
-        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
-            throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
-        _rotation_tp = _next_rotation_tp();
-        _file_helper.open(calc_filename(_base_filename, _extension));
-    }
-
-    void flush() override
-    {
-        _file_helper.flush();
-    }
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        if (std::chrono::system_clock::now() >= _rotation_tp)
-        {
-            _file_helper.open(calc_filename(_base_filename, _extension));
-            _rotation_tp = _next_rotation_tp();
-        }
-        _file_helper.write(msg);
-    }
-
-private:
-    std::chrono::system_clock::time_point _next_rotation_tp()
-    {
-        using namespace std::chrono;
-        auto now = system_clock::now();
-        time_t tnow = std::chrono::system_clock::to_time_t(now);
-        tm date = spdlog::details::os::localtime(tnow);
-        date.tm_hour = _rotation_h;
-        date.tm_min = _rotation_m;
-        date.tm_sec = 0;
-        auto rotation_time = std::chrono::system_clock::from_time_t(std::mktime(&date));
-        if (rotation_time > now)
-            return rotation_time;
-        else
-            return system_clock::time_point(rotation_time + hours(24));
-    }
-
-    //Create filename for the form basename.YYYY-MM-DD.extension
-    static std::string calc_filename(const std::string& basename, const std::string& extension)
-    {
-        std::tm tm = spdlog::details::os::localtime();
-        fmt::MemoryWriter w;
-        w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension);
-        return w.str();
-    }
-
-    std::string _base_filename;
-    std::string _extension;
-    int _rotation_h;
-    int _rotation_m;
-    std::chrono::system_clock::time_point _rotation_tp;
-    details::file_helper _file_helper;
-};
-
-typedef daily_file_sink<std::mutex> daily_file_sink_mt;
-typedef daily_file_sink<details::null_mutex> daily_file_sink_st;
-}
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/sinks/base_sink.h>

+#include <spdlog/details/null_mutex.h>

+#include <spdlog/details/file_helper.h>

+#include <spdlog/details/format.h>

+

+#include <algorithm>

+#include <chrono>

+#include <cstdio>

+#include <ctime>

+#include <mutex>

+#include <string>

+

+namespace spdlog

+{

+namespace sinks

+{

+/*

+* Trivial file sink with single file as target

+*/

+template<class Mutex>

+class simple_file_sink : public base_sink < Mutex >

+{

+public:

+    explicit simple_file_sink(const std::string &filename,

+                              bool force_flush = false) :

+        _file_helper(force_flush)

+    {

+        _file_helper.open(filename);

+    }

+    void flush() override

+    {

+        _file_helper.flush();

+    }

+

+protected:

+    void _sink_it(const details::log_msg& msg) override

+    {

+        _file_helper.write(msg);

+    }

+private:

+    details::file_helper _file_helper;

+};

+

+typedef simple_file_sink<std::mutex> simple_file_sink_mt;

+typedef simple_file_sink<details::null_mutex> simple_file_sink_st;

+

+/*

+* Rotating file sink based on size

+*/

+template<class Mutex>

+class rotating_file_sink : public base_sink < Mutex >

+{

+public:

+    rotating_file_sink(const std::string &base_filename, const std::string &extension,

+                       std::size_t max_size, std::size_t max_files,

+                       bool force_flush = false) :

+        _base_filename(base_filename),

+        _extension(extension),

+        _max_size(max_size),

+        _max_files(max_files),

+        _current_size(0),

+        _file_helper(force_flush)

+    {

+        _file_helper.open(calc_filename(_base_filename, 0, _extension));

+        _current_size = _file_helper.size(); //expensive. called only once

+    }

+

+    void flush() override

+    {

+        _file_helper.flush();

+    }

+

+protected:

+    void _sink_it(const details::log_msg& msg) override

+    {

+        _current_size += msg.formatted.size();

+        if (_current_size > _max_size)

+        {

+            _rotate();

+            _current_size = msg.formatted.size();

+        }

+        _file_helper.write(msg);

+    }

+

+private:

+    static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension)

+    {

+        fmt::MemoryWriter w;

+        if (index)

+            w.write("{}.{}.{}", filename, index, extension);

+        else

+            w.write("{}.{}", filename, extension);

+        return w.str();

+    }

+

+    // Rotate files:

+    // log.txt -> log.1.txt

+    // log.1.txt -> log2.txt

+    // log.2.txt -> log3.txt

+    // log.3.txt -> delete

+

+    void _rotate()

+    {

+        _file_helper.close();

+        for (auto i = _max_files; i > 0; --i)

+        {

+            std::string src = calc_filename(_base_filename, i - 1, _extension);

+            std::string target = calc_filename(_base_filename, i, _extension);

+

+            if (details::file_helper::file_exists(target))

+            {

+                if (std::remove(target.c_str()) != 0)

+                {

+                    throw spdlog_ex("rotating_file_sink: failed removing " + target);

+                }

+            }

+            if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str()))

+            {

+                throw spdlog_ex("rotating_file_sink: failed renaming " + src + " to " + target);

+            }

+        }

+        _file_helper.reopen(true);

+    }

+    std::string _base_filename;

+    std::string _extension;

+    std::size_t _max_size;

+    std::size_t _max_files;

+    std::size_t _current_size;

+    details::file_helper _file_helper;

+};

+

+typedef rotating_file_sink<std::mutex> rotating_file_sink_mt;

+typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;

+

+/*

+* Rotating file sink based on date. rotates at midnight

+*/

+template<class Mutex>

+class daily_file_sink :public base_sink < Mutex >

+{

+public:

+    //create daily file sink which rotates on given time

+    daily_file_sink(

+        const std::string& base_filename,

+        const std::string& extension,

+        int rotation_hour,

+        int rotation_minute,

+        bool force_flush = false) : _base_filename(base_filename),

+        _extension(extension),

+        _rotation_h(rotation_hour),

+        _rotation_m(rotation_minute),

+        _file_helper(force_flush)

+    {

+        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)

+            throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");

+        _rotation_tp = _next_rotation_tp();

+        _file_helper.open(calc_filename(_base_filename, _extension));

+    }

+

+    void flush() override

+    {

+        _file_helper.flush();

+    }

+

+protected:

+    void _sink_it(const details::log_msg& msg) override

+    {

+        if (std::chrono::system_clock::now() >= _rotation_tp)

+        {

+            _file_helper.open(calc_filename(_base_filename, _extension));

+            _rotation_tp = _next_rotation_tp();

+        }

+        _file_helper.write(msg);

+    }

+

+private:

+    std::chrono::system_clock::time_point _next_rotation_tp()

+    {

+        using namespace std::chrono;

+        auto now = system_clock::now();

+        time_t tnow = std::chrono::system_clock::to_time_t(now);

+        tm date = spdlog::details::os::localtime(tnow);

+        date.tm_hour = _rotation_h;

+        date.tm_min = _rotation_m;

+        date.tm_sec = 0;

+        auto rotation_time = std::chrono::system_clock::from_time_t(std::mktime(&date));

+        if (rotation_time > now)

+            return rotation_time;

+        else

+            return system_clock::time_point(rotation_time + hours(24));

+    }

+

+    //Create filename for the form basename.YYYY-MM-DD.extension

+    static std::string calc_filename(const std::string& basename, const std::string& extension)

+    {

+        std::tm tm = spdlog::details::os::localtime();

+        fmt::MemoryWriter w;

+        w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension);

+        return w.str();

+    }

+

+    std::string _base_filename;

+    std::string _extension;

+    int _rotation_h;

+    int _rotation_m;

+    std::chrono::system_clock::time_point _rotation_tp;

+    details::file_helper _file_helper;

+};

+

+typedef daily_file_sink<std::mutex> daily_file_sink_mt;

+typedef daily_file_sink<details::null_mutex> daily_file_sink_st;

+}

+}

diff --git a/include/spdlog/sinks/msvc_sink.h b/include/spdlog/sinks/msvc_sink.h
index 9e101ad6..2d96f4c7 100644
--- a/include/spdlog/sinks/msvc_sink.h
+++ b/include/spdlog/sinks/msvc_sink.h
@@ -1,50 +1,50 @@
-//
-// Copyright(c) 2016 Alexander Dalshov.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#if defined(_MSC_VER)
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-
-#include <WinBase.h>
-
-#include <mutex>
-#include <string>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
-* MSVC sink (logging using OutputDebugStringA)
-*/
-template<class Mutex>
-class msvc_sink : public base_sink < Mutex >
-{
-public:
-	explicit msvc_sink()
-    {
-    }
-
-    void flush() override
-    {
-    }
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-		OutputDebugStringA(msg.formatted.c_str());
-    }
-};
-
-typedef msvc_sink<std::mutex> msvc_sink_mt;
-typedef msvc_sink<details::null_mutex> msvc_sink_st;
-
-}
-}
-
-#endif
+//

+// Copyright(c) 2016 Alexander Dalshov.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#if defined(_MSC_VER)

+

+#include <spdlog/sinks/base_sink.h>

+#include <spdlog/details/null_mutex.h>

+

+#include <WinBase.h>

+

+#include <mutex>

+#include <string>

+

+namespace spdlog

+{

+namespace sinks

+{

+/*

+* MSVC sink (logging using OutputDebugStringA)

+*/

+template<class Mutex>

+class msvc_sink : public base_sink < Mutex >

+{

+public:

+    explicit msvc_sink()

+    {

+    }

+

+    void flush() override

+    {

+    }

+

+protected:

+    void _sink_it(const details::log_msg& msg) override

+    {

+        OutputDebugStringA(msg.formatted.c_str());

+    }

+};

+

+typedef msvc_sink<std::mutex> msvc_sink_mt;

+typedef msvc_sink<details::null_mutex> msvc_sink_st;

+

+}

+}

+

+#endif

diff --git a/include/spdlog/sinks/null_sink.h b/include/spdlog/sinks/null_sink.h
index 68bd9c94..01e2f438 100644
--- a/include/spdlog/sinks/null_sink.h
+++ b/include/spdlog/sinks/null_sink.h
@@ -1,34 +1,34 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-template <class Mutex>
-class null_sink : public base_sink < Mutex >
-{
-protected:
-    void _sink_it(const details::log_msg&) override
-    {}
-
-    void flush() override
-    {}
-
-};
-typedef null_sink<details::null_mutex> null_sink_st;
-typedef null_sink<std::mutex> null_sink_mt;
-
-}
-}
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/sinks/base_sink.h>

+#include <spdlog/details/null_mutex.h>

+

+#include <mutex>

+

+namespace spdlog

+{

+namespace sinks

+{

+

+template <class Mutex>

+class null_sink : public base_sink < Mutex >

+{

+protected:

+    void _sink_it(const details::log_msg&) override

+    {}

+

+    void flush() override

+    {}

+

+};

+typedef null_sink<details::null_mutex> null_sink_st;

+typedef null_sink<std::mutex> null_sink_mt;

+

+}

+}

+

diff --git a/include/spdlog/sinks/ostream_sink.h b/include/spdlog/sinks/ostream_sink.h
index feb5efa1..07ec8784 100644
--- a/include/spdlog/sinks/ostream_sink.h
+++ b/include/spdlog/sinks/ostream_sink.h
@@ -1,47 +1,47 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/sinks/base_sink.h>
-
-#include <ostream>
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class ostream_sink: public base_sink<Mutex>
-{
-public:
-    explicit ostream_sink(std::ostream& os, bool force_flush=false) :_ostream(os), _force_flush(force_flush) {}
-    ostream_sink(const ostream_sink&) = delete;
-    ostream_sink& operator=(const ostream_sink&) = delete;
-    virtual ~ostream_sink() = default;
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        _ostream.write(msg.formatted.data(), msg.formatted.size());
-        if (_force_flush)
-            _ostream.flush();
-    }
-
-    void flush() override
-    {
-        _ostream.flush();
-    }
-
-    std::ostream& _ostream;
-    bool _force_flush;
-};
-
-typedef ostream_sink<std::mutex> ostream_sink_mt;
-typedef ostream_sink<details::null_mutex> ostream_sink_st;
-}
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/details/null_mutex.h>

+#include <spdlog/sinks/base_sink.h>

+

+#include <ostream>

+#include <mutex>

+

+namespace spdlog

+{

+namespace sinks

+{

+template<class Mutex>

+class ostream_sink: public base_sink<Mutex>

+{

+public:

+    explicit ostream_sink(std::ostream& os, bool force_flush=false) :_ostream(os), _force_flush(force_flush) {}

+    ostream_sink(const ostream_sink&) = delete;

+    ostream_sink& operator=(const ostream_sink&) = delete;

+    virtual ~ostream_sink() = default;

+

+protected:

+    void _sink_it(const details::log_msg& msg) override

+    {

+        _ostream.write(msg.formatted.data(), msg.formatted.size());

+        if (_force_flush)

+            _ostream.flush();

+    }

+

+    void flush() override

+    {

+        _ostream.flush();

+    }

+

+    std::ostream& _ostream;

+    bool _force_flush;

+};

+

+typedef ostream_sink<std::mutex> ostream_sink_mt;

+typedef ostream_sink<details::null_mutex> ostream_sink_st;

+}

+}

diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index 39dc771a..49698839 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -1,24 +1,24 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-
-#pragma once
-
-#include <spdlog/details/log_msg.h>
-
-namespace spdlog
-{
-namespace sinks
-{
-class sink
-{
-public:
-    virtual ~sink() {}
-    virtual void log(const details::log_msg& msg) = 0;
-    virtual void flush() = 0;
-};
-}
-}
-
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+

+#pragma once

+

+#include <spdlog/details/log_msg.h>

+

+namespace spdlog

+{

+namespace sinks

+{

+class sink

+{

+public:

+    virtual ~sink() {}

+    virtual void log(const details::log_msg& msg) = 0;

+    virtual void flush() = 0;

+};

+}

+}

+

diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h
index 85db334f..4893c05c 100644
--- a/include/spdlog/sinks/stdout_sinks.h
+++ b/include/spdlog/sinks/stdout_sinks.h
@@ -1,54 +1,54 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/sinks/ostream_sink.h>
-#include <spdlog/details/null_mutex.h>
-
-#include <iostream>
-#include <memory>
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-template <class Mutex>
-class stdout_sink : public ostream_sink<Mutex>
-{
-    using MyType = stdout_sink<Mutex>;
-public:
-    stdout_sink() : ostream_sink<Mutex>(std::cout, true) {}
-    static std::shared_ptr<MyType> instance()
-    {
-        static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
-        return instance;
-    }
-};
-
-typedef stdout_sink<details::null_mutex> stdout_sink_st;
-typedef stdout_sink<std::mutex> stdout_sink_mt;
-
-
-template <class Mutex>
-class stderr_sink : public ostream_sink<Mutex>
-{
-    using MyType = stderr_sink<Mutex>;
-public:
-    stderr_sink() : ostream_sink<Mutex>(std::cerr, true) {}
-    static std::shared_ptr<MyType> instance()
-    {
-        static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
-        return instance;
-    }
-
-};
-
-typedef stderr_sink<std::mutex> stderr_sink_mt;
-typedef stderr_sink<details::null_mutex> stderr_sink_st;
-}
-}
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#include <spdlog/sinks/ostream_sink.h>

+#include <spdlog/details/null_mutex.h>

+

+#include <iostream>

+#include <memory>

+#include <mutex>

+

+namespace spdlog

+{

+namespace sinks

+{

+

+template <class Mutex>

+class stdout_sink : public ostream_sink<Mutex>

+{

+    using MyType = stdout_sink<Mutex>;

+public:

+    stdout_sink() : ostream_sink<Mutex>(std::cout, true) {}

+    static std::shared_ptr<MyType> instance()

+    {

+        static std::shared_ptr<MyType> instance = std::make_shared<MyType>();

+        return instance;

+    }

+};

+

+typedef stdout_sink<details::null_mutex> stdout_sink_st;

+typedef stdout_sink<std::mutex> stdout_sink_mt;

+

+

+template <class Mutex>

+class stderr_sink : public ostream_sink<Mutex>

+{

+    using MyType = stderr_sink<Mutex>;

+public:

+    stderr_sink() : ostream_sink<Mutex>(std::cerr, true) {}

+    static std::shared_ptr<MyType> instance()

+    {

+        static std::shared_ptr<MyType> instance = std::make_shared<MyType>();

+        return instance;

+    }

+

+};

+

+typedef stderr_sink<std::mutex> stderr_sink_mt;

+typedef stderr_sink<details::null_mutex> stderr_sink_st;

+}

+}

diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h
index 5d7ccf87..2136bed2 100644
--- a/include/spdlog/sinks/syslog_sink.h
+++ b/include/spdlog/sinks/syslog_sink.h
@@ -1,83 +1,83 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#if defined(__linux__) || defined(__APPLE__)
-
-#include <spdlog/sinks/sink.h>
-#include <spdlog/common.h>
-#include <spdlog/details/log_msg.h>
-
-#include <array>
-#include <string>
-#include <syslog.h>
-
-
-namespace spdlog
-{
-namespace sinks
-{
-/**
- * Sink that write to syslog using the `syscall()` library call.
- *
- * Locking is not needed, as `syslog()` itself is thread-safe.
- */
-class syslog_sink : public sink
-{
-public:
-    //
-    syslog_sink(const std::string& ident = "", int syslog_option=0, int syslog_facility=LOG_USER):
-        _ident(ident)
-    {
-        _priorities[static_cast<int>(level::trace)] = LOG_DEBUG;
-        _priorities[static_cast<int>(level::debug)] = LOG_DEBUG;
-        _priorities[static_cast<int>(level::info)] = LOG_INFO;
-        _priorities[static_cast<int>(level::notice)] = LOG_NOTICE;
-        _priorities[static_cast<int>(level::warn)] = LOG_WARNING;
-        _priorities[static_cast<int>(level::err)] = LOG_ERR;
-        _priorities[static_cast<int>(level::critical)] = LOG_CRIT;
-        _priorities[static_cast<int>(level::alert)] = LOG_ALERT;
-        _priorities[static_cast<int>(level::emerg)] = LOG_EMERG;
-        _priorities[static_cast<int>(level::off)] = LOG_INFO;
-
-        //set ident to be program name if empty
-        ::openlog(_ident.empty()? nullptr:_ident.c_str(), syslog_option, syslog_facility);
-    }
-    ~syslog_sink()
-    {
-        ::closelog();
-    }
-
-    syslog_sink(const syslog_sink&) = delete;
-    syslog_sink& operator=(const syslog_sink&) = delete;
-
-    void log(const details::log_msg &msg) override
-    {
-        ::syslog(syslog_prio_from_level(msg), "%s", msg.raw.str().c_str());
-    }
-
-    void flush() override
-    {
-    }
-
-
-private:
-    std::array<int, 10> _priorities;
-    //must store the ident because the man says openlog might use the pointer as is and not a string copy
-    const std::string _ident;
-
-    //
-    // Simply maps spdlog's log level to syslog priority level.
-    //
-    int syslog_prio_from_level(const details::log_msg &msg) const
-    {
-        return _priorities[static_cast<int>(msg.level)];
-    }
-};
-}
-}
-
-#endif
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+#pragma once

+

+#if defined(__linux__) || defined(__APPLE__)

+

+#include <spdlog/sinks/sink.h>

+#include <spdlog/common.h>

+#include <spdlog/details/log_msg.h>

+

+#include <array>

+#include <string>

+#include <syslog.h>

+

+

+namespace spdlog

+{

+namespace sinks

+{

+/**

+ * Sink that write to syslog using the `syscall()` library call.

+ *

+ * Locking is not needed, as `syslog()` itself is thread-safe.

+ */

+class syslog_sink : public sink

+{

+public:

+    //

+    syslog_sink(const std::string& ident = "", int syslog_option=0, int syslog_facility=LOG_USER):

+        _ident(ident)

+    {

+        _priorities[static_cast<int>(level::trace)] = LOG_DEBUG;

+        _priorities[static_cast<int>(level::debug)] = LOG_DEBUG;

+        _priorities[static_cast<int>(level::info)] = LOG_INFO;

+        _priorities[static_cast<int>(level::notice)] = LOG_NOTICE;

+        _priorities[static_cast<int>(level::warn)] = LOG_WARNING;

+        _priorities[static_cast<int>(level::err)] = LOG_ERR;

+        _priorities[static_cast<int>(level::critical)] = LOG_CRIT;

+        _priorities[static_cast<int>(level::alert)] = LOG_ALERT;

+        _priorities[static_cast<int>(level::emerg)] = LOG_EMERG;

+        _priorities[static_cast<int>(level::off)] = LOG_INFO;

+

+        //set ident to be program name if empty

+        ::openlog(_ident.empty()? nullptr:_ident.c_str(), syslog_option, syslog_facility);

+    }

+    ~syslog_sink()

+    {

+        ::closelog();

+    }

+

+    syslog_sink(const syslog_sink&) = delete;

+    syslog_sink& operator=(const syslog_sink&) = delete;

+

+    void log(const details::log_msg &msg) override

+    {

+        ::syslog(syslog_prio_from_level(msg), "%s", msg.raw.str().c_str());

+    }

+

+    void flush() override

+    {

+    }

+

+

+private:

+    std::array<int, 10> _priorities;

+    //must store the ident because the man says openlog might use the pointer as is and not a string copy

+    const std::string _ident;

+

+    //

+    // Simply maps spdlog's log level to syslog priority level.

+    //

+    int syslog_prio_from_level(const details::log_msg &msg) const

+    {

+        return _priorities[static_cast<int>(msg.level)];

+    }

+};

+}

+}

+

+#endif

diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index bf637a15..59314785 100644
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -1,140 +1,140 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-// spdlog main header file.
-// see example.cpp for usage example
-
-#pragma once
-
-#include <spdlog/tweakme.h>
-#include <spdlog/common.h>
-#include <spdlog/logger.h>
-
-#include <memory>
-#include <functional>
-#include <chrono>
-#include <string>
-
-namespace spdlog
-{
-// Return an existing logger or nullptr if a logger with such name doesn't exist.
-// Examples:
-//
-// spdlog::get("mylog")->info("Hello");
-// auto logger = spdlog::get("mylog");
-// logger.info("This is another message" , x, y, z);
-// logger.info() << "This is another message" << x << y << z;
-std::shared_ptr<logger> get(const std::string& name);
-
-//
-// Set global formatting
-// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
-//
-void set_pattern(const std::string& format_string);
-void set_formatter(formatter_ptr f);
-
-//
-// Set global logging level for
-//
-void set_level(level::level_enum log_level);
-
-//
-// Turn on async mode (off by default) and set the queue size for each async_logger.
-// effective only for loggers created after this call.
-// queue_size: size of queue (must be power of 2):
-//    Each logger will pre-allocate a dedicated queue with queue_size entries upon construction.
-//
-// async_overflow_policy (optional, block_retry by default):
-//    async_overflow_policy::block_retry - if queue is full, block until queue has room for the new log entry.
-//    async_overflow_policy::discard_log_msg - never block and discard any new messages when queue  overflows.
-//
-// worker_warmup_cb (optional):
-//     callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity)
-//
-void set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());
-
-// Turn off async mode
-void set_sync_mode();
-
-//
-// Create and register multi/single threaded rotating file logger
-//
-std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const std::string& filenameB, size_t max_file_size, size_t max_files, bool force_flush = false);
-std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false);
-
-//
-// Create file logger which creates new file on the given time (default in  midnight):
-//
-std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false);
-std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false);
-
-
-//
-// Create and register stdout/stderr loggers
-//
-std::shared_ptr<logger> stdout_logger_mt(const std::string& logger_name, bool color = false);
-std::shared_ptr<logger> stdout_logger_st(const std::string& logger_name, bool color = false);
-std::shared_ptr<logger> stderr_logger_mt(const std::string& logger_name, bool color = false);
-std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name, bool color = false);
-
-
-//
-// Create and register a syslog logger
-//
-#if defined(__linux__) || defined(__APPLE__)
-std::shared_ptr<logger> syslog_logger(const std::string& logger_name, const std::string& ident = "", int syslog_option = 0);
-#endif
-
-
-// Create and register a logger with multiple sinks
-std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks);
-template<class It>
-std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end);
-
-
-// Create and register a logger with templated sink type
-// Example: spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename", "txt");
-template <typename Sink, typename... Args>
-std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);
-
-
-// Register the given logger with the given name
-void register_logger(std::shared_ptr<logger> logger);
-
-// Drop the reference to the given logger
-void drop(const std::string &name);
-
-// Drop all references
-void drop_all();
-
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Macros to be display source file & line
-// Trace & Debug can be switched on/off at compile time for zero cost debug statements.
-// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in teakme.h to enable.
-//
-// Example:
-// spdlog::set_level(spdlog::level::debug);
-// SPDLOG_DEBUG(my_logger, "Some debug message {} {}", 1, 3.2);
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef SPDLOG_TRACE_ON
-#define SPDLOG_TRACE(logger, ...) logger->trace(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")";
-#else
-#define SPDLOG_TRACE(logger, ...)
-#endif
-
-#ifdef SPDLOG_DEBUG_ON
-#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__)  << " (" << __FILE__ << " #" << __LINE__ <<")";
-#else
-#define SPDLOG_DEBUG(logger, ...)
-#endif
-
-
-}
-
-
-#include <spdlog/details/spdlog_impl.h>
+//

+// Copyright(c) 2015 Gabi Melman.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+//

+

+// spdlog main header file.

+// see example.cpp for usage example

+

+#pragma once

+

+#include <spdlog/tweakme.h>

+#include <spdlog/common.h>

+#include <spdlog/logger.h>

+

+#include <memory>

+#include <functional>

+#include <chrono>

+#include <string>

+

+namespace spdlog

+{

+// Return an existing logger or nullptr if a logger with such name doesn't exist.

+// Examples:

+//

+// spdlog::get("mylog")->info("Hello");

+// auto logger = spdlog::get("mylog");

+// logger.info("This is another message" , x, y, z);

+// logger.info() << "This is another message" << x << y << z;

+std::shared_ptr<logger> get(const std::string& name);

+

+//

+// Set global formatting

+// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");

+//

+void set_pattern(const std::string& format_string);

+void set_formatter(formatter_ptr f);

+

+//

+// Set global logging level for

+//

+void set_level(level::level_enum log_level);

+

+//

+// Turn on async mode (off by default) and set the queue size for each async_logger.

+// effective only for loggers created after this call.

+// queue_size: size of queue (must be power of 2):

+//    Each logger will pre-allocate a dedicated queue with queue_size entries upon construction.

+//

+// async_overflow_policy (optional, block_retry by default):

+//    async_overflow_policy::block_retry - if queue is full, block until queue has room for the new log entry.

+//    async_overflow_policy::discard_log_msg - never block and discard any new messages when queue  overflows.

+//

+// worker_warmup_cb (optional):

+//     callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity)

+//

+void set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());

+

+// Turn off async mode

+void set_sync_mode();

+

+//

+// Create and register multi/single threaded rotating file logger

+//

+std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const std::string& filenameB, size_t max_file_size, size_t max_files, bool force_flush = false);

+std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false);

+

+//

+// Create file logger which creates new file on the given time (default in  midnight):

+//

+std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false);

+std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false);

+

+

+//

+// Create and register stdout/stderr loggers

+//

+std::shared_ptr<logger> stdout_logger_mt(const std::string& logger_name, bool color = false);

+std::shared_ptr<logger> stdout_logger_st(const std::string& logger_name, bool color = false);

+std::shared_ptr<logger> stderr_logger_mt(const std::string& logger_name, bool color = false);

+std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name, bool color = false);

+

+

+//

+// Create and register a syslog logger

+//

+#if defined(__linux__) || defined(__APPLE__)

+std::shared_ptr<logger> syslog_logger(const std::string& logger_name, const std::string& ident = "", int syslog_option = 0);

+#endif

+

+

+// Create and register a logger with multiple sinks

+std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks);

+template<class It>

+std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end);

+

+

+// Create and register a logger with templated sink type

+// Example: spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename", "txt");

+template <typename Sink, typename... Args>

+std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);

+

+

+// Register the given logger with the given name

+void register_logger(std::shared_ptr<logger> logger);

+

+// Drop the reference to the given logger

+void drop(const std::string &name);

+

+// Drop all references

+void drop_all();

+

+

+///////////////////////////////////////////////////////////////////////////////

+//

+// Macros to be display source file & line

+// Trace & Debug can be switched on/off at compile time for zero cost debug statements.

+// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in teakme.h to enable.

+//

+// Example:

+// spdlog::set_level(spdlog::level::debug);

+// SPDLOG_DEBUG(my_logger, "Some debug message {} {}", 1, 3.2);

+///////////////////////////////////////////////////////////////////////////////

+

+#ifdef SPDLOG_TRACE_ON

+#define SPDLOG_TRACE(logger, ...) logger->trace(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")";

+#else

+#define SPDLOG_TRACE(logger, ...)

+#endif

+

+#ifdef SPDLOG_DEBUG_ON

+#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__)  << " (" << __FILE__ << " #" << __LINE__ <<")";

+#else

+#define SPDLOG_DEBUG(logger, ...)

+#endif

+

+

+}

+

+

+#include <spdlog/details/spdlog_impl.h>