From 849b5cb84e4d4f33d10c38d93fcd948fa6e29d58 Mon Sep 17 00:00:00 2001
From: Denis Ivaykin <denis.ivaykin@gmail.com>
Date: Fri, 8 May 2015 22:57:52 +0200
Subject: [PATCH 01/61] flush

---
 include/spdlog/details/file_helper.h | 4 ++++
 include/spdlog/sinks/base_sink.h     | 1 +
 include/spdlog/sinks/file_sinks.h    | 8 ++++++++
 include/spdlog/sinks/null_sink.h     | 3 +++
 include/spdlog/sinks/ostream_sink.h  | 5 +++++
 5 files changed, 21 insertions(+)

diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h
index 8ae67bf0..8e1f600b 100644
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -87,6 +87,10 @@ public:
 
     }
 
+    void flush() {
+        std::fflush(_fd);
+    }
+
     void close()
     {
         if (_fd)
diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h
index f1647ae0..55411721 100644
--- a/include/spdlog/sinks/base_sink.h
+++ b/include/spdlog/sinks/base_sink.h
@@ -58,6 +58,7 @@ public:
         _sink_it(msg);
     }
 
+    virtual void flush() = 0;
 
 protected:
     virtual void _sink_it(const details::log_msg& msg) = 0;
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 9ec8f46b..0e705337 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -80,6 +80,10 @@ public:
         _file_helper.open(calc_filename(_base_filename, 0, _extension));
     }
 
+    virtual void flush() override {
+        _file_helper.flush();
+    }
+
 protected:
     void _sink_it(const details::log_msg& msg) override
     {
@@ -167,6 +171,10 @@ public:
         _file_helper.open(calc_filename(_base_filename, _extension));
     }
 
+    virtual void flush() override {
+        _file_helper.flush();
+    }
+
 protected:
     void _sink_it(const details::log_msg& msg) override
     {
diff --git a/include/spdlog/sinks/null_sink.h b/include/spdlog/sinks/null_sink.h
index 2cd416a9..992b3b73 100644
--- a/include/spdlog/sinks/null_sink.h
+++ b/include/spdlog/sinks/null_sink.h
@@ -40,6 +40,9 @@ 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 91580301..7b6b9db3 100644
--- a/include/spdlog/sinks/ostream_sink.h
+++ b/include/spdlog/sinks/ostream_sink.h
@@ -51,6 +51,11 @@ protected:
         if (_force_flush)
             _ostream.flush();
     }
+
+    virtual void flush() override {
+        _ostream.flush();
+    }
+
     std::ostream& _ostream;
     bool _force_flush;
 };

From a74e280bb4ba3a4fb6396c1bb6368c376f50ec48 Mon Sep 17 00:00:00 2001
From: Denis Ivaykin <denis.ivaykin@gmail.com>
Date: Sat, 9 May 2015 13:14:16 +0200
Subject: [PATCH 02/61] vector / mutex

---
 include/spdlog/details/registry.h | 44 ++++++++++++++++++++++++++++++-
 include/spdlog/tweakme.h          | 12 +++++++++
 2 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index 5f708743..6c6e2d30 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -54,9 +54,19 @@ public:
 
     std::shared_ptr<logger> get(const std::string& logger_name)
     {
+#ifndef SPDLOG_NO_REGISTRY_MUTEX
         std::lock_guard<std::mutex> lock(_mutex);
+#endif
+#ifdef SPDLOG_VECTOR_BASED_REGISTRY
+        for (auto& logger : _loggers) {
+            if (logger_name == logger->name())
+                return logger;
+        }
+        return nullptr;
+#else
         auto found = _loggers.find(logger_name);
         return found == _loggers.end() ? nullptr : found->second;
+#endif
     }
 
     template<class It>
@@ -84,7 +94,17 @@ public:
     void drop(const std::string& logger_name)
     {
         std::lock_guard<std::mutex> lock(_mutex);
+#ifdef SPDLOG_VECTOR_BASED_REGISTRY
+        for (auto it = _loggers.begin(); it != _loggers.end();) {
+            if (logger_name == (*it)->name()) {
+                it = _loggers.erase(it);
+            } else {
+                ++it;
+            }
+        }
+#else
         _loggers.erase(logger_name);
+#endif
     }
 
     void drop_all()
@@ -108,7 +128,11 @@ public:
         std::lock_guard<std::mutex> lock(_mutex);
         _formatter = f;
         for (auto& l : _loggers)
+#ifdef SPDLOG_VECTOR_BASED_REGISTRY
+            l->set_formatter(_formatter);
+#else
             l.second->set_formatter(_formatter);
+#endif
     }
 
     void set_pattern(const std::string& pattern)
@@ -116,14 +140,22 @@ public:
         std::lock_guard<std::mutex> lock(_mutex);
         _formatter = std::make_shared<pattern_formatter>(pattern);
         for (auto& l : _loggers)
+#ifdef SPDLOG_VECTOR_BASED_REGISTRY
+            l->set_formatter(_formatter);
+#else
             l.second->set_formatter(_formatter);
+#endif
     }
 
     void set_level(level::level_enum log_level)
     {
         std::lock_guard<std::mutex> lock(_mutex);
         for (auto& l : _loggers)
+#ifdef SPDLOG_VECTOR_BASED_REGISTRY
+            l->set_level(log_level);
+#else
             l.second->set_level(log_level);
+#endif
         _level = log_level;
     }
 
@@ -152,15 +184,25 @@ private:
     void register_logger_impl(std::shared_ptr<logger> logger)
     {
         auto logger_name = logger->name();
-        if (_loggers.find(logger_name) != std::end(_loggers))
+        if (get(logger_name) != nullptr)
             throw spdlog_ex("logger with name " + logger_name + " already exists");
+#ifdef SPDLOG_VECTOR_BASED_REGISTRY
+        _loggers.push_back(logger);
+#else
         _loggers[logger->name()] = logger;
+#endif
     }
     registry() = default;
     registry(const registry&) = delete;
     registry& operator=(const registry&) = delete;
     std::mutex _mutex;
+
+#ifdef SPDLOG_VECTOR_BASED_REGISTRY
+    std::vector <std::shared_ptr<logger>> _loggers;
+#else
     std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
+#endif
+
     formatter_ptr _formatter;
     level::level_enum _level = level::info;
     bool _async_mode = false;
diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index 20e2c5e4..9e56b202 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -64,3 +64,15 @@
 // #define SPDLOG_DEBUG_ON
 // #define SPDLOG_TRACE_ON
 ///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to enable lockless registry
+// #define SPDLOG_NO_REGISTRY_MUTEX
+///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to enable vector based registry
+// #define SPDLOG_VECTOR_BASED_REGISTRY
+///////////////////////////////////////////////////////////////////////////////

From 63e0012e344c2511c769495fbfe1378009ffaef7 Mon Sep 17 00:00:00 2001
From: Denis Ivaykin <denis.ivaykin@gmail.com>
Date: Sat, 9 May 2015 13:24:01 +0200
Subject: [PATCH 03/61] flush in logger

---
 include/spdlog/details/logger_impl.h | 6 +++++-
 include/spdlog/logger.h              | 1 +
 include/spdlog/sinks/base_sink.h     | 2 --
 include/spdlog/sinks/sink.h          | 1 +
 include/spdlog/sinks/syslog_sink.h   | 2 ++
 5 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h
index 1a920c03..fa4731ae 100644
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
@@ -312,4 +312,8 @@ inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
     _formatter = msg_formatter;
 }
 
-
+inline void spdlog::logger::flush() {
+    for (auto& sink : _sinks) {
+        sink->flush();
+    }
+}
\ No newline at end of file
diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h
index cf97fc80..7a5a31a7 100644
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -107,6 +107,7 @@ public:
     void set_pattern(const std::string&);
     void set_formatter(formatter_ptr);
 
+    void flush();
 
 protected:
     virtual void _log_msg(details::log_msg&);
diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h
index 55411721..12d63ea8 100644
--- a/include/spdlog/sinks/base_sink.h
+++ b/include/spdlog/sinks/base_sink.h
@@ -58,8 +58,6 @@ public:
         _sink_it(msg);
     }
 
-    virtual void flush() = 0;
-
 protected:
     virtual void _sink_it(const details::log_msg& msg) = 0;
     Mutex _mutex;
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index 0905d52f..88c423a0 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -35,6 +35,7 @@ class sink
 public:
     virtual ~sink() {}
     virtual void log(const details::log_msg& msg) = 0;
+    virtual void flush() = 0;
 };
 }
 }
diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h
index 7d729743..15a96fee 100644
--- a/include/spdlog/sinks/syslog_sink.h
+++ b/include/spdlog/sinks/syslog_sink.h
@@ -78,6 +78,8 @@ public:
         ::syslog(syslog_prio_from_level(msg), "%s", msg.formatted.str().c_str());
     }
 
+    virtual void flush() override {
+    }
 
 
 private:

From 64850dcb0c4d7af8ce2b2c9f400cc604ab796c1a Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 9 May 2015 16:03:43 +0300
Subject: [PATCH 04/61] small style fixes

---
 include/spdlog/details/logger_impl.h | 7 ++++---
 include/spdlog/sinks/file_sinks.h    | 6 ++++--
 include/spdlog/sinks/ostream_sink.h  | 5 +++--
 include/spdlog/sinks/syslog_sink.h   | 3 ++-
 4 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h
index fa4731ae..d658ac03 100644
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
@@ -50,7 +50,9 @@ inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list si
 
 // ctor with single sink
 inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink) :
-    logger(logger_name, { single_sink }) {}
+    logger(logger_name, {
+    single_sink
+}) {}
 
 
 inline spdlog::logger::~logger() = default;
@@ -313,7 +315,6 @@ inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
 }
 
 inline void spdlog::logger::flush() {
-    for (auto& sink : _sinks) {
+    for (auto& sink : _sinks)
         sink->flush();
-    }
 }
\ No newline at end of file
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 0e705337..1c2f2998 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -80,7 +80,8 @@ public:
         _file_helper.open(calc_filename(_base_filename, 0, _extension));
     }
 
-    virtual void flush() override {
+    void flush() override
+    {
         _file_helper.flush();
     }
 
@@ -171,7 +172,8 @@ public:
         _file_helper.open(calc_filename(_base_filename, _extension));
     }
 
-    virtual void flush() override {
+    void flush() override
+    {
         _file_helper.flush();
     }
 
diff --git a/include/spdlog/sinks/ostream_sink.h b/include/spdlog/sinks/ostream_sink.h
index 7b6b9db3..f2fe3b23 100644
--- a/include/spdlog/sinks/ostream_sink.h
+++ b/include/spdlog/sinks/ostream_sink.h
@@ -45,14 +45,15 @@ public:
     virtual ~ostream_sink() = default;
 
 protected:
-    virtual void _sink_it(const details::log_msg& msg) override
+    void _sink_it(const details::log_msg& msg) override
     {
         _ostream.write(msg.formatted.data(), msg.formatted.size());
         if (_force_flush)
             _ostream.flush();
     }
 
-    virtual void flush() override {
+    void flush() override
+    {
         _ostream.flush();
     }
 
diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h
index 15a96fee..37b65136 100644
--- a/include/spdlog/sinks/syslog_sink.h
+++ b/include/spdlog/sinks/syslog_sink.h
@@ -78,7 +78,8 @@ public:
         ::syslog(syslog_prio_from_level(msg), "%s", msg.formatted.str().c_str());
     }
 
-    virtual void flush() override {
+    void flush() override
+    {
     }
 
 

From fa038547ad92d281d04f19235680aa46a9f5422c Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 9 May 2015 16:39:23 +0300
Subject: [PATCH 05/61] tweakme.h comments

---
 include/spdlog/tweakme.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index 9e56b202..bf65ad25 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -67,12 +67,14 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable lockless registry
+// Uncomment to avoid locking in the registry operations (spdlog::get() spdlog::drop() spdlog::register())
+// Use only if your code is single threaded or never modifes concurrently the registry
 // #define SPDLOG_NO_REGISTRY_MUTEX
 ///////////////////////////////////////////////////////////////////////////////
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable vector based registry
+// Uncomment to enable vector based registry instead of the default unordered_map
+// spdlog::get(..) operations will be faster on small registry sizes (upto ~10-20 loggers)
 // #define SPDLOG_VECTOR_BASED_REGISTRY
 ///////////////////////////////////////////////////////////////////////////////

From 9cad840a728ca95d8e43d72345e75a2e7edfa5c3 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 9 May 2015 17:15:07 +0300
Subject: [PATCH 06/61] Revert "vector / mutex"

This reverts commit a74e280bb4ba3a4fb6396c1bb6368c376f50ec48.

Conflicts:
	include/spdlog/tweakme.h
---
 include/spdlog/details/registry.h | 44 +------------------------------
 include/spdlog/tweakme.h          | 13 ---------
 2 files changed, 1 insertion(+), 56 deletions(-)

diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index 6c6e2d30..5f708743 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -54,19 +54,9 @@ public:
 
     std::shared_ptr<logger> get(const std::string& logger_name)
     {
-#ifndef SPDLOG_NO_REGISTRY_MUTEX
         std::lock_guard<std::mutex> lock(_mutex);
-#endif
-#ifdef SPDLOG_VECTOR_BASED_REGISTRY
-        for (auto& logger : _loggers) {
-            if (logger_name == logger->name())
-                return logger;
-        }
-        return nullptr;
-#else
         auto found = _loggers.find(logger_name);
         return found == _loggers.end() ? nullptr : found->second;
-#endif
     }
 
     template<class It>
@@ -94,17 +84,7 @@ public:
     void drop(const std::string& logger_name)
     {
         std::lock_guard<std::mutex> lock(_mutex);
-#ifdef SPDLOG_VECTOR_BASED_REGISTRY
-        for (auto it = _loggers.begin(); it != _loggers.end();) {
-            if (logger_name == (*it)->name()) {
-                it = _loggers.erase(it);
-            } else {
-                ++it;
-            }
-        }
-#else
         _loggers.erase(logger_name);
-#endif
     }
 
     void drop_all()
@@ -128,11 +108,7 @@ public:
         std::lock_guard<std::mutex> lock(_mutex);
         _formatter = f;
         for (auto& l : _loggers)
-#ifdef SPDLOG_VECTOR_BASED_REGISTRY
-            l->set_formatter(_formatter);
-#else
             l.second->set_formatter(_formatter);
-#endif
     }
 
     void set_pattern(const std::string& pattern)
@@ -140,22 +116,14 @@ public:
         std::lock_guard<std::mutex> lock(_mutex);
         _formatter = std::make_shared<pattern_formatter>(pattern);
         for (auto& l : _loggers)
-#ifdef SPDLOG_VECTOR_BASED_REGISTRY
-            l->set_formatter(_formatter);
-#else
             l.second->set_formatter(_formatter);
-#endif
     }
 
     void set_level(level::level_enum log_level)
     {
         std::lock_guard<std::mutex> lock(_mutex);
         for (auto& l : _loggers)
-#ifdef SPDLOG_VECTOR_BASED_REGISTRY
-            l->set_level(log_level);
-#else
             l.second->set_level(log_level);
-#endif
         _level = log_level;
     }
 
@@ -184,25 +152,15 @@ private:
     void register_logger_impl(std::shared_ptr<logger> logger)
     {
         auto logger_name = logger->name();
-        if (get(logger_name) != nullptr)
+        if (_loggers.find(logger_name) != std::end(_loggers))
             throw spdlog_ex("logger with name " + logger_name + " already exists");
-#ifdef SPDLOG_VECTOR_BASED_REGISTRY
-        _loggers.push_back(logger);
-#else
         _loggers[logger->name()] = logger;
-#endif
     }
     registry() = default;
     registry(const registry&) = delete;
     registry& operator=(const registry&) = delete;
     std::mutex _mutex;
-
-#ifdef SPDLOG_VECTOR_BASED_REGISTRY
-    std::vector <std::shared_ptr<logger>> _loggers;
-#else
     std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
-#endif
-
     formatter_ptr _formatter;
     level::level_enum _level = level::info;
     bool _async_mode = false;
diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index bf65ad25..e6e1bedf 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -65,16 +65,3 @@
 // #define SPDLOG_TRACE_ON
 ///////////////////////////////////////////////////////////////////////////////
 
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to avoid locking in the registry operations (spdlog::get() spdlog::drop() spdlog::register())
-// Use only if your code is single threaded or never modifes concurrently the registry
-// #define SPDLOG_NO_REGISTRY_MUTEX
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable vector based registry instead of the default unordered_map
-// spdlog::get(..) operations will be faster on small registry sizes (upto ~10-20 loggers)
-// #define SPDLOG_VECTOR_BASED_REGISTRY
-///////////////////////////////////////////////////////////////////////////////

From 6991857a8eaf8d7835f9ff8917032e8bbaac58ef Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 9 May 2015 21:32:53 +0300
Subject: [PATCH 07/61] Added SPDLOG_NO_REGISTRY_MUTEX option to tweakme.h

---
 include/spdlog/details/registry.h | 40 ++++++++++++++++++-------------
 include/spdlog/tweakme.h          |  5 ++++
 2 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index 5f708743..cb4f5a7e 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -33,6 +33,7 @@
 #include <unordered_map>
 #include <functional>
 
+#include "./null_mutex.h"
 #include "../logger.h"
 #include "../async_logger.h"
 #include "../common.h"
@@ -41,20 +42,20 @@ namespace spdlog
 {
 namespace details
 {
-class registry
+template <class Mutex> class registry_t
 {
 public:
 
     void register_logger(std::shared_ptr<logger> logger)
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         register_logger_impl(logger);
     }
 
 
     std::shared_ptr<logger> get(const std::string& logger_name)
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         auto found = _loggers.find(logger_name);
         return found == _loggers.end() ? nullptr : found->second;
     }
@@ -65,7 +66,7 @@ public:
 
         std::shared_ptr<logger> new_logger;
 
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
 
 
         if (_async_mode)
@@ -83,13 +84,13 @@ public:
 
     void drop(const std::string& logger_name)
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         _loggers.erase(logger_name);
     }
 
     void drop_all()
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         _loggers.clear();
     }
     std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks)
@@ -105,7 +106,7 @@ public:
 
     void formatter(formatter_ptr f)
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         _formatter = f;
         for (auto& l : _loggers)
             l.second->set_formatter(_formatter);
@@ -113,7 +114,7 @@ public:
 
     void set_pattern(const std::string& pattern)
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         _formatter = std::make_shared<pattern_formatter>(pattern);
         for (auto& l : _loggers)
             l.second->set_formatter(_formatter);
@@ -121,7 +122,7 @@ public:
 
     void set_level(level::level_enum log_level)
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         for (auto& l : _loggers)
             l.second->set_level(log_level);
         _level = log_level;
@@ -129,7 +130,7 @@ public:
 
     void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb)
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         _async_mode = true;
         _async_q_size = q_size;
         _overflow_policy = overflow_policy;
@@ -138,13 +139,13 @@ public:
 
     void set_sync_mode()
     {
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<Mutex> lock(_mutex);
         _async_mode = false;
     }
 
-    static registry& instance()
+    static registry_t<Mutex>& instance()
     {
-        static registry s_instance;
+        static registry_t<Mutex> s_instance;
         return s_instance;
     }
 
@@ -156,10 +157,10 @@ private:
             throw spdlog_ex("logger with name " + logger_name + " already exists");
         _loggers[logger->name()] = logger;
     }
-    registry() = default;
-    registry(const registry&) = delete;
-    registry& operator=(const registry&) = delete;
-    std::mutex _mutex;
+    registry_t<Mutex>() = default;
+    registry_t<Mutex>(const registry_t<Mutex>&) = delete;
+    registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
+    Mutex _mutex;
     std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
     formatter_ptr _formatter;
     level::level_enum _level = level::info;
@@ -168,5 +169,10 @@ private:
     async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;
     std::function<void()> _worker_warmup_cb = nullptr;
 };
+#ifndef SPDLOG_NO_REGISTRY_MUTEX
+typedef registry_t<std::mutex> registry;
+#else
+typedef registry_t<spdlog::details::null_mutex> registry;
+#endif
 }
 }
diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index e6e1bedf..fa728662 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -65,3 +65,8 @@
 // #define SPDLOG_TRACE_ON
 ///////////////////////////////////////////////////////////////////////////////
 
+
+// Uncomment to avoid locking in the registry operations (spdlog::get(), spdlog::drop() spdlog::register())
+// Use only if your code never modifes concurrently the registry
+// Note that upon creating a logger the registry is modified by spdlog..
+// #define SPDLOG_NO_REGISTRY_MUTEX
\ No newline at end of file

From 32bc807109e1c0aaef7d0555355791698d5786b9 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 9 May 2015 21:35:17 +0300
Subject: [PATCH 08/61] Comments

---
 include/spdlog/tweakme.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index fa728662..2226820e 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -32,7 +32,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used.
-// This clock is less accurate - can be off by dozens of millis - depending on the kernel HZ
+// This clock is less accurate - can be off by dozens of millis - depending on the kernel HZ.
 // Uncomment to use it instead of the regular (but slower) clock.
 // #define SPDLOG_CLOCK_COARSE
 ///////////////////////////////////////////////////////////////////////////////
@@ -46,7 +46,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Uncomment if thread id logging is not needed (i.e. no %t in the log pattern)
+// Uncomment if thread id logging is not needed (i.e. no %t in the log pattern).
 // This will prevent spdlog from quering the thread id on each log call.
 // #define SPDLOG_NO_THREAD_ID
 ///////////////////////////////////////////////////////////////////////////////
@@ -60,13 +60,13 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable the SPDLOG_DEBUG/SPDLOG_TRACE macros
+// Uncomment to enable the SPDLOG_DEBUG/SPDLOG_TRACE macros.
 // #define SPDLOG_DEBUG_ON
 // #define SPDLOG_TRACE_ON
 ///////////////////////////////////////////////////////////////////////////////
 
 
-// Uncomment to avoid locking in the registry operations (spdlog::get(), spdlog::drop() spdlog::register())
-// Use only if your code never modifes concurrently the registry
+// Uncomment to avoid locking in the registry operations (spdlog::get(), spdlog::drop() spdlog::register()).
+// Use only if your code never modifes concurrently the registry.
 // Note that upon creating a logger the registry is modified by spdlog..
 // #define SPDLOG_NO_REGISTRY_MUTEX
\ No newline at end of file

From 0402309028b13aac445e0b82cd468d16cf7ac558 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 9 May 2015 21:39:55 +0300
Subject: [PATCH 09/61] eol

---
 include/spdlog/tweakme.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index 2226820e..342d6f99 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -69,4 +69,4 @@
 // Uncomment to avoid locking in the registry operations (spdlog::get(), spdlog::drop() spdlog::register()).
 // Use only if your code never modifes concurrently the registry.
 // Note that upon creating a logger the registry is modified by spdlog..
-// #define SPDLOG_NO_REGISTRY_MUTEX
\ No newline at end of file
+// #define SPDLOG_NO_REGISTRY_MUTEX

From b9dc8226b46132874e51a963ca5cfa9e9d308f0a Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 9 May 2015 21:41:20 +0300
Subject: [PATCH 10/61] Comments

---
 include/spdlog/tweakme.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index 342d6f99..b651658b 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -66,7 +66,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 
+///////////////////////////////////////////////////////////////////////////////
 // Uncomment to avoid locking in the registry operations (spdlog::get(), spdlog::drop() spdlog::register()).
 // Use only if your code never modifes concurrently the registry.
 // Note that upon creating a logger the registry is modified by spdlog..
 // #define SPDLOG_NO_REGISTRY_MUTEX
+///////////////////////////////////////////////////////////////////////////////

From 8208b49298da0a43a293a23292a3167702d5ca14 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 9 May 2015 21:44:02 +0300
Subject: [PATCH 11/61] Minor change is typedef order

---
 include/spdlog/details/registry.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index cb4f5a7e..9c386ced 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -169,10 +169,10 @@ private:
     async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;
     std::function<void()> _worker_warmup_cb = nullptr;
 };
-#ifndef SPDLOG_NO_REGISTRY_MUTEX
-typedef registry_t<std::mutex> registry;
-#else
+#ifdef SPDLOG_NO_REGISTRY_MUTEX
 typedef registry_t<spdlog::details::null_mutex> registry;
+#else
+typedef registry_t<std::mutex> registry;
 #endif
 }
 }

From f363fff109757840410d8d7b18947cc53e8744a6 Mon Sep 17 00:00:00 2001
From: Denis Ivaykin <denis.ivaykin@gmail.com>
Date: Sat, 9 May 2015 22:30:05 +0200
Subject: [PATCH 12/61] async auto flush

---
 include/spdlog/async_logger.h              |  9 ++++--
 include/spdlog/details/async_log_helper.h  | 37 ++++++++++++++++------
 include/spdlog/details/async_logger_impl.h | 15 +++++----
 3 files changed, 42 insertions(+), 19 deletions(-)

diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h
index 7bcde900..a802b03c 100644
--- a/include/spdlog/async_logger.h
+++ b/include/spdlog/async_logger.h
@@ -58,19 +58,22 @@ public:
                  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::function<void()>& worker_warmup_cb = nullptr,
+                 const std::chrono::milliseconds auto_flush_millis = 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::function<void()>& worker_warmup_cb = nullptr,
+                 const std::chrono::milliseconds auto_flush_millis = 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::function<void()>& worker_warmup_cb = nullptr,
+                 const std::chrono::milliseconds auto_flush_millis = std::chrono::milliseconds::zero());
 
 
 protected:
diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h
index 657c70bb..9fe38cff 100644
--- a/include/spdlog/details/async_log_helper.h
+++ b/include/spdlog/details/async_log_helper.h
@@ -65,7 +65,7 @@ class async_log_helper
         async_msg() = default;
         ~async_msg() = default;
 
-async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
+        async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
         logger_name(std::move(other.logger_name)),
                     level(std::move(other.level)),
                     time(std::move(other.time)),
@@ -119,7 +119,8 @@ public:
                      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::function<void()>& worker_warmup_cb = nullptr,
+                     const std::chrono::milliseconds auto_flush_millis = std::chrono::milliseconds::zero());
 
     void log(const details::log_msg& msg);
 
@@ -145,6 +146,9 @@ private:
     // 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 _auto_flush_millis;
+
     // worker thread
     std::thread _worker_thread;
 
@@ -159,7 +163,7 @@ private:
     bool process_next_msg(clock::time_point& last_pop);
 
     // sleep,yield or return immediatly using the time passed since last message as a hint
-    static void sleep_or_yield(const clock::time_point& last_op_time);
+    static std::chrono::nanoseconds sleep_or_yield(const clock::time_point& last_op_time);
 
 };
 }
@@ -168,12 +172,13 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 // 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):
+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 auto_flush_millis):
     _formatter(formatter),
     _sinks(sinks),
     _q(queue_size),
     _overflow_policy(overflow_policy),
     _worker_warmup_cb(worker_warmup_cb),
+    _auto_flush_millis(auto_flush_millis),
     _worker_thread(&async_log_helper::worker_loop, this)
 {}
 
@@ -249,7 +254,12 @@ inline bool spdlog::details::async_log_helper::process_next_msg(clock::time_poin
     }
     else //empty queue
     {
-        sleep_or_yield(last_pop);
+        auto time_since_op = sleep_or_yield(last_pop);
+        if (_auto_flush_millis > std::chrono::milliseconds::zero() && time_since_op > _auto_flush_millis)
+        {
+            for (auto &s : _sinks)
+                s->flush();
+        }
     }
     return true;
 }
@@ -261,7 +271,7 @@ inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_f
 
 
 // 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 clock::time_point& last_op_time)
+inline std::chrono::nanoseconds spdlog::details::async_log_helper::sleep_or_yield(const clock::time_point& last_op_time)
 {
     using std::chrono::milliseconds;
     using namespace std::this_thread;
@@ -270,18 +280,25 @@ inline void spdlog::details::async_log_helper::sleep_or_yield(const clock::time_
 
     // spin upto 1 ms
     if (time_since_op <= milliseconds(1))
-        return;
+        return time_since_op;
 
     // yield upto 10ms
     if (time_since_op <= milliseconds(10))
-        return yield();
+    {
+        yield();
+        return time_since_op;
+    }
 
 
     // sleep for half of duration since last op
     if (time_since_op <= milliseconds(100))
-        return sleep_for(time_since_op / 2);
+    {
+        sleep_for(time_since_op / 2);
+        return time_since_op;
+    }
 
-    return sleep_for(milliseconds(100));
+    sleep_for(milliseconds(100));
+    return time_since_op;
 }
 
 // throw if the worker thread threw an exception or not active
diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h
index e113e1d2..e6c21ec3 100644
--- a/include/spdlog/details/async_logger_impl.h
+++ b/include/spdlog/details/async_logger_impl.h
@@ -39,9 +39,10 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name,
         const It& end,
         size_t queue_size,
         const  async_overflow_policy overflow_policy,
-        const std::function<void()>& worker_warmup_cb) :
+        const std::function<void()>& worker_warmup_cb,
+        const std::chrono::milliseconds auto_flush_millis) :
     logger(logger_name, begin, end),
-    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, overflow_policy, worker_warmup_cb))
+    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, overflow_policy, worker_warmup_cb, auto_flush_millis))
 {
 }
 
@@ -49,15 +50,17 @@ 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) :
-    async_logger(logger_name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb) {}
+        const std::function<void()>& worker_warmup_cb,
+        const std::chrono::milliseconds auto_flush_millis) :
+    async_logger(logger_name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, auto_flush_millis) {}
 
 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) :
-    async_logger(logger_name, { single_sink }, queue_size, overflow_policy, worker_warmup_cb) {}
+        const std::function<void()>& worker_warmup_cb,
+        const std::chrono::milliseconds auto_flush_millis) :
+    async_logger(logger_name, { single_sink }, queue_size, overflow_policy, worker_warmup_cb, auto_flush_millis) {}
 
 
 inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter)

From 432e1109dd315c53934b260961a7a47d1c88fb57 Mon Sep 17 00:00:00 2001
From: Denis Ivaykin <denis.ivaykin@gmail.com>
Date: Mon, 11 May 2015 00:17:49 +0200
Subject: [PATCH 13/61] flush interval part 2

---
 include/spdlog/async_logger.h              |  6 +--
 include/spdlog/details/async_log_helper.h  | 60 +++++++++++-----------
 include/spdlog/details/async_logger_impl.h | 12 ++---
 include/spdlog/details/registry.h          |  6 ++-
 include/spdlog/details/spdlog_impl.h       |  4 +-
 include/spdlog/spdlog.h                    |  2 +-
 6 files changed, 47 insertions(+), 43 deletions(-)

diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h
index a802b03c..517ce92f 100644
--- a/include/spdlog/async_logger.h
+++ b/include/spdlog/async_logger.h
@@ -59,21 +59,21 @@ public:
                  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 auto_flush_millis = std::chrono::milliseconds::zero());
+                 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 auto_flush_millis = std::chrono::milliseconds::zero());
+                 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 auto_flush_millis = std::chrono::milliseconds::zero());
+                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());
 
 
 protected:
diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h
index 9fe38cff..6395567b 100644
--- a/include/spdlog/details/async_log_helper.h
+++ b/include/spdlog/details/async_log_helper.h
@@ -120,7 +120,7 @@ public:
                      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 auto_flush_millis = std::chrono::milliseconds::zero());
+                     const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero());
 
     void log(const details::log_msg& msg);
 
@@ -147,7 +147,7 @@ private:
     const std::function<void()> _worker_warmup_cb;
 
     // auto periodic sink flush parameter
-    const std::chrono::milliseconds _auto_flush_millis;
+    const std::chrono::milliseconds _flush_interval_ms;
 
     // worker thread
     std::thread _worker_thread;
@@ -160,10 +160,10 @@ private:
 
     // pop next message from the queue and process it
     // return true if a message was available (queue was not empty), will set the last_pop to the pop time
-    bool process_next_msg(clock::time_point& last_pop);
+    bool process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush);
 
     // sleep,yield or return immediatly using the time passed since last message as a hint
-    static std::chrono::nanoseconds sleep_or_yield(const clock::time_point& last_op_time);
+    static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time);
 
 };
 }
@@ -172,13 +172,13 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 // 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 auto_flush_millis):
+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),
     _overflow_policy(overflow_policy),
     _worker_warmup_cb(worker_warmup_cb),
-    _auto_flush_millis(auto_flush_millis),
+    _flush_interval_ms(flush_interval_ms),
     _worker_thread(&async_log_helper::worker_loop, this)
 {}
 
@@ -204,10 +204,12 @@ inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)
     async_msg new_msg(msg);
     if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)
     {
-        auto last_op_time = clock::now();
+        auto last_op_time = log_clock::now();
+        auto now = last_op_time;
         do
         {
-            sleep_or_yield(last_op_time);
+            now = log_clock::now();
+            sleep_or_yield(now, last_op_time);
         }
         while (!_q.enqueue(std::move(new_msg)));
     }
@@ -219,8 +221,9 @@ inline void spdlog::details::async_log_helper::worker_loop()
     try
     {
         if (_worker_warmup_cb) _worker_warmup_cb();
-        clock::time_point last_pop = clock::now();
-        while(process_next_msg(last_pop));
+        auto last_pop = log_clock::now();
+        auto last_flush = last_pop;
+        while(process_next_msg(last_pop, last_flush));
     }
     catch (const std::exception& ex)
     {
@@ -234,7 +237,7 @@ inline void spdlog::details::async_log_helper::worker_loop()
 
 // 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(clock::time_point& last_pop)
+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;
@@ -242,7 +245,7 @@ inline bool spdlog::details::async_log_helper::process_next_msg(clock::time_poin
 
     if (_q.dequeue(incoming_async_msg))
     {
-        last_pop = clock::now();
+        last_pop = log_clock::now();
 
         if(incoming_async_msg.level == level::off)
             return false;
@@ -254,12 +257,18 @@ inline bool spdlog::details::async_log_helper::process_next_msg(clock::time_poin
     }
     else //empty queue
     {
-        auto time_since_op = sleep_or_yield(last_pop);
-        if (_auto_flush_millis > std::chrono::milliseconds::zero() && time_since_op > _auto_flush_millis)
+        auto now = log_clock::now();
+        if (_flush_interval_ms > std::chrono::milliseconds::zero())
         {
-            for (auto &s : _sinks)
-                s->flush();
+            auto time_since_flush = now - last_flush;
+            if (time_since_flush >= _flush_interval_ms)
+            {
+                last_flush = now;
+                for (auto &s : _sinks)
+                    s->flush();
+            }
         }
+        sleep_or_yield(now, last_pop);
     }
     return true;
 }
@@ -271,34 +280,27 @@ inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_f
 
 
 // sleep,yield or return immediatly using the time passed since last message as a hint
-inline std::chrono::nanoseconds spdlog::details::async_log_helper::sleep_or_yield(const clock::time_point& last_op_time)
+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 = clock::now() - last_op_time;
+    auto time_since_op = now - last_op_time;
 
     // spin upto 1 ms
     if (time_since_op <= milliseconds(1))
-        return time_since_op;
+        return;
 
     // yield upto 10ms
     if (time_since_op <= milliseconds(10))
-    {
-        yield();
-        return time_since_op;
-    }
+        return yield();
 
 
     // sleep for half of duration since last op
     if (time_since_op <= milliseconds(100))
-    {
-        sleep_for(time_since_op / 2);
-        return time_since_op;
-    }
+        return sleep_for(time_since_op / 2);
 
-    sleep_for(milliseconds(100));
-    return time_since_op;
+    return sleep_for(milliseconds(100));
 }
 
 // throw if the worker thread threw an exception or not active
diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h
index e6c21ec3..f60407e3 100644
--- a/include/spdlog/details/async_logger_impl.h
+++ b/include/spdlog/details/async_logger_impl.h
@@ -40,9 +40,9 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name,
         size_t queue_size,
         const  async_overflow_policy overflow_policy,
         const std::function<void()>& worker_warmup_cb,
-        const std::chrono::milliseconds auto_flush_millis) :
+        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, auto_flush_millis))
+    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms))
 {
 }
 
@@ -51,16 +51,16 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name,
         size_t queue_size,
         const  async_overflow_policy overflow_policy,
         const std::function<void()>& worker_warmup_cb,
-        const std::chrono::milliseconds auto_flush_millis) :
-    async_logger(logger_name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, auto_flush_millis) {}
+        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 auto_flush_millis) :
-    async_logger(logger_name, { single_sink }, queue_size, overflow_policy, worker_warmup_cb, auto_flush_millis) {}
+        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::_set_formatter(spdlog::formatter_ptr msg_formatter)
diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index 5f708743..6092fe5f 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -69,7 +69,7 @@ public:
 
 
         if (_async_mode)
-            new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb);
+            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);
 
@@ -127,13 +127,14 @@ public:
         _level = log_level;
     }
 
-    void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb)
+    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<std::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()
@@ -167,6 +168,7 @@ private:
     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;
 };
 }
 }
diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h
index 5e1bc73a..cfd6f826 100644
--- a/include/spdlog/details/spdlog_impl.h
+++ b/include/spdlog/details/spdlog_impl.h
@@ -137,9 +137,9 @@ inline void spdlog::set_level(level::level_enum 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)
+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);
+    details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms);
 }
 
 inline void spdlog::set_sync_mode()
diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index 8601555f..5cec5623 100644
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -68,7 +68,7 @@ void set_level(level::level_enum log_level);
 // 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);
+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();

From a3dcb2b79e36d9c5d4e9a8718a1fe2cdc1f5af1c Mon Sep 17 00:00:00 2001
From: Denis Ivaykin <denis.ivaykin@gmail.com>
Date: Mon, 11 May 2015 00:21:55 +0200
Subject: [PATCH 14/61] details::os::now()

---
 include/spdlog/details/async_log_helper.h | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h
index 6395567b..9f7d2517 100644
--- a/include/spdlog/details/async_log_helper.h
+++ b/include/spdlog/details/async_log_helper.h
@@ -43,6 +43,7 @@
 #include "./mpmc_bounded_q.h"
 #include "./log_msg.h"
 #include "./format.h"
+#include "os.h"
 
 
 namespace spdlog
@@ -204,11 +205,11 @@ inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)
     async_msg new_msg(msg);
     if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)
     {
-        auto last_op_time = log_clock::now();
+        auto last_op_time = details::os::now();
         auto now = last_op_time;
         do
         {
-            now = log_clock::now();
+            now = details::os::now();
             sleep_or_yield(now, last_op_time);
         }
         while (!_q.enqueue(std::move(new_msg)));
@@ -221,7 +222,7 @@ inline void spdlog::details::async_log_helper::worker_loop()
     try
     {
         if (_worker_warmup_cb) _worker_warmup_cb();
-        auto last_pop = log_clock::now();
+        auto last_pop = details::os::now();
         auto last_flush = last_pop;
         while(process_next_msg(last_pop, last_flush));
     }
@@ -245,7 +246,7 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
 
     if (_q.dequeue(incoming_async_msg))
     {
-        last_pop = log_clock::now();
+        last_pop = details::os::now();
 
         if(incoming_async_msg.level == level::off)
             return false;
@@ -257,7 +258,7 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
     }
     else //empty queue
     {
-        auto now = log_clock::now();
+        auto now = details::os::now();
         if (_flush_interval_ms > std::chrono::milliseconds::zero())
         {
             auto time_since_flush = now - last_flush;

From fbd9d924d682f7fec3e660adf022fefb4c59d808 Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 11 May 2015 10:17:55 +0200
Subject: [PATCH 15/61] adds missing flush override to simple_file_sink

---
 include/spdlog/sinks/file_sinks.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 1c2f2998..79cbb4e4 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -47,6 +47,10 @@ public:
     {
         _file_helper.open(filename);
     }
+    void flush() override
+    {
+        _file_helper.flush();
+    }
 
 protected:
     void _sink_it(const details::log_msg& msg) override

From 2117568be5d259694c9ea1aa315fbc6bfd724d95 Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 11 May 2015 10:44:26 +0200
Subject: [PATCH 16/61] adds travis-ci automated testing

---
 .travis.yml       | 211 ++++++++++++++++++++++++++++++++++++++++++++++
 README.md         |  27 +++---
 example/Makefile  |  25 +++---
 install_libcxx.sh |  12 +++
 4 files changed, 247 insertions(+), 28 deletions(-)
 create mode 100644 .travis.yml
 create mode 100755 install_libcxx.sh

diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..8f9c693f
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,211 @@
+# Adapted from various sources, including:
+# - Louis Dionne's Hana: https://github.com/ldionne/hana
+# - Paul Fultz II's FIT: https://github.com/pfultz2/Fit
+# - Eric Niebler's range-v3: https://github.com/ericniebler/range-v3
+language: cpp
+
+# Test matrix:
+# - Build matrix per compiler: C++11/C++14 + Debug/Release
+# - Optionally: AddressSanitizer (ASAN)
+# - Valgrind: all release builds are also tested with valgrind
+# - clang 3.4, 3.5, 3.6, trunk
+#   - Note: 3.4 and trunk are tested with/without ASAN,
+#     the rest is only tested with ASAN=On.
+# - gcc 4.9, 5.0
+#
+matrix:
+  include:
+    # Test clang-3.5: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: &clang35
+    #     apt:
+    #       packages:
+    #         - clang-3.5
+    #         - valgrind
+    #       sources:
+    #         - ubuntu-toolchain-r-test
+    #         - llvm-toolchain-precise-3.5
+
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+
+    # Uncomment these to test without AddressSanitizer
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+
+    # Test clang-3.6: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: &clang36
+    #     apt:
+    #       packages:
+    #         - clang-3.6
+    #         - valgrind
+    #       sources:
+    #         - ubuntu-toolchain-r-test
+    #         - llvm-toolchain-precise-3.6
+
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+
+    # Uncomment these to test without AddressSanitizer
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+
+    # Test clang-3.7: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: &clang37
+        apt:
+          packages:
+            - clang-3.7
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # Test gcc-4.9: C++11, Build=Debug/Release, ASAN=Off
+    # - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: &gcc49
+    #     apt:
+    #       packages:
+    #         - g++-4.9
+    #         - valgrind
+    #       sources:
+    #         - ubuntu-toolchain-r-test
+
+    # - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: *gcc49
+
+    # Test gcc-5.0: C++11/14, Build=Debug/Release, ASAN=Off
+    # - env: GCC_VERSION=5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: &gcc5
+    #     apt:
+    #       packages:
+    #         - gcc-5
+    #         - valgrind
+    #       sources:
+    #         - ubuntu-toolchain-r-test
+
+    # - env: GCC_VERSION=5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: *gcc5
+
+    # - env: GCC_VERSION=5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: *gcc5
+
+    # - env: GCC_VERSION=5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: *gcc5
+
+# Install dependencies
+before_install:
+  - export CHECKOUT_PATH=`pwd`;
+  - if [ -n "$GCC_VERSION" ]; then export CXX="g++-${GCC_VERSION}" CC="gcc-${GCC_VERSION}"; fi
+  - if [ -n "$CLANG_VERSION" ]; then export CXX="clang++-${CLANG_VERSION}" CC="clang-${CLANG_VERSION}"; fi
+  - if [ "$CLANG_VERSION" == "3.4" ]; then export CXX="/usr/local/clang-3.4/bin/clang++" CC="/usr/local/clang-3.4/bin/clang"; fi
+  - which $CXX
+  - which $CC
+  - which valgrind
+  - if [ -n "$CLANG_VERSION" ]; then sudo CXX=$CXX CC=$CC ./install_libcxx.sh; fi
+
+install:
+  - cd $CHECKOUT_PATH
+
+  # Workaround for valgrind bug: https://bugs.kde.org/show_bug.cgi?id=326469.
+  # It is fixed in valgrind 3.10 so this won't be necessary if someone
+  # replaces the current valgrind (3.7) with valgrind-3.10
+  - sed -i 's/march=native/msse4.2/' example/Makefile
+
+  - if [ ! -d build ]; then mkdir build; fi
+  - export CXX_FLAGS=""
+  - export CXX_LINKER_FLAGS=""
+  - if [ -z "$BUILD_TYPE" ]; then export BUILD_TYPE=Release; fi
+  - if [ "$ASAN" == "On"]; then export CXX_FLAGS="${CXX_FLAGS} -fsanitize=address,undefined,integer -fno-omit-frame-pointer -fno-sanitize=unsigned-integer-overflow"; fi
+  - if [ -n "$CLANG_VERSION" ]; then CXX_FLAGS="${CXX_FLAGS} -D__extern_always_inline=inline"; fi
+  - if [ "$LIBCXX" == "On" ]; then CXX_FLAGS="${CXX_FLAGS} -stdlib=libc++ -I/usr/include/c++/v1/"; fi
+  - if [ "$LIBCXX" == "On" ]; then CXX_LINKER_FLAGS="${CXX_FLAGS} -L/usr/lib/ -lc++"; fi
+
+  # Build examples
+  - cd example
+  - make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1
+
+script:
+  - ./example
+  - ./bench
+  - valgrind --trace-children=yes --leak-check=full ./example
+  - valgrind --trace-children=yes --leak-check=full ./bench
+
+notifications:
+  email: false
diff --git a/README.md b/README.md
index 7db15533..a29d04df 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # spdlog
 
-Very fast, header only, C++ logging library.
+Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.org/gabime/spdlog.svg?branch=master)](https://travis-ci.org/gabime/spdlog)
 
 ## Install
 Just copy the files to your build tree and use a C++11 compiler
@@ -9,7 +9,7 @@ Just copy the files to your build tree and use a C++11 compiler
  * Linux (gcc 4.8.1+, clang 3.5+)
  * Windows (visual studio 2013+, mingw with g++ 4.9.1+)
  * Mac OSX (clang 3.5+)
- 
+
 ##Features
 * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below).
 * Headers only.
@@ -31,7 +31,7 @@ Just copy the files to your build tree and use a C++11 compiler
 
 ## Benchmarks
 
-Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz 
+Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
 
 #### Synchronous mode
 Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of 3 runs):
@@ -43,7 +43,7 @@ Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of
 |100|     15.008  |1.139s |4.512s     |0.497s|
 
 
-#### Asynchronous mode 
+#### Asynchronous mode
 Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes to put them in the async queue (in seconds, the best of 3 runs):
 
 |threads|g2log <sup>async logger</sup>   |spdlog <sup>async mode</sup>|
@@ -70,7 +70,7 @@ int main(int, char* [])
         console->info("Welcome to spdlog!") ;
         console->info("An info message example {}..", 1);
         console->info() << "Streams are supported too  " << 1;
-	
+
         //Formatting examples
         console->info("Easy padding in numbers like {:08d}", 12);
         console->info("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
@@ -80,7 +80,7 @@ int main(int, char* [])
         console->info("{:<30}", "left aligned");
         console->info("{:>30}", "right aligned");
         console->info("{:^30}", "centered");
-        
+
         //
         // Runtime log levels
         //
@@ -88,7 +88,7 @@ int main(int, char* [])
         console->debug("This message shold not be displayed!");
         console->set_level(spd::level::debug); // Set specific logger's log level
         console->debug("Now it should..");
-  
+
         //
         // Create a file rotating logger with 5mb size max and 3 rotated files
         //
@@ -100,8 +100,8 @@ int main(int, char* [])
         // Create a daily logger - a new file is created every day on 2:30am
         //
         auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30);
-        
-        // 
+
+        //
         // Customize msg format for all messages
         //
         spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
@@ -115,7 +115,7 @@ int main(int, char* [])
         //
         SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
         SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
-        
+
         //
         // Asynchronous logging is very fast..
         // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
@@ -124,14 +124,14 @@ int main(int, char* [])
         spdlog::set_async_mode(q_size);
         auto async_file= spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
         async_file->info() << "This is async log.." << "Should be very fast!";
-          
-        //      
+
+        //
         // syslog example. linux only..
         //
         #ifdef __linux__
         std::string ident = "spdlog-example";
         auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID);
-        syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!");       
+        syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!");
         #endif
     }
     catch (const spd::spdlog_ex& ex)
@@ -155,4 +155,3 @@ void custom_class_example()
 
 ## Documentation
 Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.
-
diff --git a/example/Makefile b/example/Makefile
index 80e6bd3d..8b17c7f2 100644
--- a/example/Makefile
+++ b/example/Makefile
@@ -1,32 +1,29 @@
 CXX	?= g++
-CXXFLAGS	= -march=native -Wall -Wshadow -Wextra -pedantic -std=c++11 -pthread -Wl,--no-as-needed  -I../include 
-CXX_RELEASE_FLAGS = -O3 -flto
-CXX_DEBUG_FLAGS= -g 
+CXXFLAGS	=
+CXX_FLAGS = -Wall -Wshadow -Wextra -pedantic -std=c++11 -pthread -I../include
+CXX_RELEASE_FLAGS = -O3 -march=native
+CXX_DEBUG_FLAGS= -g
 
 
 all:	example bench
 debug:	example-debug bench-debug
 
 example: example.cpp
-	$(CXX) example.cpp -o example $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
+	$(CXX) example.cpp -o example $(CXX_FLAGS) $(CXX_RELEASE_FLAGS) $(CXXFLAGS)
 
 bench: bench.cpp
-	$(CXX) bench.cpp -o bench $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-	
+	$(CXX) bench.cpp -o bench $(CXX_FLAGS) $(CXX_RELEASE_FLAGS) $(CXXFLAGS)
+
 
 example-debug: example.cpp
-	$(CXX) example.cpp -o example-debug $(CXXFLAGS) $(CXX_DEBUG_FLAGS)
-	
+	$(CXX) example.cpp -o example-debug $(CXX_FLAGS) $(CXX_DEBUG_FLAGS) $(CXXFLAGS)
+
 bench-debug: bench.cpp
-	$(CXX) bench.cpp -o bench-debug $(CXXFLAGS) $(CXX_DEBUG_FLAGS)	
-
-
+	$(CXX) bench.cpp -o bench-debug $(CXX_FLAGS) $(CXX_DEBUG_FLAGS) $(CXXFLAGS)
 
 clean:
-	rm -f *.o logs/*.txt example example-debug bench bench-debug 
+	rm -f *.o logs/*.txt example example-debug bench bench-debug
 
 
 rebuild: clean all
 rebuild-debug: clean debug
-
-
diff --git a/install_libcxx.sh b/install_libcxx.sh
new file mode 100755
index 00000000..47c79d4f
--- /dev/null
+++ b/install_libcxx.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+#
+# Install libc++ under travis
+
+svn --quiet co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx
+mkdir libcxx/build
+(cd libcxx/build && cmake .. -DLIBCXX_CXX_ABI=libstdc++ -DLIBCXX_CXX_ABI_INCLUDE_PATHS="/usr/include/c++/4.6;/usr/include/c++/4.6/x86_64-linux-gnu")
+make -C libcxx/build cxx -j2
+sudo cp libcxx/build/lib/libc++.so.1.0 /usr/lib/
+sudo cp -r libcxx/build/include/c++/v1 /usr/include/c++/v1/
+sudo ln -sf /usr/lib/libc++.so.1.0 /usr/lib/libc++.so
+sudo ln -sf /usr/lib/libc++.so.1.0 /usr/lib/libc++.so.1

From 1b31c8cab4231ef58018910323139f48a0be1ae6 Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 11 May 2015 11:25:34 +0200
Subject: [PATCH 17/61] enable clang 3.5, 3.6, and gcc 4.9

---
 .travis.yml | 58 ++++++++++++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 8f9c693f..6e261f2c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -16,16 +16,16 @@ language: cpp
 matrix:
   include:
     # Test clang-3.5: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: &clang35
-    #     apt:
-    #       packages:
-    #         - clang-3.5
-    #         - valgrind
-    #       sources:
-    #         - ubuntu-toolchain-r-test
-    #         - llvm-toolchain-precise-3.5
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: &clang35
+        apt:
+          packages:
+            - clang-3.5
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
 
     # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
     #   os: linux
@@ -54,16 +54,16 @@ matrix:
     #   addons: *clang35
 
     # Test clang-3.6: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: &clang36
-    #     apt:
-    #       packages:
-    #         - clang-3.6
-    #         - valgrind
-    #       sources:
-    #         - ubuntu-toolchain-r-test
-    #         - llvm-toolchain-precise-3.6
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: &clang36
+        apt:
+          packages:
+            - clang-3.6
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
 
     # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
     #   os: linux
@@ -132,15 +132,15 @@ matrix:
     #   addons: *clang37
 
     # Test gcc-4.9: C++11, Build=Debug/Release, ASAN=Off
-    # - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: &gcc49
-    #     apt:
-    #       packages:
-    #         - g++-4.9
-    #         - valgrind
-    #       sources:
-    #         - ubuntu-toolchain-r-test
+    - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
+      os: linux
+      addons: &gcc49
+        apt:
+          packages:
+            - g++-4.9
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
 
     # - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
     #   os: linux

From 3e2364bb57178ea7a5c1e9f039b3df5f1ea3fa7d Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 11 May 2015 11:37:19 +0200
Subject: [PATCH 18/61] enable debug/release and c++11/14

---
 .travis.yml | 171 +++++++++++++++++++++-------------------------------
 1 file changed, 69 insertions(+), 102 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 6e261f2c..18cc4a5e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -27,31 +27,28 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise-3.5
 
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang35
 
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-
-    # Uncomment these to test without AddressSanitizer
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang35
 
     # Test clang-3.6: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
     - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
@@ -65,31 +62,28 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise-3.6
 
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang36
 
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-
-    # Uncomment these to test without AddressSanitizer
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang36
 
     # Test clang-3.7: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
     - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
@@ -103,33 +97,27 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise
 
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang37
 
     # Test gcc-4.9: C++11, Build=Debug/Release, ASAN=Off
     - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
@@ -142,32 +130,9 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
 
-    # - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: *gcc49
-
-    # Test gcc-5.0: C++11/14, Build=Debug/Release, ASAN=Off
-    # - env: GCC_VERSION=5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: &gcc5
-    #     apt:
-    #       packages:
-    #         - gcc-5
-    #         - valgrind
-    #       sources:
-    #         - ubuntu-toolchain-r-test
-
-    # - env: GCC_VERSION=5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: *gcc5
-
-    # - env: GCC_VERSION=5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: *gcc5
-
-    # - env: GCC_VERSION=5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: *gcc5
+    - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
+      os: linux
+      addons: *gcc49
 
 # Install dependencies
 before_install:
@@ -196,10 +161,12 @@ install:
   - if [ -n "$CLANG_VERSION" ]; then CXX_FLAGS="${CXX_FLAGS} -D__extern_always_inline=inline"; fi
   - if [ "$LIBCXX" == "On" ]; then CXX_FLAGS="${CXX_FLAGS} -stdlib=libc++ -I/usr/include/c++/v1/"; fi
   - if [ "$LIBCXX" == "On" ]; then CXX_LINKER_FLAGS="${CXX_FLAGS} -L/usr/lib/ -lc++"; fi
+  - CXX_FLAGS="${CXX_FLAGS} -std=${CPP}"
 
   # Build examples
   - cd example
-  - make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1
+  - if [ "$BUILD_TYPE" == "Release" ]; then make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; fi
+  - if [ "$BUILD_TYPE" == "Debug" ]; then make debug CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; fi
 
 script:
   - ./example

From 77b68dd826dd5285e43a45d025d5df810ebde0a6 Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 11 May 2015 10:44:26 +0200
Subject: [PATCH 19/61] adds travis-ci automated testing

---
 .travis.yml       | 211 ++++++++++++++++++++++++++++++++++++++++++++++
 README.md         |  27 +++---
 example/Makefile  |  25 +++---
 install_libcxx.sh |  12 +++
 4 files changed, 247 insertions(+), 28 deletions(-)
 create mode 100644 .travis.yml
 create mode 100755 install_libcxx.sh

diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..8f9c693f
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,211 @@
+# Adapted from various sources, including:
+# - Louis Dionne's Hana: https://github.com/ldionne/hana
+# - Paul Fultz II's FIT: https://github.com/pfultz2/Fit
+# - Eric Niebler's range-v3: https://github.com/ericniebler/range-v3
+language: cpp
+
+# Test matrix:
+# - Build matrix per compiler: C++11/C++14 + Debug/Release
+# - Optionally: AddressSanitizer (ASAN)
+# - Valgrind: all release builds are also tested with valgrind
+# - clang 3.4, 3.5, 3.6, trunk
+#   - Note: 3.4 and trunk are tested with/without ASAN,
+#     the rest is only tested with ASAN=On.
+# - gcc 4.9, 5.0
+#
+matrix:
+  include:
+    # Test clang-3.5: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: &clang35
+    #     apt:
+    #       packages:
+    #         - clang-3.5
+    #         - valgrind
+    #       sources:
+    #         - ubuntu-toolchain-r-test
+    #         - llvm-toolchain-precise-3.5
+
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+
+    # Uncomment these to test without AddressSanitizer
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang35
+
+    # Test clang-3.6: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: &clang36
+    #     apt:
+    #       packages:
+    #         - clang-3.6
+    #         - valgrind
+    #       sources:
+    #         - ubuntu-toolchain-r-test
+    #         - llvm-toolchain-precise-3.6
+
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+
+    # Uncomment these to test without AddressSanitizer
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang36
+
+    # Test clang-3.7: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: &clang37
+        apt:
+          packages:
+            - clang-3.7
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+    #   os: linux
+    #   addons: *clang37
+
+    # Test gcc-4.9: C++11, Build=Debug/Release, ASAN=Off
+    # - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: &gcc49
+    #     apt:
+    #       packages:
+    #         - g++-4.9
+    #         - valgrind
+    #       sources:
+    #         - ubuntu-toolchain-r-test
+
+    # - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: *gcc49
+
+    # Test gcc-5.0: C++11/14, Build=Debug/Release, ASAN=Off
+    # - env: GCC_VERSION=5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: &gcc5
+    #     apt:
+    #       packages:
+    #         - gcc-5
+    #         - valgrind
+    #       sources:
+    #         - ubuntu-toolchain-r-test
+
+    # - env: GCC_VERSION=5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: *gcc5
+
+    # - env: GCC_VERSION=5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: *gcc5
+
+    # - env: GCC_VERSION=5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=Off
+    #   os: linux
+    #   addons: *gcc5
+
+# Install dependencies
+before_install:
+  - export CHECKOUT_PATH=`pwd`;
+  - if [ -n "$GCC_VERSION" ]; then export CXX="g++-${GCC_VERSION}" CC="gcc-${GCC_VERSION}"; fi
+  - if [ -n "$CLANG_VERSION" ]; then export CXX="clang++-${CLANG_VERSION}" CC="clang-${CLANG_VERSION}"; fi
+  - if [ "$CLANG_VERSION" == "3.4" ]; then export CXX="/usr/local/clang-3.4/bin/clang++" CC="/usr/local/clang-3.4/bin/clang"; fi
+  - which $CXX
+  - which $CC
+  - which valgrind
+  - if [ -n "$CLANG_VERSION" ]; then sudo CXX=$CXX CC=$CC ./install_libcxx.sh; fi
+
+install:
+  - cd $CHECKOUT_PATH
+
+  # Workaround for valgrind bug: https://bugs.kde.org/show_bug.cgi?id=326469.
+  # It is fixed in valgrind 3.10 so this won't be necessary if someone
+  # replaces the current valgrind (3.7) with valgrind-3.10
+  - sed -i 's/march=native/msse4.2/' example/Makefile
+
+  - if [ ! -d build ]; then mkdir build; fi
+  - export CXX_FLAGS=""
+  - export CXX_LINKER_FLAGS=""
+  - if [ -z "$BUILD_TYPE" ]; then export BUILD_TYPE=Release; fi
+  - if [ "$ASAN" == "On"]; then export CXX_FLAGS="${CXX_FLAGS} -fsanitize=address,undefined,integer -fno-omit-frame-pointer -fno-sanitize=unsigned-integer-overflow"; fi
+  - if [ -n "$CLANG_VERSION" ]; then CXX_FLAGS="${CXX_FLAGS} -D__extern_always_inline=inline"; fi
+  - if [ "$LIBCXX" == "On" ]; then CXX_FLAGS="${CXX_FLAGS} -stdlib=libc++ -I/usr/include/c++/v1/"; fi
+  - if [ "$LIBCXX" == "On" ]; then CXX_LINKER_FLAGS="${CXX_FLAGS} -L/usr/lib/ -lc++"; fi
+
+  # Build examples
+  - cd example
+  - make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1
+
+script:
+  - ./example
+  - ./bench
+  - valgrind --trace-children=yes --leak-check=full ./example
+  - valgrind --trace-children=yes --leak-check=full ./bench
+
+notifications:
+  email: false
diff --git a/README.md b/README.md
index 7db15533..a29d04df 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # spdlog
 
-Very fast, header only, C++ logging library.
+Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.org/gabime/spdlog.svg?branch=master)](https://travis-ci.org/gabime/spdlog)
 
 ## Install
 Just copy the files to your build tree and use a C++11 compiler
@@ -9,7 +9,7 @@ Just copy the files to your build tree and use a C++11 compiler
  * Linux (gcc 4.8.1+, clang 3.5+)
  * Windows (visual studio 2013+, mingw with g++ 4.9.1+)
  * Mac OSX (clang 3.5+)
- 
+
 ##Features
 * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below).
 * Headers only.
@@ -31,7 +31,7 @@ Just copy the files to your build tree and use a C++11 compiler
 
 ## Benchmarks
 
-Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz 
+Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
 
 #### Synchronous mode
 Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of 3 runs):
@@ -43,7 +43,7 @@ Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of
 |100|     15.008  |1.139s |4.512s     |0.497s|
 
 
-#### Asynchronous mode 
+#### Asynchronous mode
 Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes to put them in the async queue (in seconds, the best of 3 runs):
 
 |threads|g2log <sup>async logger</sup>   |spdlog <sup>async mode</sup>|
@@ -70,7 +70,7 @@ int main(int, char* [])
         console->info("Welcome to spdlog!") ;
         console->info("An info message example {}..", 1);
         console->info() << "Streams are supported too  " << 1;
-	
+
         //Formatting examples
         console->info("Easy padding in numbers like {:08d}", 12);
         console->info("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
@@ -80,7 +80,7 @@ int main(int, char* [])
         console->info("{:<30}", "left aligned");
         console->info("{:>30}", "right aligned");
         console->info("{:^30}", "centered");
-        
+
         //
         // Runtime log levels
         //
@@ -88,7 +88,7 @@ int main(int, char* [])
         console->debug("This message shold not be displayed!");
         console->set_level(spd::level::debug); // Set specific logger's log level
         console->debug("Now it should..");
-  
+
         //
         // Create a file rotating logger with 5mb size max and 3 rotated files
         //
@@ -100,8 +100,8 @@ int main(int, char* [])
         // Create a daily logger - a new file is created every day on 2:30am
         //
         auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30);
-        
-        // 
+
+        //
         // Customize msg format for all messages
         //
         spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
@@ -115,7 +115,7 @@ int main(int, char* [])
         //
         SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
         SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
-        
+
         //
         // Asynchronous logging is very fast..
         // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
@@ -124,14 +124,14 @@ int main(int, char* [])
         spdlog::set_async_mode(q_size);
         auto async_file= spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
         async_file->info() << "This is async log.." << "Should be very fast!";
-          
-        //      
+
+        //
         // syslog example. linux only..
         //
         #ifdef __linux__
         std::string ident = "spdlog-example";
         auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID);
-        syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!");       
+        syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!");
         #endif
     }
     catch (const spd::spdlog_ex& ex)
@@ -155,4 +155,3 @@ void custom_class_example()
 
 ## Documentation
 Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.
-
diff --git a/example/Makefile b/example/Makefile
index 80e6bd3d..8b17c7f2 100644
--- a/example/Makefile
+++ b/example/Makefile
@@ -1,32 +1,29 @@
 CXX	?= g++
-CXXFLAGS	= -march=native -Wall -Wshadow -Wextra -pedantic -std=c++11 -pthread -Wl,--no-as-needed  -I../include 
-CXX_RELEASE_FLAGS = -O3 -flto
-CXX_DEBUG_FLAGS= -g 
+CXXFLAGS	=
+CXX_FLAGS = -Wall -Wshadow -Wextra -pedantic -std=c++11 -pthread -I../include
+CXX_RELEASE_FLAGS = -O3 -march=native
+CXX_DEBUG_FLAGS= -g
 
 
 all:	example bench
 debug:	example-debug bench-debug
 
 example: example.cpp
-	$(CXX) example.cpp -o example $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
+	$(CXX) example.cpp -o example $(CXX_FLAGS) $(CXX_RELEASE_FLAGS) $(CXXFLAGS)
 
 bench: bench.cpp
-	$(CXX) bench.cpp -o bench $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-	
+	$(CXX) bench.cpp -o bench $(CXX_FLAGS) $(CXX_RELEASE_FLAGS) $(CXXFLAGS)
+
 
 example-debug: example.cpp
-	$(CXX) example.cpp -o example-debug $(CXXFLAGS) $(CXX_DEBUG_FLAGS)
-	
+	$(CXX) example.cpp -o example-debug $(CXX_FLAGS) $(CXX_DEBUG_FLAGS) $(CXXFLAGS)
+
 bench-debug: bench.cpp
-	$(CXX) bench.cpp -o bench-debug $(CXXFLAGS) $(CXX_DEBUG_FLAGS)	
-
-
+	$(CXX) bench.cpp -o bench-debug $(CXX_FLAGS) $(CXX_DEBUG_FLAGS) $(CXXFLAGS)
 
 clean:
-	rm -f *.o logs/*.txt example example-debug bench bench-debug 
+	rm -f *.o logs/*.txt example example-debug bench bench-debug
 
 
 rebuild: clean all
 rebuild-debug: clean debug
-
-
diff --git a/install_libcxx.sh b/install_libcxx.sh
new file mode 100755
index 00000000..47c79d4f
--- /dev/null
+++ b/install_libcxx.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+#
+# Install libc++ under travis
+
+svn --quiet co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx
+mkdir libcxx/build
+(cd libcxx/build && cmake .. -DLIBCXX_CXX_ABI=libstdc++ -DLIBCXX_CXX_ABI_INCLUDE_PATHS="/usr/include/c++/4.6;/usr/include/c++/4.6/x86_64-linux-gnu")
+make -C libcxx/build cxx -j2
+sudo cp libcxx/build/lib/libc++.so.1.0 /usr/lib/
+sudo cp -r libcxx/build/include/c++/v1 /usr/include/c++/v1/
+sudo ln -sf /usr/lib/libc++.so.1.0 /usr/lib/libc++.so
+sudo ln -sf /usr/lib/libc++.so.1.0 /usr/lib/libc++.so.1

From 97d56e769392304ea9a5ada68b03e5af1087c37d Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 11 May 2015 11:25:34 +0200
Subject: [PATCH 20/61] enable clang 3.5, 3.6, and gcc 4.9

---
 .travis.yml | 58 ++++++++++++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 8f9c693f..6e261f2c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -16,16 +16,16 @@ language: cpp
 matrix:
   include:
     # Test clang-3.5: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: &clang35
-    #     apt:
-    #       packages:
-    #         - clang-3.5
-    #         - valgrind
-    #       sources:
-    #         - ubuntu-toolchain-r-test
-    #         - llvm-toolchain-precise-3.5
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: &clang35
+        apt:
+          packages:
+            - clang-3.5
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
 
     # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
     #   os: linux
@@ -54,16 +54,16 @@ matrix:
     #   addons: *clang35
 
     # Test clang-3.6: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: &clang36
-    #     apt:
-    #       packages:
-    #         - clang-3.6
-    #         - valgrind
-    #       sources:
-    #         - ubuntu-toolchain-r-test
-    #         - llvm-toolchain-precise-3.6
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: &clang36
+        apt:
+          packages:
+            - clang-3.6
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
 
     # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
     #   os: linux
@@ -132,15 +132,15 @@ matrix:
     #   addons: *clang37
 
     # Test gcc-4.9: C++11, Build=Debug/Release, ASAN=Off
-    # - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: &gcc49
-    #     apt:
-    #       packages:
-    #         - g++-4.9
-    #         - valgrind
-    #       sources:
-    #         - ubuntu-toolchain-r-test
+    - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
+      os: linux
+      addons: &gcc49
+        apt:
+          packages:
+            - g++-4.9
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
 
     # - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
     #   os: linux

From 48ff5cd34135a6b9ba5ff09077ee8b01ad21187f Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 11 May 2015 11:37:19 +0200
Subject: [PATCH 21/61] enable debug/release and c++11/14

---
 .travis.yml | 171 +++++++++++++++++++++-------------------------------
 1 file changed, 69 insertions(+), 102 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 6e261f2c..18cc4a5e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -27,31 +27,28 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise-3.5
 
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang35
 
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-
-    # Uncomment these to test without AddressSanitizer
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
-    # - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang35
+    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang35
 
     # Test clang-3.6: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
     - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
@@ -65,31 +62,28 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise-3.6
 
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang36
 
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-
-    # Uncomment these to test without AddressSanitizer
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
-    # - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang36
+    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang36
 
     # Test clang-3.7: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
     - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
@@ -103,33 +97,27 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise
 
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
-
-    # - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-    #   os: linux
-    #   addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang37
+    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
+      os: linux
+      addons: *clang37
 
     # Test gcc-4.9: C++11, Build=Debug/Release, ASAN=Off
     - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
@@ -142,32 +130,9 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
 
-    # - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: *gcc49
-
-    # Test gcc-5.0: C++11/14, Build=Debug/Release, ASAN=Off
-    # - env: GCC_VERSION=5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: &gcc5
-    #     apt:
-    #       packages:
-    #         - gcc-5
-    #         - valgrind
-    #       sources:
-    #         - ubuntu-toolchain-r-test
-
-    # - env: GCC_VERSION=5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: *gcc5
-
-    # - env: GCC_VERSION=5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: *gcc5
-
-    # - env: GCC_VERSION=5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=Off
-    #   os: linux
-    #   addons: *gcc5
+    - env: GCC_VERSION=4.9 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
+      os: linux
+      addons: *gcc49
 
 # Install dependencies
 before_install:
@@ -196,10 +161,12 @@ install:
   - if [ -n "$CLANG_VERSION" ]; then CXX_FLAGS="${CXX_FLAGS} -D__extern_always_inline=inline"; fi
   - if [ "$LIBCXX" == "On" ]; then CXX_FLAGS="${CXX_FLAGS} -stdlib=libc++ -I/usr/include/c++/v1/"; fi
   - if [ "$LIBCXX" == "On" ]; then CXX_LINKER_FLAGS="${CXX_FLAGS} -L/usr/lib/ -lc++"; fi
+  - CXX_FLAGS="${CXX_FLAGS} -std=${CPP}"
 
   # Build examples
   - cd example
-  - make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1
+  - if [ "$BUILD_TYPE" == "Release" ]; then make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; fi
+  - if [ "$BUILD_TYPE" == "Debug" ]; then make debug CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; fi
 
 script:
   - ./example

From 5216f574020053945330b7cc91f125669a801d8e Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 11 May 2015 12:00:08 +0200
Subject: [PATCH 22/61] fixup: fix std=c++XX in travis script

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 18cc4a5e..0f1e32ec 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -161,7 +161,7 @@ install:
   - if [ -n "$CLANG_VERSION" ]; then CXX_FLAGS="${CXX_FLAGS} -D__extern_always_inline=inline"; fi
   - if [ "$LIBCXX" == "On" ]; then CXX_FLAGS="${CXX_FLAGS} -stdlib=libc++ -I/usr/include/c++/v1/"; fi
   - if [ "$LIBCXX" == "On" ]; then CXX_LINKER_FLAGS="${CXX_FLAGS} -L/usr/lib/ -lc++"; fi
-  - CXX_FLAGS="${CXX_FLAGS} -std=${CPP}"
+  - CXX_FLAGS="${CXX_FLAGS} -std=c++${CPP}"
 
   # Build examples
   - cd example

From 619644fea9c86e4bdaddf6f91f380abbbb654e5b Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Mon, 11 May 2015 16:15:27 +0300
Subject: [PATCH 23/61] Removed valgrind check of bench from travis. It will
 take forever

---
 .travis.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 0f1e32ec..a600b9cf 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -170,9 +170,7 @@ install:
 
 script:
   - ./example
-  - ./bench
   - valgrind --trace-children=yes --leak-check=full ./example
-  - valgrind --trace-children=yes --leak-check=full ./bench
 
 notifications:
   email: false

From 616d777f439fdf36304bf0acea8b515d0e12717a Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Tue, 12 May 2015 00:19:27 +0300
Subject: [PATCH 24/61] Fixed travis builds

---
 .travis.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index a600b9cf..8b8e2df3 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -165,12 +165,12 @@ install:
 
   # Build examples
   - cd example
-  - if [ "$BUILD_TYPE" == "Release" ]; then make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; fi
-  - if [ "$BUILD_TYPE" == "Debug" ]; then make debug CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; fi
+  - if [ "$BUILD_TYPE" == "Release" ]; then make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; export BIN=example; fi
+  - if [ "$BUILD_TYPE" == "Debug" ]; then make debug CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; export BIN=example-debug; fi
 
 script:
-  - ./example
-  - valgrind --trace-children=yes --leak-check=full ./example
+  - ./"${BIN}"
+  - valgrind --trace-children=yes --leak-check=full ./"${BIN}"
 
 notifications:
   email: false

From 1b2c8b9d3eb7f8d925ea8fc3ea6a62e895864b28 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Tue, 12 May 2015 18:54:36 +0300
Subject: [PATCH 25/61] Refactored periodic flush in async_log_helper

---
 include/spdlog/details/async_log_helper.h | 26 +++++++++++++----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h
index 9f7d2517..59c1b2dc 100644
--- a/include/spdlog/details/async_log_helper.h
+++ b/include/spdlog/details/async_log_helper.h
@@ -66,7 +66,7 @@ class async_log_helper
         async_msg() = default;
         ~async_msg() = default;
 
-        async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
+async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
         logger_name(std::move(other.logger_name)),
                     level(std::move(other.level)),
                     time(std::move(other.time)),
@@ -163,9 +163,13 @@ private:
     // return true if a message was available (queue was not empty), will set the last_pop to the pop time
     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);
 
+
+
 };
 }
 }
@@ -259,21 +263,21 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
     else //empty queue
     {
         auto now = details::os::now();
-        if (_flush_interval_ms > std::chrono::milliseconds::zero())
-        {
-            auto time_since_flush = now - last_flush;
-            if (time_since_flush >= _flush_interval_ms)
-            {
-                last_flush = now;
-                for (auto &s : _sinks)
-                    s->flush();
-            }
-        }
+        handle_flush_interval(now, last_flush);
         sleep_or_yield(now, last_pop);
     }
     return true;
 }
 
+inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush)
+{
+    if (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms)
+    {
+        for (auto &s : _sinks)
+            s->flush();
+        now = last_flush = details::os::now();
+    }
+}
 inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)
 {
     _formatter = msg_formatter;

From 1dcaa45443015215d329e9837cf6c4473ec9a8ab Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Tue, 12 May 2015 19:03:01 +0300
Subject: [PATCH 26/61] fixed compliation error on gcc 4.8.x

---
 include/spdlog/details/registry.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index b5e1346f..fd8e4be9 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -158,7 +158,7 @@ private:
             throw spdlog_ex("logger with name " + logger_name + " already exists");
         _loggers[logger->name()] = logger;
     }
-    registry_t<Mutex>() = default;
+    registry_t<Mutex>(){}
     registry_t<Mutex>(const registry_t<Mutex>&) = delete;
     registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
     Mutex _mutex;

From 6c7f4ed31858f4d0d8bfd0935d1d47512c0d0374 Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Tue, 12 May 2015 19:44:50 +0300
Subject: [PATCH 27/61] Update .travis.yml

---
 .travis.yml | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 8b8e2df3..1af00f12 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -119,6 +119,22 @@ matrix:
       os: linux
       addons: *clang37
 
+
+# Test gcc-4.8: C++11, Build=Debug/Release, ASAN=Off
+    - env: GCC_VERSION=4.8 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
+      os: linux
+      addons: &gcc48
+        apt:
+          packages:
+            - g++-4.8
+            - valgrind
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - env: GCC_VERSION=4.8 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=Off
+      os: linux
+      addons: *gcc48
+      
     # Test gcc-4.9: C++11, Build=Debug/Release, ASAN=Off
     - env: GCC_VERSION=4.9 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off
       os: linux

From 8c4096cf2cd74d0394bcd7b2f357a9526d4b673e Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Fri, 15 May 2015 12:36:17 +0300
Subject: [PATCH 28/61] Shortened travis script

---
 .travis.yml | 56 ++---------------------------------------------------
 1 file changed, 2 insertions(+), 54 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 1af00f12..422223bd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -27,63 +27,11 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise-3.5
 
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang35
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang35
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang35
-
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang35
+ 
     - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
       os: linux
       addons: *clang35
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang35
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang35
-
-    # Test clang-3.6: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
-    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
-      os: linux
-      addons: &clang36
-        apt:
-          packages:
-            - clang-3.6
-            - valgrind
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang36
-    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang36
-    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang36
-
-    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang36
-    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang36
-    - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang36
-    - env: CLANG_VERSION=3.6 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang36
+    
 
     # Test clang-3.7: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
     - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On

From 056352cf42b1cee4c96eab6d7ae9f8d2a65cde06 Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Fri, 15 May 2015 12:52:04 +0300
Subject: [PATCH 29/61] travis force make rebuild

---
 .travis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 422223bd..76822575 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -129,8 +129,8 @@ install:
 
   # Build examples
   - cd example
-  - if [ "$BUILD_TYPE" == "Release" ]; then make CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; export BIN=example; fi
-  - if [ "$BUILD_TYPE" == "Debug" ]; then make debug CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; export BIN=example-debug; fi
+  - if [ "$BUILD_TYPE" == "Release" ]; then make rebuild CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; export BIN=example; fi
+  - if [ "$BUILD_TYPE" == "Debug" ]; then make rebuild debug CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; export BIN=example-debug; fi
 
 script:
   - ./"${BIN}"

From 2f81e54568af44ad980808321b152e6679df1fef Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 20:30:37 +0300
Subject: [PATCH 30/61] Added unit tests (catch based)

---
 tests/Makefile              |   12 +
 tests/catch.hpp             | 9427 +++++++++++++++++++++++++++++++++++
 tests/file_log.cpp          |  136 +
 tests/format.cpp            |   87 +
 tests/includes.h            |   10 +
 tests/logs/placeholder.txt  |    0
 tests/main.cpp              |    2 +
 tests/registry.cpp          |   53 +
 tests/tests.vcxproj         |   89 +
 tests/tests.vcxproj.filters |   16 +
 10 files changed, 9832 insertions(+)
 create mode 100644 tests/Makefile
 create mode 100644 tests/catch.hpp
 create mode 100644 tests/file_log.cpp
 create mode 100644 tests/format.cpp
 create mode 100644 tests/includes.h
 create mode 100644 tests/logs/placeholder.txt
 create mode 100644 tests/main.cpp
 create mode 100644 tests/registry.cpp
 create mode 100644 tests/tests.vcxproj
 create mode 100644 tests/tests.vcxproj.filters

diff --git a/tests/Makefile b/tests/Makefile
new file mode 100644
index 00000000..7580ee7d
--- /dev/null
+++ b/tests/Makefile
@@ -0,0 +1,12 @@
+CXX	?= g++
+CXXFLAGS	=  -D_WIN32_WINNT=0x600 -march=native -Wall -Wextra -Wshadow -pedantic -std=c++11 -pthread -Wl,--no-as-needed  -I../include 
+
+all: %.cpp
+    $(CXX) $^ -o tests $(CXXFLAGS) $(CXX_RELEASE_FLAGS)    
+clean:
+    rm -f tests *.o logs/*     
+ 
+rebuild: clean all
+
+
+
diff --git a/tests/catch.hpp b/tests/catch.hpp
new file mode 100644
index 00000000..5b616a2b
--- /dev/null
+++ b/tests/catch.hpp
@@ -0,0 +1,9427 @@
+/*
+ *  CATCH v1.1 build 1 (master branch)
+ *  Generated: 2015-03-27 18:00:16.346230
+ *  ----------------------------------------------------------
+ *  This file has been merged from multiple headers. Please don't edit it directly
+ *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
+#define TWOBLUECUBES_CATCH_HPP_INCLUDED
+
+// #included from: internal/catch_suppress_warnings.h
+
+#define TWOBLUECUBES_CATCH_SUPPRESS_WARNINGS_H_INCLUDED
+
+#ifdef __clang__
+#   ifdef __ICC // icpc defines the __clang__ macro
+#       pragma warning(push)
+#       pragma warning(disable: 161 1682)
+#   else // __ICC
+#       pragma clang diagnostic ignored "-Wglobal-constructors"
+#       pragma clang diagnostic ignored "-Wvariadic-macros"
+#       pragma clang diagnostic ignored "-Wc99-extensions"
+#       pragma clang diagnostic ignored "-Wunused-variable"
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wpadded"
+#       pragma clang diagnostic ignored "-Wc++98-compat"
+#       pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic ignored "-Wvariadic-macros"
+#    pragma GCC diagnostic ignored "-Wunused-variable"
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wpadded"
+#endif
+
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
+#endif
+
+#ifdef CATCH_IMPL
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+// #included from: internal/catch_notimplemented_exception.h
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
+
+// #included from: catch_common.h
+#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
+
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+
+#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
+#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )
+
+#include <sstream>
+#include <stdexcept>
+#include <algorithm>
+
+// #included from: catch_compiler_capabilities.h
+#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Much of the following code is based on Boost (1.53)
+
+#ifdef __clang__
+
+#  if __has_feature(cxx_nullptr)
+#    define CATCH_CONFIG_CPP11_NULLPTR
+#  endif
+
+#  if __has_feature(cxx_noexcept)
+#    define CATCH_CONFIG_CPP11_NOEXCEPT
+#  endif
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// Borland
+#ifdef __BORLANDC__
+
+#if (__BORLANDC__ > 0x582 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __BORLANDC__
+
+////////////////////////////////////////////////////////////////////////////////
+// EDG
+#ifdef __EDG_VERSION__
+
+#if (__EDG_VERSION__ > 238 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __EDG_VERSION__
+
+////////////////////////////////////////////////////////////////////////////////
+// Digital Mars
+#ifdef __DMC__
+
+#if (__DMC__ > 0x840 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __DMC__
+
+////////////////////////////////////////////////////////////////////////////////
+// GCC
+#ifdef __GNUC__
+
+#if __GNUC__ < 3
+
+#if (__GNUC_MINOR__ >= 96 )
+//#define CATCH_CONFIG_SFINAE
+#endif
+
+#elif __GNUC__ >= 3
+
+// #define CATCH_CONFIG_SFINAE // Taking this out completely for now
+
+#endif // __GNUC__ < 3
+
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) )
+
+#define CATCH_CONFIG_CPP11_NULLPTR
+#endif
+
+#endif // __GNUC__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#ifdef _MSC_VER
+
+#if (_MSC_VER >= 1600)
+#define CATCH_CONFIG_CPP11_NULLPTR
+#endif
+
+#if (_MSC_VER >= 1310 ) // (VC++ 7.0+)
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // _MSC_VER
+
+// Use variadic macros if the compiler supports them
+#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
+    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
+    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
+
+#ifndef CATCH_CONFIG_NO_VARIADIC_MACROS
+#define CATCH_CONFIG_VARIADIC_MACROS
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// C++ language feature support
+
+// detect language version:
+#if (__cplusplus == 201103L)
+#  define CATCH_CPP11
+#  define CATCH_CPP11_OR_GREATER
+#elif (__cplusplus >= 201103L)
+#  define CATCH_CPP11_OR_GREATER
+#endif
+
+// noexcept support:
+#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
+#  define CATCH_NOEXCEPT noexcept
+#  define CATCH_NOEXCEPT_IS(x) noexcept(x)
+#else
+#  define CATCH_NOEXCEPT throw()
+#  define CATCH_NOEXCEPT_IS(x)
+#endif
+
+namespace Catch {
+
+    class NonCopyable {
+#ifdef CATCH_CPP11_OR_GREATER
+        NonCopyable( NonCopyable const& )              = delete;
+        NonCopyable( NonCopyable && )                  = delete;
+        NonCopyable& operator = ( NonCopyable const& ) = delete;
+        NonCopyable& operator = ( NonCopyable && )     = delete;
+#else
+        NonCopyable( NonCopyable const& info );
+        NonCopyable& operator = ( NonCopyable const& );
+#endif
+
+    protected:
+        NonCopyable() {}
+        virtual ~NonCopyable();
+    };
+
+    class SafeBool {
+    public:
+        typedef void (SafeBool::*type)() const;
+
+        static type makeSafe( bool value ) {
+            return value ? &SafeBool::trueValue : 0;
+        }
+    private:
+        void trueValue() const {}
+    };
+
+    template<typename ContainerT>
+    inline void deleteAll( ContainerT& container ) {
+        typename ContainerT::const_iterator it = container.begin();
+        typename ContainerT::const_iterator itEnd = container.end();
+        for(; it != itEnd; ++it )
+            delete *it;
+    }
+    template<typename AssociativeContainerT>
+    inline void deleteAllValues( AssociativeContainerT& container ) {
+        typename AssociativeContainerT::const_iterator it = container.begin();
+        typename AssociativeContainerT::const_iterator itEnd = container.end();
+        for(; it != itEnd; ++it )
+            delete it->second;
+    }
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    std::string trim( std::string const& str );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+
+    struct SourceLineInfo {
+
+        SourceLineInfo();
+        SourceLineInfo( char const* _file, std::size_t _line );
+        SourceLineInfo( SourceLineInfo const& other );
+#  ifdef CATCH_CPP11_OR_GREATER
+        SourceLineInfo( SourceLineInfo && )                  = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
+        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
+#  endif
+        bool empty() const;
+        bool operator == ( SourceLineInfo const& other ) const;
+        bool operator < ( SourceLineInfo const& other ) const;
+
+        std::string file;
+        std::size_t line;
+    };
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+    // This is just here to avoid compiler warnings with macro constants and boolean literals
+    inline bool isTrue( bool value ){ return value; }
+    inline bool alwaysTrue() { return true; }
+    inline bool alwaysFalse() { return false; }
+
+    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );
+
+    // Use this in variadic streaming macros to allow
+    //    >> +StreamEndStop
+    // as well as
+    //    >> stuff +StreamEndStop
+    struct StreamEndStop {
+        std::string operator+() {
+            return std::string();
+        }
+    };
+    template<typename T>
+    T const& operator + ( T const& value, StreamEndStop ) {
+        return value;
+    }
+}
+
+#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );
+
+#include <ostream>
+
+namespace Catch {
+
+    class NotImplementedException : public std::exception
+    {
+    public:
+        NotImplementedException( SourceLineInfo const& lineInfo );
+        NotImplementedException( NotImplementedException const& ) {}
+
+        virtual ~NotImplementedException() CATCH_NOEXCEPT {}
+
+        virtual const char* what() const CATCH_NOEXCEPT;
+
+    private:
+        std::string m_what;
+        SourceLineInfo m_lineInfo;
+    };
+
+} // end namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )
+
+// #included from: internal/catch_context.h
+#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
+
+// #included from: catch_interfaces_generators.h
+#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct IGeneratorInfo {
+        virtual ~IGeneratorInfo();
+        virtual bool moveNext() = 0;
+        virtual std::size_t getCurrentIndex() const = 0;
+    };
+
+    struct IGeneratorsForTest {
+        virtual ~IGeneratorsForTest();
+
+        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
+        virtual bool moveNext() = 0;
+    };
+
+    IGeneratorsForTest* createGeneratorsForTest();
+
+} // end namespace Catch
+
+// #included from: catch_ptr.hpp
+#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    // An intrusive reference counting smart pointer.
+    // T must implement addRef() and release() methods
+    // typically implementing the IShared interface
+    template<typename T>
+    class Ptr {
+    public:
+        Ptr() : m_p( NULL ){}
+        Ptr( T* p ) : m_p( p ){
+            if( m_p )
+                m_p->addRef();
+        }
+        Ptr( Ptr const& other ) : m_p( other.m_p ){
+            if( m_p )
+                m_p->addRef();
+        }
+        ~Ptr(){
+            if( m_p )
+                m_p->release();
+        }
+        void reset() {
+            if( m_p )
+                m_p->release();
+            m_p = NULL;
+        }
+        Ptr& operator = ( T* p ){
+            Ptr temp( p );
+            swap( temp );
+            return *this;
+        }
+        Ptr& operator = ( Ptr const& other ){
+            Ptr temp( other );
+            swap( temp );
+            return *this;
+        }
+        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
+        T* get() { return m_p; }
+        const T* get() const{ return m_p; }
+        T& operator*() const { return *m_p; }
+        T* operator->() const { return m_p; }
+        bool operator !() const { return m_p == NULL; }
+        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != NULL ); }
+
+    private:
+        T* m_p;
+    };
+
+    struct IShared : NonCopyable {
+        virtual ~IShared();
+        virtual void addRef() const = 0;
+        virtual void release() const = 0;
+    };
+
+    template<typename T = IShared>
+    struct SharedImpl : T {
+
+        SharedImpl() : m_rc( 0 ){}
+
+        virtual void addRef() const {
+            ++m_rc;
+        }
+        virtual void release() const {
+            if( --m_rc == 0 )
+                delete this;
+        }
+
+        mutable unsigned int m_rc;
+    };
+
+} // end namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#include <memory>
+#include <vector>
+#include <stdlib.h>
+
+namespace Catch {
+
+    class TestCase;
+    class Stream;
+    struct IResultCapture;
+    struct IRunner;
+    struct IGeneratorsForTest;
+    struct IConfig;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
+        virtual bool advanceGeneratorsForCurrentTest() = 0;
+        virtual Ptr<IConfig const> getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;
+    };
+
+    IContext& getCurrentContext();
+    IMutableContext& getCurrentMutableContext();
+    void cleanUpContext();
+    Stream createStream( std::string const& streamName );
+
+}
+
+// #included from: internal/catch_test_registry.hpp
+#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+// #included from: catch_interfaces_testcase.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+
+    struct ITestCase : IShared {
+        virtual void invoke () const = 0;
+    protected:
+        virtual ~ITestCase();
+    };
+
+    class TestCase;
+    struct IConfig;
+
+    struct ITestCaseRegistry {
+        virtual ~ITestCaseRegistry();
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases, bool negated = false ) const = 0;
+
+    };
+}
+
+namespace Catch {
+
+template<typename C>
+class MethodTestCase : public SharedImpl<ITestCase> {
+
+public:
+    MethodTestCase( void (C::*method)() ) : m_method( method ) {}
+
+    virtual void invoke() const {
+        C obj;
+        (obj.*m_method)();
+    }
+
+private:
+    virtual ~MethodTestCase() {}
+
+    void (C::*m_method)();
+};
+
+typedef void(*TestFunction)();
+
+struct NameAndDesc {
+    NameAndDesc( const char* _name = "", const char* _description= "" )
+    : name( _name ), description( _description )
+    {}
+
+    const char* name;
+    const char* description;
+};
+
+struct AutoReg {
+
+    AutoReg(    TestFunction function,
+                SourceLineInfo const& lineInfo,
+                NameAndDesc const& nameAndDesc );
+
+    template<typename C>
+    AutoReg(    void (C::*method)(),
+                char const* className,
+                NameAndDesc const& nameAndDesc,
+                SourceLineInfo const& lineInfo ) {
+        registerTestCase(   new MethodTestCase<C>( method ),
+                            className,
+                            nameAndDesc,
+                            lineInfo );
+    }
+
+    void registerTestCase(  ITestCase* testCase,
+                            char const* className,
+                            NameAndDesc const& nameAndDesc,
+                            SourceLineInfo const& lineInfo );
+
+    ~AutoReg();
+
+private:
+    AutoReg( AutoReg const& );
+    void operator= ( AutoReg const& );
+};
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\
+        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\
+        namespace{ \
+            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \
+        } \
+        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()
+
+#else
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
+        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\
+        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
+        namespace{ \
+            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \
+        } \
+        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()
+
+#endif
+
+// #included from: internal/catch_capture.hpp
+#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
+
+// #included from: catch_result_builder.h
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED
+
+// #included from: catch_result_type.h
+#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
+
+    }; };
+
+    inline bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    inline bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x00,
+
+        ContinueOnFailure = 0x01,   // Failures fail test, but execution continues
+        FalseTest = 0x02,           // Prefix expression with !
+        SuppressFail = 0x04         // Failures are reported but do not fail the test
+    }; };
+
+    inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    inline bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.h
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionInfo
+    {
+        AssertionInfo() {}
+        AssertionInfo(  std::string const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        std::string const& _capturedExpression,
+                        ResultDisposition::Flags _resultDisposition );
+
+        std::string macroName;
+        SourceLineInfo lineInfo;
+        std::string capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+    };
+
+    struct AssertionResultData
+    {
+        AssertionResultData() : resultType( ResultWas::Unknown ) {}
+
+        std::string reconstructedExpression;
+        std::string message;
+        ResultWas::OfType resultType;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult();
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+        ~AssertionResult();
+#  ifdef CATCH_CPP11_OR_GREATER
+         AssertionResult( AssertionResult const& )              = default;
+         AssertionResult( AssertionResult && )                  = default;
+         AssertionResult& operator = ( AssertionResult const& ) = default;
+         AssertionResult& operator = ( AssertionResult && )     = default;
+#  endif
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        std::string getTestMacroName() const;
+
+    protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+namespace Catch {
+
+    struct TestFailureException{};
+
+    template<typename T> class ExpressionLhs;
+
+    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
+
+    struct CopyableStream {
+        CopyableStream() {}
+        CopyableStream( CopyableStream const& other ) {
+            oss << other.oss.str();
+        }
+        CopyableStream& operator=( CopyableStream const& other ) {
+            oss.str("");
+            oss << other.oss.str();
+            return *this;
+        }
+        std::ostringstream oss;
+    };
+
+    class ResultBuilder {
+    public:
+        ResultBuilder(  char const* macroName,
+                        SourceLineInfo const& lineInfo,
+                        char const* capturedExpression,
+                        ResultDisposition::Flags resultDisposition );
+
+        template<typename T>
+        ExpressionLhs<T const&> operator->* ( T const& operand );
+        ExpressionLhs<bool> operator->* ( bool value );
+
+        template<typename T>
+        ResultBuilder& operator << ( T const& value ) {
+            m_stream.oss << value;
+            return *this;
+        }
+
+        template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& );
+        template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& );
+
+        ResultBuilder& setResultType( ResultWas::OfType result );
+        ResultBuilder& setResultType( bool result );
+        ResultBuilder& setLhs( std::string const& lhs );
+        ResultBuilder& setRhs( std::string const& rhs );
+        ResultBuilder& setOp( std::string const& op );
+
+        void endExpression();
+
+        std::string reconstructExpression() const;
+        AssertionResult build() const;
+
+        void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal );
+        void captureResult( ResultWas::OfType resultType );
+        void captureExpression();
+        void react();
+        bool shouldDebugBreak() const;
+        bool allowThrows() const;
+
+    private:
+        AssertionInfo m_assertionInfo;
+        AssertionResultData m_data;
+        struct ExprComponents {
+            ExprComponents() : testFalse( false ) {}
+            bool testFalse;
+            std::string lhs, rhs, op;
+        } m_exprComponents;
+        CopyableStream m_stream;
+
+        bool m_shouldDebugBreak;
+        bool m_shouldThrow;
+    };
+
+} // namespace Catch
+
+// Include after due to circular dependency:
+// #included from: catch_expression_lhs.hpp
+#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
+
+// #included from: catch_evaluate.hpp
+#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#endif
+
+#include <cstddef>
+
+namespace Catch {
+namespace Internal {
+
+    enum Operator {
+        IsEqualTo,
+        IsNotEqualTo,
+        IsLessThan,
+        IsGreaterThan,
+        IsLessThanOrEqualTo,
+        IsGreaterThanOrEqualTo
+    };
+
+    template<Operator Op> struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
+    template<> struct OperatorTraits<IsEqualTo>             { static const char* getName(){ return "=="; } };
+    template<> struct OperatorTraits<IsNotEqualTo>          { static const char* getName(){ return "!="; } };
+    template<> struct OperatorTraits<IsLessThan>            { static const char* getName(){ return "<"; } };
+    template<> struct OperatorTraits<IsGreaterThan>         { static const char* getName(){ return ">"; } };
+    template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
+    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
+
+    template<typename T>
+    inline T& opCast(T const& t) { return const_cast<T&>(t); }
+
+// nullptr_t support based on pull request #154 from Konstantin Baumann
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+    // So the compare overloads can be operator agnostic we convey the operator as a template
+    // enum, which is used to specialise an Evaluator for doing the comparison.
+    template<typename T1, typename T2, Operator Op>
+    class Evaluator{};
+
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs) {
+            return opCast( lhs ) ==  opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsNotEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) != opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsLessThan> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) < opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsGreaterThan> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) > opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) >= opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) <= opCast( rhs );
+        }
+    };
+
+    template<Operator Op, typename T1, typename T2>
+    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // This level of indirection allows us to specialise for integer types
+    // to avoid signed/ unsigned warnings
+
+    // "base" overload
+    template<Operator Op, typename T1, typename T2>
+    bool compare( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // unsigned X to int
+    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+
+    // unsigned X to long
+    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+
+    // int to unsigned X
+    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+
+    // long to unsigned X
+    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // pointer to long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+    // pointer to int (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    // pointer to nullptr_t (when comparing against nullptr)
+    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( NULL, rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, NULL );
+    }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+} // end of namespace Internal
+} // end of namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// #included from: catch_tostring.h
+#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
+
+// #included from: catch_sfinae.hpp
+#define TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED
+
+// Try to detect if the current compiler supports SFINAE
+
+namespace Catch {
+
+    struct TrueType {
+        static const bool value = true;
+        typedef void Enable;
+        char sizer[1];
+    };
+    struct FalseType {
+        static const bool value = false;
+        typedef void Disable;
+        char sizer[2];
+    };
+
+#ifdef CATCH_CONFIG_SFINAE
+
+    template<bool> struct NotABooleanExpression;
+
+    template<bool c> struct If : NotABooleanExpression<c> {};
+    template<> struct If<true> : TrueType {};
+    template<> struct If<false> : FalseType {};
+
+    template<int size> struct SizedIf;
+    template<> struct SizedIf<sizeof(TrueType)> : TrueType {};
+    template<> struct SizedIf<sizeof(FalseType)> : FalseType {};
+
+#endif // CATCH_CONFIG_SFINAE
+
+} // end namespace Catch
+
+#include <sstream>
+#include <iomanip>
+#include <limits>
+#include <vector>
+#include <cstddef>
+
+#ifdef __OBJC__
+// #included from: catch_objc_arc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease( NSObject* obj );
+id performOptionalSelector( id obj, SEL sel );
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease( NSObject* obj ) {
+    [obj release];
+}
+inline id performOptionalSelector( id obj, SEL sel ) {
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease( NSObject* ){}
+inline id performOptionalSelector( id obj, SEL sel ) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+#endif
+
+#ifdef CATCH_CPP11_OR_GREATER
+#include <tuple>
+#include <type_traits>
+#endif
+
+namespace Catch {
+
+// Why we're here.
+template<typename T>
+std::string toString( T const& value );
+
+// Built in overloads
+
+std::string toString( std::string const& value );
+std::string toString( std::wstring const& value );
+std::string toString( const char* const value );
+std::string toString( char* const value );
+std::string toString( const wchar_t* const value );
+std::string toString( wchar_t* const value );
+std::string toString( int value );
+std::string toString( unsigned long value );
+std::string toString( unsigned int value );
+std::string toString( const double value );
+std::string toString( const float value );
+std::string toString( bool value );
+std::string toString( char value );
+std::string toString( signed char value );
+std::string toString( unsigned char value );
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t );
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring );
+    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring );
+    std::string toString( NSObject* const& nsObject );
+#endif
+
+namespace Detail {
+
+    extern std::string unprintableString;
+
+// SFINAE is currently disabled by default for all compilers.
+// If the non SFINAE version of IsStreamInsertable is ambiguous for you
+// and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE
+#ifdef CATCH_CONFIG_SFINAE
+
+    template<typename T>
+    class IsStreamInsertableHelper {
+        template<int N> struct TrueIfSizeable : TrueType {};
+
+        template<typename T2>
+        static TrueIfSizeable<sizeof((*(std::ostream*)0) << *((T2 const*)0))> dummy(T2*);
+        static FalseType dummy(...);
+
+    public:
+        typedef SizedIf<sizeof(dummy((T*)0))> type;
+    };
+
+    template<typename T>
+    struct IsStreamInsertable : IsStreamInsertableHelper<T>::type {};
+
+#else
+
+    struct BorgType {
+        template<typename T> BorgType( T const& );
+    };
+
+    TrueType& testStreamable( std::ostream& );
+    FalseType testStreamable( FalseType );
+
+    FalseType operator<<( std::ostream const&, BorgType const& );
+
+    template<typename T>
+    struct IsStreamInsertable {
+        static std::ostream &s;
+        static T  const&t;
+        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
+    };
+
+#endif
+
+#if defined(CATCH_CPP11_OR_GREATER)
+    template<typename T,
+             bool IsEnum = std::is_enum<T>::value
+             >
+    struct EnumStringMaker
+    {
+        static std::string convert( T const& ) { return unprintableString; }
+    };
+
+    template<typename T>
+    struct EnumStringMaker<T,true>
+    {
+        static std::string convert( T const& v )
+        {
+            return ::Catch::toString(
+                static_cast<typename std::underlying_type<T>::type>(v)
+                );
+        }
+    };
+#endif
+    template<bool C>
+    struct StringMakerBase {
+#if defined(CATCH_CPP11_OR_GREATER)
+        template<typename T>
+        static std::string convert( T const& v )
+        {
+            return EnumStringMaker<T>::convert( v );
+        }
+#else
+        template<typename T>
+        static std::string convert( T const& ) { return unprintableString; }
+#endif
+    };
+
+    template<>
+    struct StringMakerBase<true> {
+        template<typename T>
+        static std::string convert( T const& _value ) {
+            std::ostringstream oss;
+            oss << _value;
+            return oss.str();
+        }
+    };
+
+    std::string rawMemoryToString( const void *object, std::size_t size );
+
+    template<typename T>
+    inline std::string rawMemoryToString( const T& object ) {
+      return rawMemoryToString( &object, sizeof(object) );
+    }
+
+} // end namespace Detail
+
+template<typename T>
+struct StringMaker :
+    Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
+
+template<typename T>
+struct StringMaker<T*> {
+    template<typename U>
+    static std::string convert( U* p ) {
+        if( !p )
+            return INTERNAL_CATCH_STRINGIFY( NULL );
+        else
+            return Detail::rawMemoryToString( p );
+    }
+};
+
+template<typename R, typename C>
+struct StringMaker<R C::*> {
+    static std::string convert( R C::* p ) {
+        if( !p )
+            return INTERNAL_CATCH_STRINGIFY( NULL );
+        else
+            return Detail::rawMemoryToString( p );
+    }
+};
+
+namespace Detail {
+    template<typename InputIterator>
+    std::string rangeToString( InputIterator first, InputIterator last );
+}
+
+//template<typename T, typename Allocator>
+//struct StringMaker<std::vector<T, Allocator> > {
+//    static std::string convert( std::vector<T,Allocator> const& v ) {
+//        return Detail::rangeToString( v.begin(), v.end() );
+//    }
+//};
+
+template<typename T, typename Allocator>
+std::string toString( std::vector<T,Allocator> const& v ) {
+    return Detail::rangeToString( v.begin(), v.end() );
+}
+
+#ifdef CATCH_CPP11_OR_GREATER
+
+// toString for tuples
+namespace TupleDetail {
+  template<
+      typename Tuple,
+      std::size_t N = 0,
+      bool = (N < std::tuple_size<Tuple>::value)
+      >
+  struct ElementPrinter {
+      static void print( const Tuple& tuple, std::ostream& os )
+      {
+          os << ( N ? ", " : " " )
+             << Catch::toString(std::get<N>(tuple));
+          ElementPrinter<Tuple,N+1>::print(tuple,os);
+      }
+  };
+
+  template<
+      typename Tuple,
+      std::size_t N
+      >
+  struct ElementPrinter<Tuple,N,false> {
+      static void print( const Tuple&, std::ostream& ) {}
+  };
+
+}
+
+template<typename ...Types>
+struct StringMaker<std::tuple<Types...>> {
+
+    static std::string convert( const std::tuple<Types...>& tuple )
+    {
+        std::ostringstream os;
+        os << '{';
+        TupleDetail::ElementPrinter<std::tuple<Types...>>::print( tuple, os );
+        os << " }";
+        return os.str();
+    }
+};
+#endif
+
+namespace Detail {
+    template<typename T>
+    std::string makeString( T const& value ) {
+        return StringMaker<T>::convert( value );
+    }
+} // end namespace Detail
+
+/// \brief converts any type to a string
+///
+/// The default template forwards on to ostringstream - except when an
+/// ostringstream overload does not exist - in which case it attempts to detect
+/// that and writes {?}.
+/// Overload (not specialise) this template for custom typs that you don't want
+/// to provide an ostream overload for.
+template<typename T>
+std::string toString( T const& value ) {
+    return StringMaker<T>::convert( value );
+}
+
+    namespace Detail {
+    template<typename InputIterator>
+    std::string rangeToString( InputIterator first, InputIterator last ) {
+        std::ostringstream oss;
+        oss << "{ ";
+        if( first != last ) {
+            oss << Catch::toString( *first );
+            for( ++first ; first != last ; ++first )
+                oss << ", " << Catch::toString( *first );
+        }
+        oss << " }";
+        return oss.str();
+    }
+}
+
+} // end namespace Catch
+
+namespace Catch {
+
+// Wraps the LHS of an expression and captures the operator and RHS (if any) -
+// wrapping them all in a ResultBuilder object
+template<typename T>
+class ExpressionLhs {
+    ExpressionLhs& operator = ( ExpressionLhs const& );
+#  ifdef CATCH_CPP11_OR_GREATER
+    ExpressionLhs& operator = ( ExpressionLhs && ) = delete;
+#  endif
+
+public:
+    ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ) {}
+#  ifdef CATCH_CPP11_OR_GREATER
+    ExpressionLhs( ExpressionLhs const& ) = default;
+    ExpressionLhs( ExpressionLhs && )     = default;
+#  endif
+
+    template<typename RhsT>
+    ResultBuilder& operator == ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator != ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsNotEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator < ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsLessThan>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator > ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsGreaterThan>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator <= ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator >= ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
+    }
+
+    ResultBuilder& operator == ( bool rhs ) {
+        return captureExpression<Internal::IsEqualTo>( rhs );
+    }
+
+    ResultBuilder& operator != ( bool rhs ) {
+        return captureExpression<Internal::IsNotEqualTo>( rhs );
+    }
+
+    void endExpression() {
+        bool value = m_lhs ? true : false;
+        m_rb
+            .setLhs( Catch::toString( value ) )
+            .setResultType( value )
+            .endExpression();
+    }
+
+    // Only simple binary expressions are allowed on the LHS.
+    // If more complex compositions are required then place the sub expression in parentheses
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& );
+
+private:
+    template<Internal::Operator Op, typename RhsT>
+    ResultBuilder& captureExpression( RhsT const& rhs ) {
+        return m_rb
+            .setResultType( Internal::compare<Op>( m_lhs, rhs ) )
+            .setLhs( Catch::toString( m_lhs ) )
+            .setRhs( Catch::toString( rhs ) )
+            .setOp( Internal::OperatorTraits<Op>::getName() );
+    }
+
+private:
+    ResultBuilder& m_rb;
+    T m_lhs;
+};
+
+} // end namespace Catch
+
+
+namespace Catch {
+
+    template<typename T>
+    inline ExpressionLhs<T const&> ResultBuilder::operator->* ( T const& operand ) {
+        return ExpressionLhs<T const&>( *this, operand );
+    }
+
+    inline ExpressionLhs<bool> ResultBuilder::operator->* ( bool value ) {
+        return ExpressionLhs<bool>( *this, value );
+    }
+
+} // namespace Catch
+
+// #included from: catch_message.h
+#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    std::string const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        std::string macroName;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        std::string message;
+        unsigned int sequence;
+
+        bool operator == ( MessageInfo const& other ) const {
+            return sequence == other.sequence;
+        }
+        bool operator < ( MessageInfo const& other ) const {
+            return sequence < other.sequence;
+        }
+    private:
+        static unsigned int globalCount;
+    };
+
+    struct MessageBuilder {
+        MessageBuilder( std::string const& macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type )
+        : m_info( macroName, lineInfo, type )
+        {}
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+        std::ostringstream m_stream;
+    };
+
+    class ScopedMessage {
+    public:
+        ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage const& other );
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_capture.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class TestCase;
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct MessageInfo;
+    class ScopedMessageBuilder;
+    struct Counts;
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual void assertionEnded( AssertionResult const& result ) = 0;
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionInfo const& name, Counts const& assertions, double _durationInSeconds ) = 0;
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+
+        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// #included from: catch_debugger.h
+#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
+
+// #included from: catch_platform.h
+#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED
+
+#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
+#define CATCH_PLATFORM_MAC
+#elif  defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
+#define CATCH_PLATFORM_IPHONE
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#define CATCH_PLATFORM_WINDOWS
+#endif
+
+#include <string>
+
+namespace Catch{
+
+    bool isDebuggerActive();
+    void writeToDebugConsole( std::string const& text );
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    // The following code snippet based on:
+    // http://cocoawithlove.com/2008/03/break-into-debugger.html
+    #ifdef DEBUG
+        #if defined(__ppc64__) || defined(__ppc__)
+            #define CATCH_BREAK_INTO_DEBUGGER() \
+                if( Catch::isDebuggerActive() ) { \
+                    __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+                    : : : "memory","r0","r3","r4" ); \
+                }
+        #else
+            #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );}
+        #endif
+    #endif
+
+#elif defined(_MSC_VER)
+    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); }
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+#define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
+#endif
+
+// #included from: catch_interfaces_runner.h
+#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED
+
+namespace Catch {
+    class TestCase;
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// In the event of a failure works out if the debugger needs to be invoked
+// and/or an exception thrown and takes appropriate action.
+// This needs to be done as a macro so the debugger will stop in the user
+// source code rather than in Catch library code
+#define INTERNAL_CATCH_REACT( resultBuilder ) \
+    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
+    resultBuilder.react();
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        try { \
+            ( __catchResult->*expr ).endExpression(); \
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( Catch::ResultDisposition::Normal ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && (expr) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \
+    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
+    if( Catch::getResultCapture().getLastResult()->succeeded() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \
+    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
+    if( !Catch::getResultCapture().getLastResult()->succeeded() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        try { \
+            expr; \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( expr, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        if( __catchResult.allowThrows() ) \
+            try { \
+                expr; \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+            } \
+            catch( ... ) { \
+                __catchResult.captureResult( Catch::ResultWas::Ok ); \
+            } \
+        else \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        if( __catchResult.allowThrows() ) \
+            try { \
+                expr; \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+            } \
+            catch( exceptionType ) { \
+                __catchResult.captureResult( Catch::ResultWas::Ok ); \
+            } \
+            catch( ... ) { \
+                __catchResult.useActiveException( resultDisposition ); \
+            } \
+        else \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#else
+    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << log + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( log, macroName ) \
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg " " #matcher, resultDisposition ); \
+        try { \
+            std::string matcherAsString = ::Catch::Matchers::matcher.toString(); \
+            __catchResult \
+                .setLhs( Catch::toString( arg ) ) \
+                .setRhs( matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString ) \
+                .setOp( "matches" ) \
+                .setResultType( ::Catch::Matchers::matcher.match( arg ) ); \
+            __catchResult.captureExpression(); \
+        } catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+// #included from: internal/catch_section.h
+#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED
+
+// #included from: catch_section_info.h
+#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED
+
+namespace Catch {
+
+    struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name,
+                std::string const& _description = std::string() );
+
+        std::string name;
+        std::string description;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_totals.hpp
+#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED
+
+#include <cstddef>
+
+namespace Catch {
+
+    struct Counts {
+        Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {}
+
+        Counts operator - ( Counts const& other ) const {
+            Counts diff;
+            diff.passed = passed - other.passed;
+            diff.failed = failed - other.failed;
+            diff.failedButOk = failedButOk - other.failedButOk;
+            return diff;
+        }
+        Counts& operator += ( Counts const& other ) {
+            passed += other.passed;
+            failed += other.failed;
+            failedButOk += other.failedButOk;
+            return *this;
+        }
+
+        std::size_t total() const {
+            return passed + failed + failedButOk;
+        }
+        bool allPassed() const {
+            return failed == 0 && failedButOk == 0;
+        }
+        bool allOk() const {
+            return failed == 0;
+        }
+
+        std::size_t passed;
+        std::size_t failed;
+        std::size_t failedButOk;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const {
+            Totals diff;
+            diff.assertions = assertions - other.assertions;
+            diff.testCases = testCases - other.testCases;
+            return diff;
+        }
+
+        Totals delta( Totals const& prevTotals ) const {
+            Totals diff = *this - prevTotals;
+            if( diff.assertions.failed > 0 )
+                ++diff.testCases.failed;
+            else if( diff.assertions.failedButOk > 0 )
+                ++diff.testCases.failedButOk;
+            else
+                ++diff.testCases.passed;
+            return diff;
+        }
+
+        Totals& operator += ( Totals const& other ) {
+            assertions += other.assertions;
+            testCases += other.testCases;
+            return *this;
+        }
+
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+// #included from: catch_timer.h
+#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED
+
+#ifdef CATCH_PLATFORM_WINDOWS
+typedef unsigned long long uint64_t;
+#else
+#include <stdint.h>
+#endif
+
+namespace Catch {
+
+    class Timer {
+    public:
+        Timer() : m_ticks( 0 ) {}
+        void start();
+        unsigned int getElapsedMicroseconds() const;
+        unsigned int getElapsedMilliseconds() const;
+        double getElapsedSeconds() const;
+
+    private:
+        uint64_t m_ticks;
+    };
+
+} // namespace Catch
+
+#include <string>
+
+namespace Catch {
+
+    class Section : NonCopyable {
+    public:
+        Section( SectionInfo const& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        std::string m_name;
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_SECTION( ... ) \
+        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
+#else
+    #define INTERNAL_CATCH_SECTION( name, desc ) \
+        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) )
+#endif
+
+// #included from: internal/catch_generators.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
+
+#include <iterator>
+#include <vector>
+#include <string>
+#include <stdlib.h>
+
+namespace Catch {
+
+template<typename T>
+struct IGenerator {
+    virtual ~IGenerator() {}
+    virtual T getValue( std::size_t index ) const = 0;
+    virtual std::size_t size () const = 0;
+};
+
+template<typename T>
+class BetweenGenerator : public IGenerator<T> {
+public:
+    BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}
+
+    virtual T getValue( std::size_t index ) const {
+        return m_from+static_cast<int>( index );
+    }
+
+    virtual std::size_t size() const {
+        return static_cast<std::size_t>( 1+m_to-m_from );
+    }
+
+private:
+
+    T m_from;
+    T m_to;
+};
+
+template<typename T>
+class ValuesGenerator : public IGenerator<T> {
+public:
+    ValuesGenerator(){}
+
+    void add( T value ) {
+        m_values.push_back( value );
+    }
+
+    virtual T getValue( std::size_t index ) const {
+        return m_values[index];
+    }
+
+    virtual std::size_t size() const {
+        return m_values.size();
+    }
+
+private:
+    std::vector<T> m_values;
+};
+
+template<typename T>
+class CompositeGenerator {
+public:
+    CompositeGenerator() : m_totalSize( 0 ) {}
+
+    // *** Move semantics, similar to auto_ptr ***
+    CompositeGenerator( CompositeGenerator& other )
+    :   m_fileInfo( other.m_fileInfo ),
+        m_totalSize( 0 )
+    {
+        move( other );
+    }
+
+    CompositeGenerator& setFileInfo( const char* fileInfo ) {
+        m_fileInfo = fileInfo;
+        return *this;
+    }
+
+    ~CompositeGenerator() {
+        deleteAll( m_composed );
+    }
+
+    operator T () const {
+        size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize );
+
+        typename std::vector<const IGenerator<T>*>::const_iterator it = m_composed.begin();
+        typename std::vector<const IGenerator<T>*>::const_iterator itEnd = m_composed.end();
+        for( size_t index = 0; it != itEnd; ++it )
+        {
+            const IGenerator<T>* generator = *it;
+            if( overallIndex >= index && overallIndex < index + generator->size() )
+            {
+                return generator->getValue( overallIndex-index );
+            }
+            index += generator->size();
+        }
+        CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
+        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
+    }
+
+    void add( const IGenerator<T>* generator ) {
+        m_totalSize += generator->size();
+        m_composed.push_back( generator );
+    }
+
+    CompositeGenerator& then( CompositeGenerator& other ) {
+        move( other );
+        return *this;
+    }
+
+    CompositeGenerator& then( T value ) {
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( value );
+        add( valuesGen );
+        return *this;
+    }
+
+private:
+
+    void move( CompositeGenerator& other ) {
+        std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) );
+        m_totalSize += other.m_totalSize;
+        other.m_composed.clear();
+    }
+
+    std::vector<const IGenerator<T>*> m_composed;
+    std::string m_fileInfo;
+    size_t m_totalSize;
+};
+
+namespace Generators
+{
+    template<typename T>
+    CompositeGenerator<T> between( T from, T to ) {
+        CompositeGenerator<T> generators;
+        generators.add( new BetweenGenerator<T>( from, to ) );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2 ) {
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2, T val3 ){
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        valuesGen->add( val3 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2, T val3, T val4 ) {
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        valuesGen->add( val3 );
+        valuesGen->add( val4 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+} // end namespace Generators
+
+using namespace Generators;
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_LINESTR2( line ) #line
+#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line )
+
+#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" )
+
+// #included from: internal/catch_interfaces_exception.h
+#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
+
+#include <string>
+// #included from: catch_interfaces_registry_hub.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class TestCase;
+    struct ITestCaseRegistry;
+    struct IExceptionTranslatorRegistry;
+    struct IExceptionTranslator;
+    struct IReporterRegistry;
+    struct IReporterFactory;
+
+    struct IRegistryHub {
+        virtual ~IRegistryHub();
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
+    };
+
+    struct IMutableRegistryHub {
+        virtual ~IMutableRegistryHub();
+        virtual void registerReporter( std::string const& name, IReporterFactory* factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
+        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+    };
+
+    IRegistryHub& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+
+namespace Catch {
+
+    typedef std::string(*exceptionTranslateFunction)();
+
+    struct IExceptionTranslator {
+        virtual ~IExceptionTranslator();
+        virtual std::string translate() const = 0;
+    };
+
+    struct IExceptionTranslatorRegistry {
+        virtual ~IExceptionTranslatorRegistry();
+
+        virtual std::string translateActiveException() const = 0;
+    };
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            virtual std::string translate() const {
+                try {
+                    throw;
+                }
+                catch( T& ex ) {
+                    return m_translateFunction( ex );
+                }
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+            getMutableRegistryHub().registerTranslator
+                ( new ExceptionTranslator<T>( translateFunction ) );
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) \
+    static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ); \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ) ); }\
+    static std::string INTERNAL_CATCH_UNIQUE_NAME(  catch_internal_ExceptionTranslator )( signature )
+
+// #included from: internal/catch_approx.hpp
+#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
+
+#include <cmath>
+#include <limits>
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    public:
+        explicit Approx ( double value )
+        :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+            m_scale( 1.0 ),
+            m_value( value )
+        {}
+
+        Approx( Approx const& other )
+        :   m_epsilon( other.m_epsilon ),
+            m_scale( other.m_scale ),
+            m_value( other.m_value )
+        {}
+
+        static Approx custom() {
+            return Approx( 0 );
+        }
+
+        Approx operator()( double value ) {
+            Approx approx( value );
+            approx.epsilon( m_epsilon );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+        friend bool operator == ( double lhs, Approx const& rhs ) {
+            // Thanks to Richard Harris for his help refining this formula
+            return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) );
+        }
+
+        friend bool operator == ( Approx const& lhs, double rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        friend bool operator != ( double lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        friend bool operator != ( Approx const& lhs, double rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        Approx& epsilon( double newEpsilon ) {
+            m_epsilon = newEpsilon;
+            return *this;
+        }
+
+        Approx& scale( double newScale ) {
+            m_scale = newScale;
+            return *this;
+        }
+
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << "Approx( " << Catch::toString( m_value ) << " )";
+            return oss.str();
+        }
+
+    private:
+        double m_epsilon;
+        double m_scale;
+        double m_value;
+    };
+}
+
+template<>
+inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
+    return value.toString();
+}
+
+} // end namespace Catch
+
+// #included from: internal/catch_matchers.hpp
+#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+    template<typename ExpressionT>
+    struct Matcher : SharedImpl<IShared>
+    {
+        typedef ExpressionT ExpressionType;
+
+        virtual ~Matcher() {}
+        virtual Ptr<Matcher> clone() const = 0;
+        virtual bool match( ExpressionT const& expr ) const = 0;
+        virtual std::string toString() const = 0;
+    };
+
+    template<typename DerivedT, typename ExpressionT>
+    struct MatcherImpl : Matcher<ExpressionT> {
+
+        virtual Ptr<Matcher<ExpressionT> > clone() const {
+            return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );
+        }
+    };
+
+    namespace Generic {
+
+        template<typename ExpressionT>
+        class AllOf : public MatcherImpl<AllOf<ExpressionT>, ExpressionT> {
+        public:
+
+            AllOf() {}
+            AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {}
+
+            AllOf& add( Matcher<ExpressionT> const& matcher ) {
+                m_matchers.push_back( matcher.clone() );
+                return *this;
+            }
+            virtual bool match( ExpressionT const& expr ) const
+            {
+                for( std::size_t i = 0; i < m_matchers.size(); ++i )
+                    if( !m_matchers[i]->match( expr ) )
+                        return false;
+                return true;
+            }
+            virtual std::string toString() const {
+                std::ostringstream oss;
+                oss << "( ";
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if( i != 0 )
+                        oss << " and ";
+                    oss << m_matchers[i]->toString();
+                }
+                oss << " )";
+                return oss.str();
+            }
+
+        private:
+            std::vector<Ptr<Matcher<ExpressionT> > > m_matchers;
+        };
+
+        template<typename ExpressionT>
+        class AnyOf : public MatcherImpl<AnyOf<ExpressionT>, ExpressionT> {
+        public:
+
+            AnyOf() {}
+            AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {}
+
+            AnyOf& add( Matcher<ExpressionT> const& matcher ) {
+                m_matchers.push_back( matcher.clone() );
+                return *this;
+            }
+            virtual bool match( ExpressionT const& expr ) const
+            {
+                for( std::size_t i = 0; i < m_matchers.size(); ++i )
+                    if( m_matchers[i]->match( expr ) )
+                        return true;
+                return false;
+            }
+            virtual std::string toString() const {
+                std::ostringstream oss;
+                oss << "( ";
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if( i != 0 )
+                        oss << " or ";
+                    oss << m_matchers[i]->toString();
+                }
+                oss << " )";
+                return oss.str();
+            }
+
+        private:
+            std::vector<Ptr<Matcher<ExpressionT> > > m_matchers;
+        };
+
+    }
+
+    namespace StdString {
+
+        inline std::string makeString( std::string const& str ) { return str; }
+        inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); }
+
+        struct Equals : MatcherImpl<Equals, std::string> {
+            Equals( std::string const& str ) : m_str( str ){}
+            Equals( Equals const& other ) : m_str( other.m_str ){}
+
+            virtual ~Equals();
+
+            virtual bool match( std::string const& expr ) const {
+                return m_str == expr;
+            }
+            virtual std::string toString() const {
+                return "equals: \"" + m_str + "\"";
+            }
+
+            std::string m_str;
+        };
+
+        struct Contains : MatcherImpl<Contains, std::string> {
+            Contains( std::string const& substr ) : m_substr( substr ){}
+            Contains( Contains const& other ) : m_substr( other.m_substr ){}
+
+            virtual ~Contains();
+
+            virtual bool match( std::string const& expr ) const {
+                return expr.find( m_substr ) != std::string::npos;
+            }
+            virtual std::string toString() const {
+                return "contains: \"" + m_substr + "\"";
+            }
+
+            std::string m_substr;
+        };
+
+        struct StartsWith : MatcherImpl<StartsWith, std::string> {
+            StartsWith( std::string const& substr ) : m_substr( substr ){}
+            StartsWith( StartsWith const& other ) : m_substr( other.m_substr ){}
+
+            virtual ~StartsWith();
+
+            virtual bool match( std::string const& expr ) const {
+                return expr.find( m_substr ) == 0;
+            }
+            virtual std::string toString() const {
+                return "starts with: \"" + m_substr + "\"";
+            }
+
+            std::string m_substr;
+        };
+
+        struct EndsWith : MatcherImpl<EndsWith, std::string> {
+            EndsWith( std::string const& substr ) : m_substr( substr ){}
+            EndsWith( EndsWith const& other ) : m_substr( other.m_substr ){}
+
+            virtual ~EndsWith();
+
+            virtual bool match( std::string const& expr ) const {
+                return expr.find( m_substr ) == expr.size() - m_substr.size();
+            }
+            virtual std::string toString() const {
+                return "ends with: \"" + m_substr + "\"";
+            }
+
+            std::string m_substr;
+        };
+    } // namespace StdString
+    } // namespace Impl
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    template<typename ExpressionT>
+    inline Impl::Generic::AllOf<ExpressionT> AllOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2 ) {
+        return Impl::Generic::AllOf<ExpressionT>().add( m1 ).add( m2 );
+    }
+    template<typename ExpressionT>
+    inline Impl::Generic::AllOf<ExpressionT> AllOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2,
+                                                    Impl::Matcher<ExpressionT> const& m3 ) {
+        return Impl::Generic::AllOf<ExpressionT>().add( m1 ).add( m2 ).add( m3 );
+    }
+    template<typename ExpressionT>
+    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2 ) {
+        return Impl::Generic::AnyOf<ExpressionT>().add( m1 ).add( m2 );
+    }
+    template<typename ExpressionT>
+    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2,
+                                                    Impl::Matcher<ExpressionT> const& m3 ) {
+        return Impl::Generic::AnyOf<ExpressionT>().add( m1 ).add( m2 ).add( m3 );
+    }
+
+    inline Impl::StdString::Equals      Equals( std::string const& str ) {
+        return Impl::StdString::Equals( str );
+    }
+    inline Impl::StdString::Equals      Equals( const char* str ) {
+        return Impl::StdString::Equals( Impl::StdString::makeString( str ) );
+    }
+    inline Impl::StdString::Contains    Contains( std::string const& substr ) {
+        return Impl::StdString::Contains( substr );
+    }
+    inline Impl::StdString::Contains    Contains( const char* substr ) {
+        return Impl::StdString::Contains( Impl::StdString::makeString( substr ) );
+    }
+    inline Impl::StdString::StartsWith  StartsWith( std::string const& substr ) {
+        return Impl::StdString::StartsWith( substr );
+    }
+    inline Impl::StdString::StartsWith  StartsWith( const char* substr ) {
+        return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) );
+    }
+    inline Impl::StdString::EndsWith    EndsWith( std::string const& substr ) {
+        return Impl::StdString::EndsWith( substr );
+    }
+    inline Impl::StdString::EndsWith    EndsWith( const char* substr ) {
+        return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) );
+    }
+
+} // namespace Matchers
+
+using namespace Matchers;
+
+} // namespace Catch
+
+// #included from: internal/catch_interfaces_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+// #included from: catch_tag_alias.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias( std::string _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {}
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); }
+// #included from: catch_option.hpp
+#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( NULL ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : NULL )
+        {}
+
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = NULL;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != NULL; }
+        bool none() const { return nullableValue == NULL; }
+
+        bool operator !() const { return nullableValue == NULL; }
+        operator SafeBool::type() const {
+            return SafeBool::makeSafe( some() );
+        }
+
+    private:
+        T* nullableValue;
+        char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+namespace Catch {
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        virtual Option<TagAlias> find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// #included from: internal/catch_test_case_info.h
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
+
+#include <string>
+#include <set>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestCase;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::set<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        TestCaseInfo( TestCaseInfo const& other );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::set<std::string> tags;
+        std::set<std::string> lcaseTags;
+        std::string tagsAsString;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestCase* testCase, TestCaseInfo const& info );
+        TestCase( TestCase const& other );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        void swap( TestCase& other );
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+        TestCase& operator = ( TestCase const& other );
+
+    private:
+        Ptr<ITestCase> test;
+    };
+
+    TestCase makeTestCase(  ITestCase* testCase,
+                            std::string const& className,
+                            std::string const& name,
+                            std::string const& description,
+                            SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+
+#ifdef __OBJC__
+// #included from: internal/catch_objc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public SharedImpl<ITestCase> {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline size_t registerTestMethods() {
+        size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( NULL, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            template<typename MatcherT>
+            struct StringHolder : MatcherImpl<MatcherT, NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                NSString* m_substr;
+            };
+
+            struct Equals : StringHolder<Equals> {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( ExpressionType const& str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                virtual std::string toString() const {
+                    return "equals string: " + Catch::toString( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder<Contains> {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( ExpressionType const& str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                virtual std::string toString() const {
+                    return "contains string: " + Catch::toString( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder<StartsWith> {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( ExpressionType const& str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                virtual std::string toString() const {
+                    return "starts with: " + Catch::toString( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder<EndsWith> {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( ExpressionType const& str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                virtual std::string toString() const {
+                    return "ends with: " + Catch::toString( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_TEST_CASE( name, desc )\
++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
+{\
+return @ name; \
+}\
++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
+{ \
+return @ desc; \
+} \
+-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )
+
+#endif
+
+#ifdef CATCH_IMPL
+// #included from: internal/catch_impl.hpp
+#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
+
+// Collect all the implementation files together here
+// These are the equivalent of what would usually be cpp files
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// #included from: ../catch_runner.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
+
+// #included from: internal/catch_commandline.hpp
+#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
+
+// #included from: catch_config.hpp
+#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
+
+// #included from: catch_test_spec_parser.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// #included from: catch_test_spec.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec {
+        struct Pattern : SharedImpl<> {
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+        };
+        class NamePattern : public Pattern {
+            enum WildcardPosition {
+                NoWildcard = 0,
+                WildcardAtStart = 1,
+                WildcardAtEnd = 2,
+                WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+            };
+
+        public:
+            NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) {
+                if( startsWith( m_name, "*" ) ) {
+                    m_name = m_name.substr( 1 );
+                    m_wildcard = WildcardAtStart;
+                }
+                if( endsWith( m_name, "*" ) ) {
+                    m_name = m_name.substr( 0, m_name.size()-1 );
+                    m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+                }
+            }
+            virtual ~NamePattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const {
+                switch( m_wildcard ) {
+                    case NoWildcard:
+                        return m_name == toLower( testCase.name );
+                    case WildcardAtStart:
+                        return endsWith( toLower( testCase.name ), m_name );
+                    case WildcardAtEnd:
+                        return startsWith( toLower( testCase.name ), m_name );
+                    case WildcardAtBothEnds:
+                        return contains( toLower( testCase.name ), m_name );
+                }
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+                throw std::logic_error( "Unknown enum" );
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+            }
+        private:
+            std::string m_name;
+            WildcardPosition m_wildcard;
+        };
+        class TagPattern : public Pattern {
+        public:
+            TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
+            virtual ~TagPattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const {
+                return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end();
+            }
+        private:
+            std::string m_tag;
+        };
+        class ExcludedPattern : public Pattern {
+        public:
+            ExcludedPattern( Ptr<Pattern> const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
+            virtual ~ExcludedPattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
+        private:
+            Ptr<Pattern> m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<Ptr<Pattern> > m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const {
+                // All patterns in a filter must match for the filter to be a match
+                for( std::vector<Ptr<Pattern> >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it )
+                    if( !(*it)->matches( testCase ) )
+                        return false;
+                    return true;
+            }
+        };
+
+    public:
+        bool hasFilters() const {
+            return !m_filters.empty();
+        }
+        bool matches( TestCaseInfo const& testCase ) const {
+            // A TestSpec matches if any filter matches
+            for( std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
+                if( it->matches( testCase ) )
+                    return true;
+            return false;
+        }
+
+    private:
+        std::vector<Filter> m_filters;
+
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag };
+        Mode m_mode;
+        bool m_exclusion;
+        std::size_t m_start, m_pos;
+        std::string m_arg;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+        TestSpecParser& parse( std::string const& arg ) {
+            m_mode = None;
+            m_exclusion = false;
+            m_start = std::string::npos;
+            m_arg = m_tagAliases->expandAliases( arg );
+            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+                visitChar( m_arg[m_pos] );
+            if( m_mode == Name )
+                addPattern<TestSpec::NamePattern>();
+            return *this;
+        }
+        TestSpec testSpec() {
+            addFilter();
+            return m_testSpec;
+        }
+    private:
+        void visitChar( char c ) {
+            if( m_mode == None ) {
+                switch( c ) {
+                case ' ': return;
+                case '~': m_exclusion = true; return;
+                case '[': return startNewMode( Tag, ++m_pos );
+                case '"': return startNewMode( QuotedName, ++m_pos );
+                default: startNewMode( Name, m_pos ); break;
+                }
+            }
+            if( m_mode == Name ) {
+                if( c == ',' ) {
+                    addPattern<TestSpec::NamePattern>();
+                    addFilter();
+                }
+                else if( c == '[' ) {
+                    if( subString() == "exclude:" )
+                        m_exclusion = true;
+                    else
+                        addPattern<TestSpec::NamePattern>();
+                    startNewMode( Tag, ++m_pos );
+                }
+            }
+            else if( m_mode == QuotedName && c == '"' )
+                addPattern<TestSpec::NamePattern>();
+            else if( m_mode == Tag && c == ']' )
+                addPattern<TestSpec::TagPattern>();
+        }
+        void startNewMode( Mode mode, std::size_t start ) {
+            m_mode = mode;
+            m_start = start;
+        }
+        std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
+        template<typename T>
+        void addPattern() {
+            std::string token = subString();
+            if( startsWith( token, "exclude:" ) ) {
+                m_exclusion = true;
+                token = token.substr( 8 );
+            }
+            if( !token.empty() ) {
+                Ptr<TestSpec::Pattern> pattern = new T( token );
+                if( m_exclusion )
+                    pattern = new TestSpec::ExcludedPattern( pattern );
+                m_currentFilter.m_patterns.push_back( pattern );
+            }
+            m_exclusion = false;
+            m_mode = None;
+        }
+        void addFilter() {
+            if( !m_currentFilter.m_patterns.empty() ) {
+                m_testSpec.m_filters.push_back( m_currentFilter );
+                m_currentFilter = TestSpec::Filter();
+            }
+        }
+    };
+    inline TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// #included from: catch_interfaces_config.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct Verbosity { enum Level {
+        NoOutput = 0,
+        Quiet,
+        Normal
+    }; };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : IShared {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual bool forceColour() const = 0;
+    };
+}
+
+// #included from: catch_stream.h
+#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
+
+#include <streambuf>
+
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    class Stream {
+    public:
+        Stream();
+        Stream( std::streambuf* _streamBuf, bool _isOwned );
+        void release();
+
+        std::streambuf* streamBuf;
+
+    private:
+        bool isOwned;
+    };
+
+    std::ostream& cout();
+    std::ostream& cerr();
+}
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <ctime>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct ConfigData {
+
+        ConfigData()
+        :   listTests( false ),
+            listTags( false ),
+            listReporters( false ),
+            listTestNamesOnly( false ),
+            showSuccessfulTests( false ),
+            shouldDebugBreak( false ),
+            noThrow( false ),
+            showHelp( false ),
+            showInvisibles( false ),
+            forceColour( false ),
+            abortAfter( -1 ),
+            rngSeed( 0 ),
+            verbosity( Verbosity::Normal ),
+            warnings( WarnAbout::Nothing ),
+            showDurations( ShowDurations::DefaultForReporter ),
+            runOrder( RunTests::InDeclarationOrder )
+        {}
+
+        bool listTests;
+        bool listTags;
+        bool listReporters;
+        bool listTestNamesOnly;
+
+        bool showSuccessfulTests;
+        bool shouldDebugBreak;
+        bool noThrow;
+        bool showHelp;
+        bool showInvisibles;
+        bool forceColour;
+
+        int abortAfter;
+        unsigned int rngSeed;
+
+        Verbosity::Level verbosity;
+        WarnAbout::What warnings;
+        ShowDurations::OrNot showDurations;
+        RunTests::InWhatOrder runOrder;
+
+        std::string reporterName;
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+
+        std::vector<std::string> testsOrTags;
+    };
+
+    class Config : public SharedImpl<IConfig> {
+    private:
+        Config( Config const& other );
+        Config& operator = ( Config const& other );
+        virtual void dummy();
+    public:
+
+        Config()
+        :   m_os( Catch::cout().rdbuf() )
+        {}
+
+        Config( ConfigData const& data )
+        :   m_data( data ),
+            m_os( Catch::cout().rdbuf() )
+        {
+            if( !data.testsOrTags.empty() ) {
+                TestSpecParser parser( ITagAliasRegistry::get() );
+                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
+                    parser.parse( data.testsOrTags[i] );
+                m_testSpec = parser.testSpec();
+            }
+        }
+
+        virtual ~Config() {
+            m_os.rdbuf( Catch::cout().rdbuf() );
+            m_stream.release();
+        }
+
+        void setFilename( std::string const& filename ) {
+            m_data.outputFilename = filename;
+        }
+
+        std::string const& getFilename() const {
+            return m_data.outputFilename ;
+        }
+
+        bool listTests() const { return m_data.listTests; }
+        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
+        bool listTags() const { return m_data.listTags; }
+        bool listReporters() const { return m_data.listReporters; }
+
+        std::string getProcessName() const { return m_data.processName; }
+
+        bool shouldDebugBreak() const { return m_data.shouldDebugBreak; }
+
+        void setStreamBuf( std::streambuf* buf ) {
+            m_os.rdbuf( buf ? buf : Catch::cout().rdbuf() );
+        }
+
+        void useStream( std::string const& streamName ) {
+            Stream stream = createStream( streamName );
+            setStreamBuf( stream.streamBuf );
+            m_stream.release();
+            m_stream = stream;
+        }
+
+        std::string getReporterName() const { return m_data.reporterName; }
+
+        int abortAfter() const { return m_data.abortAfter; }
+
+        TestSpec const& testSpec() const { return m_testSpec; }
+
+        bool showHelp() const { return m_data.showHelp; }
+        bool showInvisibles() const { return m_data.showInvisibles; }
+
+        // IConfig interface
+        virtual bool allowThrows() const        { return !m_data.noThrow; }
+        virtual std::ostream& stream() const    { return m_os; }
+        virtual std::string name() const        { return m_data.name.empty() ? m_data.processName : m_data.name; }
+        virtual bool includeSuccessfulResults() const   { return m_data.showSuccessfulTests; }
+        virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; }
+        virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; }
+        virtual RunTests::InWhatOrder runOrder() const  { return m_data.runOrder; }
+        virtual unsigned int rngSeed() const    { return m_data.rngSeed; }
+        virtual bool forceColour() const { return m_data.forceColour; }
+
+    private:
+        ConfigData m_data;
+
+        Stream m_stream;
+        mutable std::ostream m_os;
+        TestSpec m_testSpec;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_clara.h
+#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
+#undef CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+// Declare Clara inside the Catch namespace
+#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
+// #included from: ../external/clara.h
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)
+
+#ifndef STITCH_CLARA_OPEN_NAMESPACE
+#define TWOBLUECUBES_CLARA_H_INCLUDED
+#define STITCH_CLARA_OPEN_NAMESPACE
+#define STITCH_CLARA_CLOSE_NAMESPACE
+#else
+#define STITCH_CLARA_CLOSE_NAMESPACE }
+#endif
+
+#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE
+
+// ----------- #included from tbc_text_format.h -----------
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
+#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+#define TBC_TEXT_FORMAT_H_INCLUDED
+#endif
+
+#include <string>
+#include <vector>
+#include <sstream>
+
+// Use optional outer namespace
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 ),
+            tabChar( '\t' )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+        char tabChar;               // If this char is seen the indent is changed to current pos
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            std::string wrappableChars = " [({.,/|\\-";
+            std::size_t indent = _attr.initialIndent != std::string::npos
+                ? _attr.initialIndent
+                : _attr.indent;
+            std::string remainder = _str;
+
+            while( !remainder.empty() ) {
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+                std::size_t tabPos = std::string::npos;
+                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
+                std::size_t pos = remainder.find_first_of( '\n' );
+                if( pos <= width ) {
+                    width = pos;
+                }
+                pos = remainder.find_last_of( _attr.tabChar, width );
+                if( pos != std::string::npos ) {
+                    tabPos = pos;
+                    if( remainder[width] == '\n' )
+                        width--;
+                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
+                }
+
+                if( width == remainder.size() ) {
+                    spliceLine( indent, remainder, width );
+                }
+                else if( remainder[width] == '\n' ) {
+                    spliceLine( indent, remainder, width );
+                    if( width <= 1 || remainder.size() != 1 )
+                        remainder = remainder.substr( 1 );
+                    indent = _attr.indent;
+                }
+                else {
+                    pos = remainder.find_last_of( wrappableChars, width );
+                    if( pos != std::string::npos && pos > 0 ) {
+                        spliceLine( indent, remainder, pos );
+                        if( remainder[0] == ' ' )
+                            remainder = remainder.substr( 1 );
+                    }
+                    else {
+                        spliceLine( indent, remainder, width-1 );
+                        lines.back() += "-";
+                    }
+                    if( lines.size() == 1 )
+                        indent = _attr.indent;
+                    if( tabPos != std::string::npos )
+                        indent += tabPos;
+                }
+            }
+        }
+
+        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
+            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
+            _remainder = _remainder.substr( _pos );
+        }
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TBC_TEXT_FORMAT_H_INCLUDED
+
+// ----------- end of #include from tbc_text_format.h -----------
+// ........... back in /Users/philnash/Dev/OSS/Clara/srcs/clara.h
+
+#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE
+
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+#include <memory>
+
+// Use optional outer namespace
+#ifdef STITCH_CLARA_OPEN_NAMESPACE
+STITCH_CLARA_OPEN_NAMESPACE
+#endif
+
+namespace Clara {
+
+    struct UnpositionalTag {};
+
+    extern UnpositionalTag _;
+
+#ifdef CLARA_CONFIG_MAIN
+    UnpositionalTag _;
+#endif
+
+    namespace Detail {
+
+#ifdef CLARA_CONSOLE_WIDTH
+    const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+        using namespace Tbc;
+
+        inline bool startsWith( std::string const& str, std::string const& prefix ) {
+            return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix;
+        }
+
+        template<typename T> struct RemoveConstRef{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const>{ typedef T type; };
+
+        template<typename T>    struct IsBool       { static const bool value = false; };
+        template<>              struct IsBool<bool> { static const bool value = true; };
+
+        template<typename T>
+        void convertInto( std::string const& _source, T& _dest ) {
+            std::stringstream ss;
+            ss << _source;
+            ss >> _dest;
+            if( ss.fail() )
+                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
+        }
+        inline void convertInto( std::string const& _source, std::string& _dest ) {
+            _dest = _source;
+        }
+        inline void convertInto( std::string const& _source, bool& _dest ) {
+            std::string sourceLC = _source;
+            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower );
+            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
+                _dest = true;
+            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
+                _dest = false;
+            else
+                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
+        }
+        inline void convertInto( bool _source, bool& _dest ) {
+            _dest = _source;
+        }
+        template<typename T>
+        inline void convertInto( bool, T& ) {
+            throw std::runtime_error( "Invalid conversion" );
+        }
+
+        template<typename ConfigT>
+        struct IArgFunction {
+            virtual ~IArgFunction() {}
+#  ifdef CATCH_CPP11_OR_GREATER
+            IArgFunction()                      = default;
+            IArgFunction( IArgFunction const& ) = default;
+#  endif
+            virtual void set( ConfigT& config, std::string const& value ) const = 0;
+            virtual void setFlag( ConfigT& config ) const = 0;
+            virtual bool takesArg() const = 0;
+            virtual IArgFunction* clone() const = 0;
+        };
+
+        template<typename ConfigT>
+        class BoundArgFunction {
+        public:
+            BoundArgFunction() : functionObj( NULL ) {}
+            BoundArgFunction( IArgFunction<ConfigT>* _functionObj ) : functionObj( _functionObj ) {}
+            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : NULL ) {}
+            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
+                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : NULL;
+                delete functionObj;
+                functionObj = newFunctionObj;
+                return *this;
+            }
+            ~BoundArgFunction() { delete functionObj; }
+
+            void set( ConfigT& config, std::string const& value ) const {
+                functionObj->set( config, value );
+            }
+            void setFlag( ConfigT& config ) const {
+                functionObj->setFlag( config );
+            }
+            bool takesArg() const { return functionObj->takesArg(); }
+
+            bool isSet() const {
+                return functionObj != NULL;
+            }
+        private:
+            IArgFunction<ConfigT>* functionObj;
+        };
+
+        template<typename C>
+        struct NullBinder : IArgFunction<C>{
+            virtual void set( C&, std::string const& ) const {}
+            virtual void setFlag( C& ) const {}
+            virtual bool takesArg() const { return true; }
+            virtual IArgFunction<C>* clone() const { return new NullBinder( *this ); }
+        };
+
+        template<typename C, typename M>
+        struct BoundDataMember : IArgFunction<C>{
+            BoundDataMember( M C::* _member ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                convertInto( stringValue, p.*member );
+            }
+            virtual void setFlag( C& p ) const {
+                convertInto( true, p.*member );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundDataMember( *this ); }
+            M C::* member;
+        };
+        template<typename C, typename M>
+        struct BoundUnaryMethod : IArgFunction<C>{
+            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                typename RemoveConstRef<M>::type value;
+                convertInto( stringValue, value );
+                (p.*member)( value );
+            }
+            virtual void setFlag( C& p ) const {
+                typename RemoveConstRef<M>::type value;
+                convertInto( true, value );
+                (p.*member)( value );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod( *this ); }
+            void (C::*member)( M );
+        };
+        template<typename C>
+        struct BoundNullaryMethod : IArgFunction<C>{
+            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    (p.*member)();
+            }
+            virtual void setFlag( C& p ) const {
+                (p.*member)();
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod( *this ); }
+            void (C::*member)();
+        };
+
+        template<typename C>
+        struct BoundUnaryFunction : IArgFunction<C>{
+            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    function( obj );
+            }
+            virtual void setFlag( C& p ) const {
+                function( p );
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction( *this ); }
+            void (*function)( C& );
+        };
+
+        template<typename C, typename T>
+        struct BoundBinaryFunction : IArgFunction<C>{
+            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                typename RemoveConstRef<T>::type value;
+                convertInto( stringValue, value );
+                function( obj, value );
+            }
+            virtual void setFlag( C& obj ) const {
+                typename RemoveConstRef<T>::type value;
+                convertInto( true, value );
+                function( obj, value );
+            }
+            virtual bool takesArg() const { return !IsBool<T>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction( *this ); }
+            void (*function)( C&, T );
+        };
+
+    } // namespace Detail
+
+    struct Parser {
+        Parser() : separators( " \t=:" ) {}
+
+        struct Token {
+            enum Type { Positional, ShortOpt, LongOpt };
+            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
+            Type type;
+            std::string data;
+        };
+
+        void parseIntoTokens( int argc, char const * const * argv, std::vector<Parser::Token>& tokens ) const {
+            const std::string doubleDash = "--";
+            for( int i = 1; i < argc && argv[i] != doubleDash; ++i )
+                parseIntoTokens( argv[i] , tokens);
+        }
+        void parseIntoTokens( std::string arg, std::vector<Parser::Token>& tokens ) const {
+            while( !arg.empty() ) {
+                Parser::Token token( Parser::Token::Positional, arg );
+                arg = "";
+                if( token.data[0] == '-' ) {
+                    if( token.data.size() > 1 && token.data[1] == '-' ) {
+                        token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) );
+                    }
+                    else {
+                        token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) );
+                        if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) {
+                            arg = "-" + token.data.substr( 1 );
+                            token.data = token.data.substr( 0, 1 );
+                        }
+                    }
+                }
+                if( token.type != Parser::Token::Positional ) {
+                    std::size_t pos = token.data.find_first_of( separators );
+                    if( pos != std::string::npos ) {
+                        arg = token.data.substr( pos+1 );
+                        token.data = token.data.substr( 0, pos );
+                    }
+                }
+                tokens.push_back( token );
+            }
+        }
+        std::string separators;
+    };
+
+    template<typename ConfigT>
+    struct CommonArgProperties {
+        CommonArgProperties() {}
+        CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {}
+
+        Detail::BoundArgFunction<ConfigT> boundField;
+        std::string description;
+        std::string detail;
+        std::string placeholder; // Only value if boundField takes an arg
+
+        bool takesArg() const {
+            return !placeholder.empty();
+        }
+        void validate() const {
+            if( !boundField.isSet() )
+                throw std::logic_error( "option not bound" );
+        }
+    };
+    struct OptionArgProperties {
+        std::vector<std::string> shortNames;
+        std::string longName;
+
+        bool hasShortName( std::string const& shortName ) const {
+            return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end();
+        }
+        bool hasLongName( std::string const& _longName ) const {
+            return _longName == longName;
+        }
+    };
+    struct PositionalArgProperties {
+        PositionalArgProperties() : position( -1 ) {}
+        int position; // -1 means non-positional (floating)
+
+        bool isFixedPositional() const {
+            return position != -1;
+        }
+    };
+
+    template<typename ConfigT>
+    class CommandLine {
+
+        struct Arg : CommonArgProperties<ConfigT>, OptionArgProperties, PositionalArgProperties {
+            Arg() {}
+            Arg( Detail::BoundArgFunction<ConfigT> const& _boundField ) : CommonArgProperties<ConfigT>( _boundField ) {}
+
+            using CommonArgProperties<ConfigT>::placeholder; // !TBD
+
+            std::string dbgName() const {
+                if( !longName.empty() )
+                    return "--" + longName;
+                if( !shortNames.empty() )
+                    return "-" + shortNames[0];
+                return "positional args";
+            }
+            std::string commands() const {
+                std::ostringstream oss;
+                bool first = true;
+                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
+                for(; it != itEnd; ++it ) {
+                    if( first )
+                        first = false;
+                    else
+                        oss << ", ";
+                    oss << "-" << *it;
+                }
+                if( !longName.empty() ) {
+                    if( !first )
+                        oss << ", ";
+                    oss << "--" << longName;
+                }
+                if( !placeholder.empty() )
+                    oss << " <" << placeholder << ">";
+                return oss.str();
+            }
+        };
+
+        // NOTE: std::auto_ptr is deprecated in c++11/c++0x
+#if defined(__cplusplus) && __cplusplus > 199711L
+        typedef std::unique_ptr<Arg> ArgAutoPtr;
+#else
+        typedef std::auto_ptr<Arg> ArgAutoPtr;
+#endif
+
+        friend void addOptName( Arg& arg, std::string const& optName )
+        {
+            if( optName.empty() )
+                return;
+            if( Detail::startsWith( optName, "--" ) ) {
+                if( !arg.longName.empty() )
+                    throw std::logic_error( "Only one long opt may be specified. '"
+                        + arg.longName
+                        + "' already specified, now attempting to add '"
+                        + optName + "'" );
+                arg.longName = optName.substr( 2 );
+            }
+            else if( Detail::startsWith( optName, "-" ) )
+                arg.shortNames.push_back( optName.substr( 1 ) );
+            else
+                throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" );
+        }
+        friend void setPositionalArg( Arg& arg, int position )
+        {
+            arg.position = position;
+        }
+
+        class ArgBuilder {
+        public:
+            ArgBuilder( Arg* arg ) : m_arg( arg ) {}
+
+            // Bind a non-boolean data member (requires placeholder string)
+            template<typename C, typename M>
+            void bind( M C::* field, std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
+                m_arg->placeholder = placeholder;
+            }
+            // Bind a boolean data member (no placeholder required)
+            template<typename C>
+            void bind( bool C::* field ) {
+                m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
+            }
+
+            // Bind a method taking a single, non-boolean argument (requires a placeholder string)
+            template<typename C, typename M>
+            void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundUnaryMethod<C,M>( unaryMethod );
+                m_arg->placeholder = placeholder;
+            }
+
+            // Bind a method taking a single, boolean argument (no placeholder string required)
+            template<typename C>
+            void bind( void (C::* unaryMethod)( bool ) ) {
+                m_arg->boundField = new Detail::BoundUnaryMethod<C,bool>( unaryMethod );
+            }
+
+            // Bind a method that takes no arguments (will be called if opt is present)
+            template<typename C>
+            void bind( void (C::* nullaryMethod)() ) {
+                m_arg->boundField = new Detail::BoundNullaryMethod<C>( nullaryMethod );
+            }
+
+            // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
+            template<typename C>
+            void bind( void (* unaryFunction)( C& ) ) {
+                m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
+            }
+
+            // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
+            template<typename C, typename T>
+            void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
+                m_arg->placeholder = placeholder;
+            }
+
+            ArgBuilder& describe( std::string const& description ) {
+                m_arg->description = description;
+                return *this;
+            }
+            ArgBuilder& detail( std::string const& detail ) {
+                m_arg->detail = detail;
+                return *this;
+            }
+
+        protected:
+            Arg* m_arg;
+        };
+
+        class OptBuilder : public ArgBuilder {
+        public:
+            OptBuilder( Arg* arg ) : ArgBuilder( arg ) {}
+            OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {}
+
+            OptBuilder& operator[]( std::string const& optName ) {
+                addOptName( *ArgBuilder::m_arg, optName );
+                return *this;
+            }
+        };
+
+    public:
+
+        CommandLine()
+        :   m_boundProcessName( new Detail::NullBinder<ConfigT>() ),
+            m_highestSpecifiedArgPosition( 0 ),
+            m_throwOnUnrecognisedTokens( false )
+        {}
+        CommandLine( CommandLine const& other )
+        :   m_boundProcessName( other.m_boundProcessName ),
+            m_options ( other.m_options ),
+            m_positionalArgs( other.m_positionalArgs ),
+            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ),
+            m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
+        {
+            if( other.m_floatingArg.get() )
+                m_floatingArg.reset( new Arg( *other.m_floatingArg ) );
+        }
+
+        CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
+            m_throwOnUnrecognisedTokens = shouldThrow;
+            return *this;
+        }
+
+        OptBuilder operator[]( std::string const& optName ) {
+            m_options.push_back( Arg() );
+            addOptName( m_options.back(), optName );
+            OptBuilder builder( &m_options.back() );
+            return builder;
+        }
+
+        ArgBuilder operator[]( int position ) {
+            m_positionalArgs.insert( std::make_pair( position, Arg() ) );
+            if( position > m_highestSpecifiedArgPosition )
+                m_highestSpecifiedArgPosition = position;
+            setPositionalArg( m_positionalArgs[position], position );
+            ArgBuilder builder( &m_positionalArgs[position] );
+            return builder;
+        }
+
+        // Invoke this with the _ instance
+        ArgBuilder operator[]( UnpositionalTag ) {
+            if( m_floatingArg.get() )
+                throw std::logic_error( "Only one unpositional argument can be added" );
+            m_floatingArg.reset( new Arg() );
+            ArgBuilder builder( m_floatingArg.get() );
+            return builder;
+        }
+
+        template<typename C, typename M>
+        void bindProcessName( M C::* field ) {
+            m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
+        }
+        template<typename C, typename M>
+        void bindProcessName( void (C::*_unaryMethod)( M ) ) {
+            m_boundProcessName = new Detail::BoundUnaryMethod<C,M>( _unaryMethod );
+        }
+
+        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
+            typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
+            std::size_t maxWidth = 0;
+            for( it = itBegin; it != itEnd; ++it )
+                maxWidth = (std::max)( maxWidth, it->commands().size() );
+
+            for( it = itBegin; it != itEnd; ++it ) {
+                Detail::Text usage( it->commands(), Detail::TextAttributes()
+                                                        .setWidth( maxWidth+indent )
+                                                        .setIndent( indent ) );
+                Detail::Text desc( it->description, Detail::TextAttributes()
+                                                        .setWidth( width - maxWidth - 3 ) );
+
+                for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) {
+                    std::string usageCol = i < usage.size() ? usage[i] : "";
+                    os << usageCol;
+
+                    if( i < desc.size() && !desc[i].empty() )
+                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
+                            << desc[i];
+                    os << "\n";
+                }
+            }
+        }
+        std::string optUsage() const {
+            std::ostringstream oss;
+            optUsage( oss );
+            return oss.str();
+        }
+
+        void argSynopsis( std::ostream& os ) const {
+            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
+                if( i > 1 )
+                    os << " ";
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
+                if( it != m_positionalArgs.end() )
+                    os << "<" << it->second.placeholder << ">";
+                else if( m_floatingArg.get() )
+                    os << "<" << m_floatingArg->placeholder << ">";
+                else
+                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
+            }
+            // !TBD No indication of mandatory args
+            if( m_floatingArg.get() ) {
+                if( m_highestSpecifiedArgPosition > 1 )
+                    os << " ";
+                os << "[<" << m_floatingArg->placeholder << "> ...]";
+            }
+        }
+        std::string argSynopsis() const {
+            std::ostringstream oss;
+            argSynopsis( oss );
+            return oss.str();
+        }
+
+        void usage( std::ostream& os, std::string const& procName ) const {
+            validate();
+            os << "usage:\n  " << procName << " ";
+            argSynopsis( os );
+            if( !m_options.empty() ) {
+                os << " [options]\n\nwhere options are: \n";
+                optUsage( os, 2 );
+            }
+            os << "\n";
+        }
+        std::string usage( std::string const& procName ) const {
+            std::ostringstream oss;
+            usage( oss, procName );
+            return oss.str();
+        }
+
+        ConfigT parse( int argc, char const * const * argv ) const {
+            ConfigT config;
+            parseInto( argc, argv, config );
+            return config;
+        }
+
+        std::vector<Parser::Token> parseInto( int argc, char const * const * argv, ConfigT& config ) const {
+            std::string processName = argv[0];
+            std::size_t lastSlash = processName.find_last_of( "/\\" );
+            if( lastSlash != std::string::npos )
+                processName = processName.substr( lastSlash+1 );
+            m_boundProcessName.set( config, processName );
+            std::vector<Parser::Token> tokens;
+            Parser parser;
+            parser.parseIntoTokens( argc, argv, tokens );
+            return populate( tokens, config );
+        }
+
+        std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            validate();
+            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
+            unusedTokens = populateFixedArgs( unusedTokens, config );
+            unusedTokens = populateFloatingArgs( unusedTokens, config );
+            return unusedTokens;
+        }
+
+        std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            std::vector<std::string> errors;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
+                for(; it != itEnd; ++it ) {
+                    Arg const& arg = *it;
+
+                    try {
+                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
+                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
+                            if( arg.takesArg() ) {
+                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
+                                    errors.push_back( "Expected argument to option: " + token.data );
+                                else
+                                    arg.boundField.set( config, tokens[++i].data );
+                            }
+                            else {
+                                arg.boundField.setFlag( config );
+                            }
+                            break;
+                        }
+                    }
+                    catch( std::exception& ex ) {
+                        errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" );
+                    }
+                }
+                if( it == itEnd ) {
+                    if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
+                        unusedTokens.push_back( token );
+                    else if( errors.empty() && m_throwOnUnrecognisedTokens )
+                        errors.push_back( "unrecognised option: " + token.data );
+                }
+            }
+            if( !errors.empty() ) {
+                std::ostringstream oss;
+                for( std::vector<std::string>::const_iterator it = errors.begin(), itEnd = errors.end();
+                        it != itEnd;
+                        ++it ) {
+                    if( it != errors.begin() )
+                        oss << "\n";
+                    oss << *it;
+                }
+                throw std::runtime_error( oss.str() );
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            int position = 1;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
+                if( it != m_positionalArgs.end() )
+                    it->second.boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+                if( token.type == Parser::Token::Positional )
+                    position++;
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            if( !m_floatingArg.get() )
+                return tokens;
+            std::vector<Parser::Token> unusedTokens;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                if( token.type == Parser::Token::Positional )
+                    m_floatingArg->boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+            }
+            return unusedTokens;
+        }
+
+        void validate() const
+        {
+            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
+                throw std::logic_error( "No options or arguments specified" );
+
+            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
+                                                            itEnd = m_options.end();
+                    it != itEnd; ++it )
+                it->validate();
+        }
+
+    private:
+        Detail::BoundArgFunction<ConfigT> m_boundProcessName;
+        std::vector<Arg> m_options;
+        std::map<int, Arg> m_positionalArgs;
+        ArgAutoPtr m_floatingArg;
+        int m_highestSpecifiedArgPosition;
+        bool m_throwOnUnrecognisedTokens;
+    };
+
+} // end namespace Clara
+
+STITCH_CLARA_CLOSE_NAMESPACE
+#undef STITCH_CLARA_OPEN_NAMESPACE
+#undef STITCH_CLARA_CLOSE_NAMESPACE
+
+#endif // TWOBLUECUBES_CLARA_H_INCLUDED
+#undef STITCH_CLARA_OPEN_NAMESPACE
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#include <fstream>
+
+namespace Catch {
+
+    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
+    inline void abortAfterX( ConfigData& config, int x ) {
+        if( x < 1 )
+            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
+        config.abortAfter = x;
+    }
+    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }
+
+    inline void addWarning( ConfigData& config, std::string const& _warning ) {
+        if( _warning == "NoAssertions" )
+            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
+        else
+            throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
+    }
+    inline void setOrder( ConfigData& config, std::string const& order ) {
+        if( startsWith( "declared", order ) )
+            config.runOrder = RunTests::InDeclarationOrder;
+        else if( startsWith( "lexical", order ) )
+            config.runOrder = RunTests::InLexicographicalOrder;
+        else if( startsWith( "random", order ) )
+            config.runOrder = RunTests::InRandomOrder;
+        else
+            throw std::runtime_error( "Unrecognised ordering: '" + order + "'" );
+    }
+    inline void setRngSeed( ConfigData& config, std::string const& seed ) {
+        if( seed == "time" ) {
+            config.rngSeed = static_cast<unsigned int>( std::time(0) );
+        }
+        else {
+            std::stringstream ss;
+            ss << seed;
+            ss >> config.rngSeed;
+            if( ss.fail() )
+                throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" );
+        }
+    }
+    inline void setVerbosity( ConfigData& config, int level ) {
+        // !TBD: accept strings?
+        config.verbosity = static_cast<Verbosity::Level>( level );
+    }
+    inline void setShowDurations( ConfigData& config, bool _showDurations ) {
+        config.showDurations = _showDurations
+            ? ShowDurations::Always
+            : ShowDurations::Never;
+    }
+    inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
+        std::ifstream f( _filename.c_str() );
+        if( !f.is_open() )
+            throw std::domain_error( "Unable to load input file: " + _filename );
+
+        std::string line;
+        while( std::getline( f, line ) ) {
+            line = trim(line);
+            if( !line.empty() && !startsWith( line, "#" ) )
+                addTestOrTags( config, "\"" + line + "\"," );
+        }
+    }
+
+    inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
+
+        using namespace Clara;
+        CommandLine<ConfigData> cli;
+
+        cli.bindProcessName( &ConfigData::processName );
+
+        cli["-?"]["-h"]["--help"]
+            .describe( "display usage information" )
+            .bind( &ConfigData::showHelp );
+
+        cli["-l"]["--list-tests"]
+            .describe( "list all/matching test cases" )
+            .bind( &ConfigData::listTests );
+
+        cli["-t"]["--list-tags"]
+            .describe( "list all/matching tags" )
+            .bind( &ConfigData::listTags );
+
+        cli["-s"]["--success"]
+            .describe( "include successful tests in output" )
+            .bind( &ConfigData::showSuccessfulTests );
+
+        cli["-b"]["--break"]
+            .describe( "break into debugger on failure" )
+            .bind( &ConfigData::shouldDebugBreak );
+
+        cli["-e"]["--nothrow"]
+            .describe( "skip exception tests" )
+            .bind( &ConfigData::noThrow );
+
+        cli["-i"]["--invisibles"]
+            .describe( "show invisibles (tabs, newlines)" )
+            .bind( &ConfigData::showInvisibles );
+
+        cli["-o"]["--out"]
+            .describe( "output filename" )
+            .bind( &ConfigData::outputFilename, "filename" );
+
+        cli["-r"]["--reporter"]
+//            .placeholder( "name[:filename]" )
+            .describe( "reporter to use (defaults to console)" )
+            .bind( &ConfigData::reporterName, "name" );
+
+        cli["-n"]["--name"]
+            .describe( "suite name" )
+            .bind( &ConfigData::name, "name" );
+
+        cli["-a"]["--abort"]
+            .describe( "abort at first failure" )
+            .bind( &abortAfterFirst );
+
+        cli["-x"]["--abortx"]
+            .describe( "abort after x failures" )
+            .bind( &abortAfterX, "no. failures" );
+
+        cli["-w"]["--warn"]
+            .describe( "enable warnings" )
+            .bind( &addWarning, "warning name" );
+
+// - needs updating if reinstated
+//        cli.into( &setVerbosity )
+//            .describe( "level of verbosity (0=no output)" )
+//            .shortOpt( "v")
+//            .longOpt( "verbosity" )
+//            .placeholder( "level" );
+
+        cli[_]
+            .describe( "which test or tests to use" )
+            .bind( &addTestOrTags, "test name, pattern or tags" );
+
+        cli["-d"]["--durations"]
+            .describe( "show test durations" )
+            .bind( &setShowDurations, "yes/no" );
+
+        cli["-f"]["--input-file"]
+            .describe( "load test names to run from a file" )
+            .bind( &loadTestNamesFromFile, "filename" );
+
+        // Less common commands which don't have a short form
+        cli["--list-test-names-only"]
+            .describe( "list all/matching test cases names only" )
+            .bind( &ConfigData::listTestNamesOnly );
+
+        cli["--list-reporters"]
+            .describe( "list all reporters" )
+            .bind( &ConfigData::listReporters );
+
+        cli["--order"]
+            .describe( "test case order (defaults to decl)" )
+            .bind( &setOrder, "decl|lex|rand" );
+
+        cli["--rng-seed"]
+            .describe( "set a specific seed for random numbers" )
+            .bind( &setRngSeed, "'time'|number" );
+
+        cli["--force-colour"]
+            .describe( "force colourised output" )
+            .bind( &ConfigData::forceColour );
+
+        return cli;
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_list.hpp
+#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
+
+// #included from: catch_text.h
+#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
+
+#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
+// #included from: ../external/tbc_text_format.h
+// Only use header guard if we are not using an outer namespace
+#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#  endif
+# else
+#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+# endif
+#endif
+#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#include <string>
+#include <vector>
+#include <sstream>
+
+// Use optional outer namespace
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 ),
+            tabChar( '\t' )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+        char tabChar;               // If this char is seen the indent is changed to current pos
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            std::string wrappableChars = " [({.,/|\\-";
+            std::size_t indent = _attr.initialIndent != std::string::npos
+                ? _attr.initialIndent
+                : _attr.indent;
+            std::string remainder = _str;
+
+            while( !remainder.empty() ) {
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+                std::size_t tabPos = std::string::npos;
+                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
+                std::size_t pos = remainder.find_first_of( '\n' );
+                if( pos <= width ) {
+                    width = pos;
+                }
+                pos = remainder.find_last_of( _attr.tabChar, width );
+                if( pos != std::string::npos ) {
+                    tabPos = pos;
+                    if( remainder[width] == '\n' )
+                        width--;
+                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
+                }
+
+                if( width == remainder.size() ) {
+                    spliceLine( indent, remainder, width );
+                }
+                else if( remainder[width] == '\n' ) {
+                    spliceLine( indent, remainder, width );
+                    if( width <= 1 || remainder.size() != 1 )
+                        remainder = remainder.substr( 1 );
+                    indent = _attr.indent;
+                }
+                else {
+                    pos = remainder.find_last_of( wrappableChars, width );
+                    if( pos != std::string::npos && pos > 0 ) {
+                        spliceLine( indent, remainder, pos );
+                        if( remainder[0] == ' ' )
+                            remainder = remainder.substr( 1 );
+                    }
+                    else {
+                        spliceLine( indent, remainder, width-1 );
+                        lines.back() += "-";
+                    }
+                    if( lines.size() == 1 )
+                        indent = _attr.indent;
+                    if( tabPos != std::string::npos )
+                        indent += tabPos;
+                }
+            }
+        }
+
+        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
+            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
+            _remainder = _remainder.substr( _pos );
+        }
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+
+namespace Catch {
+    using Tbc::Text;
+    using Tbc::TextAttributes;
+}
+
+// #included from: catch_console_colour.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+namespace Catch {
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = Yellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = Yellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour const& other );
+        ~Colour();
+
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
+
+    private:
+        bool m_moved;
+    };
+
+    inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; }
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_reporter.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED
+
+#include <string>
+#include <ostream>
+#include <map>
+#include <assert.h>
+
+namespace Catch
+{
+    struct ReporterConfig {
+        explicit ReporterConfig( Ptr<IConfig> const& _fullConfig )
+        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+        ReporterConfig( Ptr<IConfig> const& _fullConfig, std::ostream& _stream )
+        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+        std::ostream& stream() const    { return *m_stream; }
+        Ptr<IConfig> fullConfig() const { return m_fullConfig; }
+
+    private:
+        std::ostream* m_stream;
+        Ptr<IConfig> m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        ReporterPreferences()
+        : shouldRedirectStdOut( false )
+        {}
+
+        bool shouldRedirectStdOut;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat() : used( false ) {}
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name ) : name( _name ) {}
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount )
+        :   name( _name ),
+            groupIndex( _groupIndex ),
+            groupsCounts( _groupsCount )
+        {}
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals )
+        :   assertionResult( _assertionResult ),
+            infoMessages( _infoMessages ),
+            totals( _totals )
+        {
+            if( assertionResult.hasMessage() ) {
+                // Copy message into messages list.
+                // !TBD This should have been done earlier, somewhere
+                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+                builder << assertionResult.getMessage();
+                builder.m_info.message = builder.m_stream.str();
+
+                infoMessages.push_back( builder.m_info );
+            }
+        }
+        virtual ~AssertionStats();
+
+#  ifdef CATCH_CPP11_OR_GREATER
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = default;
+        AssertionStats& operator = ( AssertionStats && )     = default;
+#  endif
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions )
+        :   sectionInfo( _sectionInfo ),
+            assertions( _assertions ),
+            durationInSeconds( _durationInSeconds ),
+            missingAssertions( _missingAssertions )
+        {}
+        virtual ~SectionStats();
+#  ifdef CATCH_CPP11_OR_GREATER
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+#  endif
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting )
+        : testInfo( _testInfo ),
+            totals( _totals ),
+            stdOut( _stdOut ),
+            stdErr( _stdErr ),
+            aborting( _aborting )
+        {}
+        virtual ~TestCaseStats();
+
+#  ifdef CATCH_CPP11_OR_GREATER
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+#  endif
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   groupInfo( _groupInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        TestGroupStats( GroupInfo const& _groupInfo )
+        :   groupInfo( _groupInfo ),
+            aborting( false )
+        {}
+        virtual ~TestGroupStats();
+
+#  ifdef CATCH_CPP11_OR_GREATER
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+#  endif
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   runInfo( _runInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        virtual ~TestRunStats();
+
+#  ifndef CATCH_CPP11_OR_GREATER
+        TestRunStats( TestRunStats const& _other )
+        :   runInfo( _other.runInfo ),
+            totals( _other.totals ),
+            aborting( _other.aborting )
+        {}
+#  else
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+#  endif
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct IStreamingReporter : IShared {
+        virtual ~IStreamingReporter();
+
+        // Implementing class must also provide the following static method:
+        // static std::string getDescription();
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+    };
+
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+
+    struct IReporterRegistry {
+        typedef std::map<std::string, IReporterFactory*> FactoryMap;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+    };
+
+}
+
+#include <limits>
+#include <algorithm>
+
+namespace Catch {
+
+    inline std::size_t listTests( Config const& config ) {
+
+        TestSpec testSpec = config.testSpec();
+        if( config.testSpec().hasFilters() )
+            Catch::cout() << "Matching test cases:\n";
+        else {
+            Catch::cout() << "All available test cases:\n";
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        }
+
+        std::size_t matchedTests = 0;
+        TextAttributes nameAttr, tagsAttr;
+        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
+        tagsAttr.setIndent( 6 );
+
+        std::vector<TestCase> matchedTestCases;
+        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            matchedTests++;
+            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
+            if( !testCaseInfo.tags.empty() )
+                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
+        }
+
+        if( !config.testSpec().hasFilters() )
+            Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
+        else
+            Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
+        return matchedTests;
+    }
+
+    inline std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec testSpec = config.testSpec();
+        if( !config.testSpec().hasFilters() )
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases;
+        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            matchedTests++;
+            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+            Catch::cout() << testCaseInfo.name << std::endl;
+        }
+        return matchedTests;
+    }
+
+    struct TagInfo {
+        TagInfo() : count ( 0 ) {}
+        void add( std::string const& spelling ) {
+            ++count;
+            spellings.insert( spelling );
+        }
+        std::string all() const {
+            std::string out;
+            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
+                        it != itEnd;
+                        ++it )
+                out += "[" + *it + "]";
+            return out;
+        }
+        std::set<std::string> spellings;
+        std::size_t count;
+    };
+
+    inline std::size_t listTags( Config const& config ) {
+        TestSpec testSpec = config.testSpec();
+        if( config.testSpec().hasFilters() )
+            Catch::cout() << "Tags for matching test cases:\n";
+        else {
+            Catch::cout() << "All available tags:\n";
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases;
+        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
+                                                        tagItEnd = it->getTestCaseInfo().tags.end();
+                    tagIt != tagItEnd;
+                    ++tagIt ) {
+                std::string tagName = *tagIt;
+                std::string lcaseTagName = toLower( tagName );
+                std::map<std::string, TagInfo>::iterator countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
+                                                            countItEnd = tagCounts.end();
+                countIt != countItEnd;
+                ++countIt ) {
+            std::ostringstream oss;
+            oss << "  " << std::setw(2) << countIt->second.count << "  ";
+            Text wrapper( countIt->second.all(), TextAttributes()
+                                                    .setInitialIndent( 0 )
+                                                    .setIndent( oss.str().size() )
+                                                    .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
+            Catch::cout() << oss.str() << wrapper << "\n";
+        }
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
+        return tagCounts.size();
+    }
+
+    inline std::size_t listReporters( Config const& /*config*/ ) {
+        Catch::cout() << "Available reporters:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
+        std::size_t maxNameLen = 0;
+        for(it = itBegin; it != itEnd; ++it )
+            maxNameLen = (std::max)( maxNameLen, it->first.size() );
+
+        for(it = itBegin; it != itEnd; ++it ) {
+            Text wrapper( it->second->getDescription(), TextAttributes()
+                                                        .setInitialIndent( 0 )
+                                                        .setIndent( 7+maxNameLen )
+                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
+            Catch::cout() << "  "
+                    << it->first
+                    << ":"
+                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
+                    << wrapper << "\n";
+        }
+        Catch::cout() << std::endl;
+        return factories.size();
+    }
+
+    inline Option<std::size_t> list( Config const& config ) {
+        Option<std::size_t> listedCount;
+        if( config.listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( config );
+        if( config.listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
+        if( config.listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( config );
+        if( config.listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters( config );
+        return listedCount;
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_runner_impl.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
+
+// #included from: catch_test_case_tracker.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+#include <map>
+#include <string>
+#include <assert.h>
+
+namespace Catch {
+namespace SectionTracking {
+
+    class TrackedSection {
+
+        typedef std::map<std::string, TrackedSection> TrackedSections;
+
+    public:
+        enum RunState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            Completed
+        };
+
+        TrackedSection( std::string const& name, TrackedSection* parent )
+        :   m_name( name ), m_runState( NotStarted ), m_parent( parent )
+        {}
+
+        RunState runState() const { return m_runState; }
+
+        TrackedSection* findChild( std::string const& childName ) {
+            TrackedSections::iterator it = m_children.find( childName );
+            return it != m_children.end()
+                ? &it->second
+                : NULL;
+        }
+        TrackedSection* acquireChild( std::string const& childName ) {
+            if( TrackedSection* child = findChild( childName ) )
+                return child;
+            m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) );
+            return findChild( childName );
+        }
+        void enter() {
+            if( m_runState == NotStarted )
+                m_runState = Executing;
+        }
+        void leave() {
+            for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end();
+                    it != itEnd;
+                    ++it )
+                if( it->second.runState() != Completed ) {
+                    m_runState = ExecutingChildren;
+                    return;
+                }
+            m_runState = Completed;
+        }
+        TrackedSection* getParent() {
+            return m_parent;
+        }
+        bool hasChildren() const {
+            return !m_children.empty();
+        }
+
+    private:
+        std::string m_name;
+        RunState m_runState;
+        TrackedSections m_children;
+        TrackedSection* m_parent;
+
+    };
+
+    class TestCaseTracker {
+    public:
+        TestCaseTracker( std::string const& testCaseName )
+        :   m_testCase( testCaseName, NULL ),
+            m_currentSection( &m_testCase ),
+            m_completedASectionThisRun( false )
+        {}
+
+        bool enterSection( std::string const& name ) {
+            TrackedSection* child = m_currentSection->acquireChild( name );
+            if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed )
+                return false;
+
+            m_currentSection = child;
+            m_currentSection->enter();
+            return true;
+        }
+        void leaveSection() {
+            m_currentSection->leave();
+            m_currentSection = m_currentSection->getParent();
+            assert( m_currentSection != NULL );
+            m_completedASectionThisRun = true;
+        }
+
+        bool currentSectionHasChildren() const {
+            return m_currentSection->hasChildren();
+        }
+        bool isCompleted() const {
+            return m_testCase.runState() == TrackedSection::Completed;
+        }
+
+        class Guard {
+        public:
+            Guard( TestCaseTracker& tracker ) : m_tracker( tracker ) {
+                m_tracker.enterTestCase();
+            }
+            ~Guard() {
+                m_tracker.leaveTestCase();
+            }
+        private:
+            Guard( Guard const& );
+            void operator = ( Guard const& );
+            TestCaseTracker& m_tracker;
+        };
+
+    private:
+        void enterTestCase() {
+            m_currentSection = &m_testCase;
+            m_completedASectionThisRun = false;
+            m_testCase.enter();
+        }
+        void leaveTestCase() {
+            m_testCase.leave();
+        }
+
+        TrackedSection m_testCase;
+        TrackedSection* m_currentSection;
+        bool m_completedASectionThisRun;
+    };
+
+} // namespace SectionTracking
+
+using SectionTracking::TestCaseTracker;
+
+} // namespace Catch
+
+// #included from: catch_fatal_condition.hpp
+#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
+
+namespace Catch {
+
+    // Report the error condition then exit the process
+    inline void fatal( std::string const& message, int exitCode ) {
+        IContext& context = Catch::getCurrentContext();
+        IResultCapture* resultCapture = context.getResultCapture();
+        resultCapture->handleFatalErrorCondition( message );
+
+		if( Catch::alwaysTrue() ) // avoids "no return" warnings
+            exit( exitCode );
+    }
+
+} // namespace Catch
+
+#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+		void reset() {}
+	};
+
+} // namespace Catch
+
+#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct SignalDefs { int id; const char* name; };
+    extern SignalDefs signalDefs[];
+    SignalDefs signalDefs[] = {
+            { SIGINT,  "SIGINT - Terminal interrupt signal" },
+            { SIGILL,  "SIGILL - Illegal instruction signal" },
+            { SIGFPE,  "SIGFPE - Floating point error signal" },
+            { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+            { SIGTERM, "SIGTERM - Termination request signal" },
+            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+        };
+
+    struct FatalConditionHandler {
+
+        static void handleSignal( int sig ) {
+            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
+                if( sig == signalDefs[i].id )
+                    fatal( signalDefs[i].name, -sig );
+            fatal( "<unknown signal>", -sig );
+        }
+
+        FatalConditionHandler() : m_isSet( true ) {
+            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
+                signal( signalDefs[i].id, handleSignal );
+        }
+        ~FatalConditionHandler() {
+            reset();
+        }
+        void reset() {
+            if( m_isSet ) {
+                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
+                    signal( signalDefs[i].id, SIG_DFL );
+                m_isSet = false;
+            }
+        }
+
+        bool m_isSet;
+    };
+
+} // namespace Catch
+
+#endif // not Windows
+
+#include <set>
+#include <string>
+
+namespace Catch {
+
+    class StreamRedirect {
+
+    public:
+        StreamRedirect( std::ostream& stream, std::string& targetString )
+        :   m_stream( stream ),
+            m_prevBuf( stream.rdbuf() ),
+            m_targetString( targetString )
+        {
+            stream.rdbuf( m_oss.rdbuf() );
+        }
+
+        ~StreamRedirect() {
+            m_targetString += m_oss.str();
+            m_stream.rdbuf( m_prevBuf );
+        }
+
+    private:
+        std::ostream& m_stream;
+        std::streambuf* m_prevBuf;
+        std::ostringstream m_oss;
+        std::string& m_targetString;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+        RunContext( RunContext const& );
+        void operator =( RunContext const& );
+
+    public:
+
+        explicit RunContext( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> const& reporter )
+        :   m_runInfo( config->name() ),
+            m_context( getCurrentMutableContext() ),
+            m_activeTestCase( NULL ),
+            m_config( config ),
+            m_reporter( reporter ),
+            m_prevRunner( m_context.getRunner() ),
+            m_prevResultCapture( m_context.getResultCapture() ),
+            m_prevConfig( m_context.getConfig() )
+        {
+            m_context.setRunner( this );
+            m_context.setConfig( m_config );
+            m_context.setResultCapture( this );
+            m_reporter->testRunStarting( m_runInfo );
+        }
+
+        virtual ~RunContext() {
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
+            m_context.setRunner( m_prevRunner );
+            m_context.setConfig( NULL );
+            m_context.setResultCapture( m_prevResultCapture );
+            m_context.setConfig( m_prevConfig );
+        }
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
+        }
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
+        }
+
+        Totals runTest( TestCase const& testCase ) {
+            Totals prevTotals = m_totals;
+
+            std::string redirectedCout;
+            std::string redirectedCerr;
+
+            TestCaseInfo testInfo = testCase.getTestCaseInfo();
+
+            m_reporter->testCaseStarting( testInfo );
+
+            m_activeTestCase = &testCase;
+            m_testCaseTracker = TestCaseTracker( testInfo.name );
+
+            do {
+                do {
+                    runCurrentTest( redirectedCout, redirectedCerr );
+                }
+                while( !m_testCaseTracker->isCompleted() && !aborting() );
+            }
+            while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
+
+            Totals deltaTotals = m_totals.delta( prevTotals );
+            m_totals.testCases += deltaTotals.testCases;
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        redirectedCout,
+                                                        redirectedCerr,
+                                                        aborting() ) );
+
+            m_activeTestCase = NULL;
+            m_testCaseTracker.reset();
+
+            return deltaTotals;
+        }
+
+        Ptr<IConfig const> config() const {
+            return m_config;
+        }
+
+    private: // IResultCapture
+
+        virtual void assertionEnded( AssertionResult const& result ) {
+            if( result.getResultType() == ResultWas::Ok ) {
+                m_totals.assertions.passed++;
+            }
+            else if( !result.isOk() ) {
+                m_totals.assertions.failed++;
+            }
+
+            if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) )
+                m_messages.clear();
+
+            // Reset working state
+            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
+            m_lastResult = result;
+        }
+
+        virtual bool sectionStarted (
+            SectionInfo const& sectionInfo,
+            Counts& assertions
+        )
+        {
+            std::ostringstream oss;
+            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;
+
+            if( !m_testCaseTracker->enterSection( oss.str() ) )
+                return false;
+
+            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+            m_reporter->sectionStarting( sectionInfo );
+
+            assertions = m_totals.assertions;
+
+            return true;
+        }
+        bool testForMissingAssertions( Counts& assertions ) {
+            if( assertions.total() != 0 ||
+                    !m_config->warnAboutMissingAssertions() ||
+                    m_testCaseTracker->currentSectionHasChildren() )
+                return false;
+            m_totals.assertions.failed++;
+            assertions.failed++;
+            return true;
+        }
+
+        virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) {
+            if( std::uncaught_exception() ) {
+                m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) );
+                return;
+            }
+
+            Counts assertions = m_totals.assertions - prevAssertions;
+            bool missingAssertions = testForMissingAssertions( assertions );
+
+            m_testCaseTracker->leaveSection();
+
+            m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) );
+            m_messages.clear();
+        }
+
+        virtual void pushScopedMessage( MessageInfo const& message ) {
+            m_messages.push_back( message );
+        }
+
+        virtual void popScopedMessage( MessageInfo const& message ) {
+            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
+        }
+
+        virtual std::string getCurrentTestName() const {
+            return m_activeTestCase
+                ? m_activeTestCase->getTestCaseInfo().name
+                : "";
+        }
+
+        virtual const AssertionResult* getLastResult() const {
+            return &m_lastResult;
+        }
+
+        virtual void handleFatalErrorCondition( std::string const& message ) {
+            ResultBuilder resultBuilder = makeUnexpectedResultBuilder();
+            resultBuilder.setResultType( ResultWas::FatalErrorCondition );
+            resultBuilder << message;
+            resultBuilder.captureExpression();
+
+            handleUnfinishedSections();
+
+            // Recreate section for test case (as we will lose the one that was in scope)
+            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
+
+            Counts assertions;
+            assertions.failed = 1;
+            SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
+            m_reporter->sectionEnded( testCaseSectionStats );
+
+            TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
+
+            Totals deltaTotals;
+            deltaTotals.testCases.failed = 1;
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        "",
+                                                        "",
+                                                        false ) );
+            m_totals.testCases.failed++;
+            testGroupEnded( "", m_totals, 1, 1 );
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
+        }
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const {
+            return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
+        }
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
+            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
+            m_reporter->sectionStarting( testCaseSection );
+            Counts prevAssertions = m_totals.assertions;
+            double duration = 0;
+            try {
+                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
+                TestCaseTracker::Guard guard( *m_testCaseTracker );
+
+                Timer timer;
+                timer.start();
+                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
+                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
+                    StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr );
+                    invokeActiveTestCase();
+                }
+                else {
+                    invokeActiveTestCase();
+                }
+                duration = timer.getElapsedSeconds();
+            }
+            catch( TestFailureException& ) {
+                // This just means the test was aborted due to failure
+            }
+            catch(...) {
+                makeUnexpectedResultBuilder().useActiveException();
+            }
+            handleUnfinishedSections();
+            m_messages.clear();
+
+            Counts assertions = m_totals.assertions - prevAssertions;
+            bool missingAssertions = testForMissingAssertions( assertions );
+
+            if( testCaseInfo.okToFail() ) {
+                std::swap( assertions.failedButOk, assertions.failed );
+                m_totals.assertions.failed -= assertions.failedButOk;
+                m_totals.assertions.failedButOk += assertions.failedButOk;
+            }
+
+            SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
+            m_reporter->sectionEnded( testCaseSectionStats );
+        }
+
+        void invokeActiveTestCase() {
+            FatalConditionHandler fatalConditionHandler; // Handle signals
+            m_activeTestCase->invoke();
+            fatalConditionHandler.reset();
+        }
+
+    private:
+
+        ResultBuilder makeUnexpectedResultBuilder() const {
+            return ResultBuilder(   m_lastAssertionInfo.macroName.c_str(),
+                                    m_lastAssertionInfo.lineInfo,
+                                    m_lastAssertionInfo.capturedExpression.c_str(),
+                                    m_lastAssertionInfo.resultDisposition );
+        }
+
+        void handleUnfinishedSections() {
+            // If sections ended prematurely due to an exception we stored their
+            // infos here so we can tear them down outside the unwind process.
+            for( std::vector<UnfinishedSections>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
+                        itEnd = m_unfinishedSections.rend();
+                    it != itEnd;
+                    ++it )
+                sectionEnded( it->info, it->prevAssertions, it->durationInSeconds );
+            m_unfinishedSections.clear();
+        }
+
+        struct UnfinishedSections {
+            UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds )
+            : info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
+            {}
+
+            SectionInfo info;
+            Counts prevAssertions;
+            double durationInSeconds;
+        };
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase;
+        Option<TestCaseTracker> m_testCaseTracker;
+        AssertionResult m_lastResult;
+
+        Ptr<IConfig const> m_config;
+        Totals m_totals;
+        Ptr<IStreamingReporter> m_reporter;
+        std::vector<MessageInfo> m_messages;
+        IRunner* m_prevRunner;
+        IResultCapture* m_prevResultCapture;
+        Ptr<IConfig const> m_prevConfig;
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<UnfinishedSections> m_unfinishedSections;
+    };
+
+    IResultCapture& getResultCapture() {
+        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
+            return *capture;
+        else
+            throw std::logic_error( "No result capture instance" );
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_version.h
+#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _buildNumber,
+                    char const* const _branchName )
+        :   majorVersion( _majorVersion ),
+            minorVersion( _minorVersion ),
+            buildNumber( _buildNumber ),
+            branchName( _branchName )
+        {}
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const buildNumber;
+        char const* const branchName;
+
+    private:
+        void operator=( Version const& );
+    };
+
+    extern Version libraryVersion;
+}
+
+#include <fstream>
+#include <stdlib.h>
+#include <limits>
+
+namespace Catch {
+
+    class Runner {
+
+    public:
+        Runner( Ptr<Config> const& config )
+        :   m_config( config )
+        {
+            openStream();
+            makeReporter();
+        }
+
+        Totals runTests() {
+
+            RunContext context( m_config.get(), m_reporter );
+
+            Totals totals;
+
+            context.testGroupStarting( "all tests", 1, 1 ); // deprecated?
+
+            TestSpec testSpec = m_config->testSpec();
+            if( !testSpec.hasFilters() )
+                testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
+
+            std::vector<TestCase> testCases;
+            getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, testCases );
+
+            int testsRunForGroup = 0;
+            for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
+                    it != itEnd;
+                    ++it ) {
+                testsRunForGroup++;
+                if( m_testsAlreadyRun.find( *it ) == m_testsAlreadyRun.end() ) {
+
+                    if( context.aborting() )
+                        break;
+
+                    totals += context.runTest( *it );
+                    m_testsAlreadyRun.insert( *it );
+                }
+            }
+            std::vector<TestCase> skippedTestCases;
+            getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, skippedTestCases, true );
+
+            for( std::vector<TestCase>::const_iterator it = skippedTestCases.begin(), itEnd = skippedTestCases.end();
+                    it != itEnd;
+                    ++it )
+                m_reporter->skipTest( *it );
+
+            context.testGroupEnded( "all tests", totals, 1, 1 );
+            return totals;
+        }
+
+    private:
+        void openStream() {
+            // Open output file, if specified
+            if( !m_config->getFilename().empty() ) {
+                m_ofs.open( m_config->getFilename().c_str() );
+                if( m_ofs.fail() ) {
+                    std::ostringstream oss;
+                    oss << "Unable to open file: '" << m_config->getFilename() << "'";
+                    throw std::domain_error( oss.str() );
+                }
+                m_config->setStreamBuf( m_ofs.rdbuf() );
+            }
+        }
+        void makeReporter() {
+            std::string reporterName = m_config->getReporterName().empty()
+                ? "console"
+                : m_config->getReporterName();
+
+            m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() );
+            if( !m_reporter ) {
+                std::ostringstream oss;
+                oss << "No reporter registered with name: '" << reporterName << "'";
+                throw std::domain_error( oss.str() );
+            }
+        }
+
+    private:
+        Ptr<Config> m_config;
+        std::ofstream m_ofs;
+        Ptr<IStreamingReporter> m_reporter;
+        std::set<TestCase> m_testsAlreadyRun;
+    };
+
+    class Session : NonCopyable {
+        static bool alreadyInstantiated;
+
+    public:
+
+        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
+
+        Session()
+        : m_cli( makeCommandLineParser() ) {
+            if( alreadyInstantiated ) {
+                std::string msg = "Only one instance of Catch::Session can ever be used";
+                Catch::cerr() << msg << std::endl;
+                throw std::logic_error( msg );
+            }
+            alreadyInstantiated = true;
+        }
+        ~Session() {
+            Catch::cleanUp();
+        }
+
+        void showHelp( std::string const& processName ) {
+            Catch::cout() << "\nCatch v"    << libraryVersion.majorVersion << "."
+                                        << libraryVersion.minorVersion << " build "
+                                        << libraryVersion.buildNumber;
+            if( libraryVersion.branchName != std::string( "master" ) )
+                Catch::cout() << " (" << libraryVersion.branchName << " branch)";
+            Catch::cout() << "\n";
+
+            m_cli.usage( Catch::cout(), processName );
+            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
+        }
+
+        int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
+            try {
+                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
+                m_unusedTokens = m_cli.parseInto( argc, argv, m_configData );
+                if( m_configData.showHelp )
+                    showHelp( m_configData.processName );
+                m_config.reset();
+            }
+            catch( std::exception& ex ) {
+                {
+                    Colour colourGuard( Colour::Red );
+                    Catch::cerr()   << "\nError(s) in input:\n"
+                                << Text( ex.what(), TextAttributes().setIndent(2) )
+                                << "\n\n";
+                }
+                m_cli.usage( Catch::cout(), m_configData.processName );
+                return (std::numeric_limits<int>::max)();
+            }
+            return 0;
+        }
+
+        void useConfigData( ConfigData const& _configData ) {
+            m_configData = _configData;
+            m_config.reset();
+        }
+
+        int run( int argc, char* const argv[] ) {
+
+            int returnCode = applyCommandLine( argc, argv );
+            if( returnCode == 0 )
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run() {
+            if( m_configData.showHelp )
+                return 0;
+
+            try
+            {
+                config(); // Force config to be constructed
+
+                std::srand( m_configData.rngSeed );
+
+                Runner runner( m_config );
+
+                // Handle list request
+                if( Option<std::size_t> listed = list( config() ) )
+                    return static_cast<int>( *listed );
+
+                return static_cast<int>( runner.runTests().assertions.failed );
+            }
+            catch( std::exception& ex ) {
+                Catch::cerr() << ex.what() << std::endl;
+                return (std::numeric_limits<int>::max)();
+            }
+        }
+
+        Clara::CommandLine<ConfigData> const& cli() const {
+            return m_cli;
+        }
+        std::vector<Clara::Parser::Token> const& unusedTokens() const {
+            return m_unusedTokens;
+        }
+        ConfigData& configData() {
+            return m_configData;
+        }
+        Config& config() {
+            if( !m_config )
+                m_config = new Config( m_configData );
+            return *m_config;
+        }
+
+    private:
+        Clara::CommandLine<ConfigData> m_cli;
+        std::vector<Clara::Parser::Token> m_unusedTokens;
+        ConfigData m_configData;
+        Ptr<Config> m_config;
+    };
+
+    bool Session::alreadyInstantiated = false;
+
+} // end namespace Catch
+
+// #included from: catch_registry_hub.hpp
+#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED
+
+// #included from: catch_test_case_registry_impl.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+#include <vector>
+#include <set>
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+
+namespace Catch {
+
+    class TestRegistry : public ITestCaseRegistry {
+        struct LexSort {
+            bool operator() (TestCase i,TestCase j) const { return (i<j);}
+        };
+        struct RandomNumberGenerator {
+            int operator()( int n ) const { return std::rand() % n; }
+        };
+
+    public:
+        TestRegistry() : m_unnamedCount( 0 ) {}
+        virtual ~TestRegistry();
+
+        virtual void registerTest( TestCase const& testCase ) {
+            std::string name = testCase.getTestCaseInfo().name;
+            if( name == "" ) {
+                std::ostringstream oss;
+                oss << "Anonymous test case " << ++m_unnamedCount;
+                return registerTest( testCase.withName( oss.str() ) );
+            }
+
+            if( m_functions.find( testCase ) == m_functions.end() ) {
+                m_functions.insert( testCase );
+                m_functionsInOrder.push_back( testCase );
+                if( !testCase.isHidden() )
+                    m_nonHiddenFunctions.push_back( testCase );
+            }
+            else {
+                TestCase const& prev = *m_functions.find( testCase );
+                {
+                    Colour colourGuard( Colour::Red );
+                    Catch::cerr()   << "error: TEST_CASE( \"" << name << "\" ) already defined.\n"
+                                << "\tFirst seen at " << prev.getTestCaseInfo().lineInfo << "\n"
+                                << "\tRedefined at " << testCase.getTestCaseInfo().lineInfo << std::endl;
+                }
+                exit(1);
+            }
+        }
+
+        virtual std::vector<TestCase> const& getAllTests() const {
+            return m_functionsInOrder;
+        }
+
+        virtual std::vector<TestCase> const& getAllNonHiddenTests() const {
+            return m_nonHiddenFunctions;
+        }
+
+        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases, bool negated = false ) const {
+
+            for( std::vector<TestCase>::const_iterator  it = m_functionsInOrder.begin(),
+                                                        itEnd = m_functionsInOrder.end();
+                    it != itEnd;
+                    ++it ) {
+                bool includeTest = testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() );
+                if( includeTest != negated )
+                    matchingTestCases.push_back( *it );
+            }
+            sortTests( config, matchingTestCases );
+        }
+
+    private:
+
+        static void sortTests( IConfig const& config, std::vector<TestCase>& matchingTestCases ) {
+
+            switch( config.runOrder() ) {
+                case RunTests::InLexicographicalOrder:
+                    std::sort( matchingTestCases.begin(), matchingTestCases.end(), LexSort() );
+                    break;
+                case RunTests::InRandomOrder:
+                {
+                    RandomNumberGenerator rng;
+                    std::random_shuffle( matchingTestCases.begin(), matchingTestCases.end(), rng );
+                }
+                    break;
+                case RunTests::InDeclarationOrder:
+                    // already in declaration order
+                    break;
+            }
+        }
+        std::set<TestCase> m_functions;
+        std::vector<TestCase> m_functionsInOrder;
+        std::vector<TestCase> m_nonHiddenFunctions;
+        size_t m_unnamedCount;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class FreeFunctionTestCase : public SharedImpl<ITestCase> {
+    public:
+
+        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}
+
+        virtual void invoke() const {
+            m_fun();
+        }
+
+    private:
+        virtual ~FreeFunctionTestCase();
+
+        TestFunction m_fun;
+    };
+
+    inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
+        std::string className = classOrQualifiedMethodName;
+        if( startsWith( className, "&" ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    AutoReg::AutoReg(   TestFunction function,
+                        SourceLineInfo const& lineInfo,
+                        NameAndDesc const& nameAndDesc ) {
+        registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo );
+    }
+
+    AutoReg::~AutoReg() {}
+
+    void AutoReg::registerTestCase( ITestCase* testCase,
+                                    char const* classOrQualifiedMethodName,
+                                    NameAndDesc const& nameAndDesc,
+                                    SourceLineInfo const& lineInfo ) {
+
+        getMutableRegistryHub().registerTest
+            ( makeTestCase( testCase,
+                            extractClassName( classOrQualifiedMethodName ),
+                            nameAndDesc.name,
+                            nameAndDesc.description,
+                            lineInfo ) );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_reporter_registry.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        virtual ~ReporterRegistry() {
+            deleteAllValues( m_factories );
+        }
+
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const {
+            FactoryMap::const_iterator it =  m_factories.find( name );
+            if( it == m_factories.end() )
+                return NULL;
+            return it->second->create( ReporterConfig( config ) );
+        }
+
+        void registerReporter( std::string const& name, IReporterFactory* factory ) {
+            m_factories.insert( std::make_pair( name, factory ) );
+        }
+
+        FactoryMap const& getFactories() const {
+            return m_factories;
+        }
+
+    private:
+        FactoryMap m_factories;
+    };
+}
+
+// #included from: catch_exception_translator_registry.hpp
+#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry() {
+            deleteAll( m_translators );
+        }
+
+        virtual void registerTranslator( const IExceptionTranslator* translator ) {
+            m_translators.push_back( translator );
+        }
+
+        virtual std::string translateActiveException() const {
+            try {
+#ifdef __OBJC__
+                // In Objective-C try objective-c exceptions first
+                @try {
+                    throw;
+                }
+                @catch (NSException *exception) {
+                    return Catch::toString( [exception description] );
+                }
+#else
+                throw;
+#endif
+            }
+            catch( TestFailureException& ) {
+                throw;
+            }
+            catch( std::exception& ex ) {
+                return ex.what();
+            }
+            catch( std::string& msg ) {
+                return msg;
+            }
+            catch( const char* msg ) {
+                return msg;
+            }
+            catch(...) {
+                return tryTranslators( m_translators.begin() );
+            }
+        }
+
+        std::string tryTranslators( std::vector<const IExceptionTranslator*>::const_iterator it ) const {
+            if( it == m_translators.end() )
+                return "Unknown exception";
+
+            try {
+                return (*it)->translate();
+            }
+            catch(...) {
+                return tryTranslators( it+1 );
+            }
+        }
+
+    private:
+        std::vector<const IExceptionTranslator*> m_translators;
+    };
+}
+
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub {
+
+            RegistryHub( RegistryHub const& );
+            void operator=( RegistryHub const& );
+
+        public: // IRegistryHub
+            RegistryHub() {
+            }
+            virtual IReporterRegistry const& getReporterRegistry() const {
+                return m_reporterRegistry;
+            }
+            virtual ITestCaseRegistry const& getTestCaseRegistry() const {
+                return m_testCaseRegistry;
+            }
+            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() {
+                return m_exceptionTranslatorRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            virtual void registerReporter( std::string const& name, IReporterFactory* factory ) {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            virtual void registerTest( TestCase const& testInfo ) {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            virtual void registerTranslator( const IExceptionTranslator* translator ) {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+        };
+
+        // Single, global, instance
+        inline RegistryHub*& getTheRegistryHub() {
+            static RegistryHub* theRegistryHub = NULL;
+            if( !theRegistryHub )
+                theRegistryHub = new RegistryHub();
+            return theRegistryHub;
+        }
+    }
+
+    IRegistryHub& getRegistryHub() {
+        return *getTheRegistryHub();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return *getTheRegistryHub();
+    }
+    void cleanUp() {
+        delete getTheRegistryHub();
+        getTheRegistryHub() = NULL;
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_notimplemented_exception.hpp
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED
+
+#include <ostream>
+
+namespace Catch {
+
+    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
+    :   m_lineInfo( lineInfo ) {
+        std::ostringstream oss;
+        oss << lineInfo << ": function ";
+        oss << "not implemented";
+        m_what = oss.str();
+    }
+
+    const char* NotImplementedException::what() const CATCH_NOEXCEPT {
+        return m_what.c_str();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_context_impl.hpp
+#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED
+
+// #included from: catch_stream.hpp
+#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
+
+// #included from: catch_streambuf.h
+#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
+
+#include <streambuf>
+
+namespace Catch {
+
+    class StreamBufBase : public std::streambuf {
+    public:
+        virtual ~StreamBufBase() CATCH_NOEXCEPT;
+    };
+}
+
+#include <stdexcept>
+#include <cstdio>
+#include <iostream>
+
+namespace Catch {
+
+    template<typename WriterF, size_t bufferSize=256>
+    class StreamBufImpl : public StreamBufBase {
+        char data[bufferSize];
+        WriterF m_writer;
+
+    public:
+        StreamBufImpl() {
+            setp( data, data + sizeof(data) );
+        }
+
+        ~StreamBufImpl() CATCH_NOEXCEPT {
+            sync();
+        }
+
+    private:
+        int overflow( int c ) {
+            sync();
+
+            if( c != EOF ) {
+                if( pbase() == epptr() )
+                    m_writer( std::string( 1, static_cast<char>( c ) ) );
+                else
+                    sputc( static_cast<char>( c ) );
+            }
+            return 0;
+        }
+
+        int sync() {
+            if( pbase() != pptr() ) {
+                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                setp( pbase(), epptr() );
+            }
+            return 0;
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    struct OutputDebugWriter {
+
+        void operator()( std::string const&str ) {
+            writeToDebugConsole( str );
+        }
+    };
+
+    Stream::Stream()
+    : streamBuf( NULL ), isOwned( false )
+    {}
+
+    Stream::Stream( std::streambuf* _streamBuf, bool _isOwned )
+    : streamBuf( _streamBuf ), isOwned( _isOwned )
+    {}
+
+    void Stream::release() {
+        if( isOwned ) {
+            delete streamBuf;
+            streamBuf = NULL;
+            isOwned = false;
+        }
+    }
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement this functions
+    std::ostream& cout() {
+        return std::cout;
+    }
+    std::ostream& cerr() {
+        return std::cerr;
+    }
+#endif
+}
+
+namespace Catch {
+
+    class Context : public IMutableContext {
+
+        Context() : m_config( NULL ), m_runner( NULL ), m_resultCapture( NULL ) {}
+        Context( Context const& );
+        void operator=( Context const& );
+
+    public: // IContext
+        virtual IResultCapture* getResultCapture() {
+            return m_resultCapture;
+        }
+        virtual IRunner* getRunner() {
+            return m_runner;
+        }
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
+            return getGeneratorsForCurrentTest()
+            .getGeneratorInfo( fileInfo, totalSize )
+            .getCurrentIndex();
+        }
+        virtual bool advanceGeneratorsForCurrentTest() {
+            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+            return generators && generators->moveNext();
+        }
+
+        virtual Ptr<IConfig const> getConfig() const {
+            return m_config;
+        }
+
+    public: // IMutableContext
+        virtual void setResultCapture( IResultCapture* resultCapture ) {
+            m_resultCapture = resultCapture;
+        }
+        virtual void setRunner( IRunner* runner ) {
+            m_runner = runner;
+        }
+        virtual void setConfig( Ptr<IConfig const> const& config ) {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IGeneratorsForTest* findGeneratorsForCurrentTest() {
+            std::string testName = getResultCapture()->getCurrentTestName();
+
+            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
+                m_generatorsByTestName.find( testName );
+            return it != m_generatorsByTestName.end()
+                ? it->second
+                : NULL;
+        }
+
+        IGeneratorsForTest& getGeneratorsForCurrentTest() {
+            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+            if( !generators ) {
+                std::string testName = getResultCapture()->getCurrentTestName();
+                generators = createGeneratorsForTest();
+                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
+            }
+            return *generators;
+        }
+
+    private:
+        Ptr<IConfig const> m_config;
+        IRunner* m_runner;
+        IResultCapture* m_resultCapture;
+        std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
+    };
+
+    namespace {
+        Context* currentContext = NULL;
+    }
+    IMutableContext& getCurrentMutableContext() {
+        if( !currentContext )
+            currentContext = new Context();
+        return *currentContext;
+    }
+    IContext& getCurrentContext() {
+        return getCurrentMutableContext();
+    }
+
+    Stream createStream( std::string const& streamName ) {
+        if( streamName == "stdout" ) return Stream( Catch::cout().rdbuf(), false );
+        if( streamName == "stderr" ) return Stream( Catch::cerr().rdbuf(), false );
+        if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );
+
+        throw std::domain_error( "Unknown stream: " + streamName );
+    }
+
+    void cleanUpContext() {
+        delete currentContext;
+        currentContext = NULL;
+    }
+}
+
+// #included from: catch_console_colour_impl.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
+
+namespace Catch {
+    namespace {
+
+        struct IColourImpl {
+            virtual ~IColourImpl() {}
+            virtual void use( Colour::Code _colourCode ) = 0;
+        };
+
+        struct NoColourImpl : IColourImpl {
+            void use( Colour::Code ) {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+
+    } // anon namespace
+} // namespace Catch
+
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
+
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalAttributes = csbiInfo.wAttributes;
+        }
+
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+
+    private:
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute );
+        }
+        HANDLE stdoutHandle;
+        WORD originalAttributes;
+    };
+
+    IColourImpl* platformColourInstance() {
+        static Win32ColourImpl s_instance;
+        return &s_instance;
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+    // use POSIX/ ANSI console terminal codes
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
+    // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public IColourImpl {
+    public:
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0:34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+        static IColourImpl* instance() {
+            static PosixColourImpl s_instance;
+            return &s_instance;
+        }
+
+    private:
+        void setColour( const char* _escapeCode ) {
+            Catch::cout() << '\033' << _escapeCode;
+        }
+    };
+
+    IColourImpl* platformColourInstance() {
+        Ptr<IConfig const> config = getCurrentContext().getConfig();
+        return (config && config->forceColour()) || isatty(STDOUT_FILENO)
+            ? PosixColourImpl::instance()
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#else  // not Windows or ANSI ///////////////////////////////////////////////
+
+namespace Catch {
+
+    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
+
+    Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
+    Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast<Colour&>( _other ).m_moved = true; }
+    Colour::~Colour(){ if( !m_moved ) use( None ); }
+
+    void Colour::use( Code _colourCode ) {
+        static IColourImpl* impl = isDebuggerActive()
+            ? NoColourImpl::instance()
+            : platformColourInstance();
+        impl->use( _colourCode );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_generators_impl.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED
+
+#include <vector>
+#include <string>
+#include <map>
+
+namespace Catch {
+
+    struct GeneratorInfo : IGeneratorInfo {
+
+        GeneratorInfo( std::size_t size )
+        :   m_size( size ),
+            m_currentIndex( 0 )
+        {}
+
+        bool moveNext() {
+            if( ++m_currentIndex == m_size ) {
+                m_currentIndex = 0;
+                return false;
+            }
+            return true;
+        }
+
+        std::size_t getCurrentIndex() const {
+            return m_currentIndex;
+        }
+
+        std::size_t m_size;
+        std::size_t m_currentIndex;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class GeneratorsForTest : public IGeneratorsForTest {
+
+    public:
+        ~GeneratorsForTest() {
+            deleteAll( m_generatorsInOrder );
+        }
+
+        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
+            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
+            if( it == m_generatorsByName.end() ) {
+                IGeneratorInfo* info = new GeneratorInfo( size );
+                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
+                m_generatorsInOrder.push_back( info );
+                return *info;
+            }
+            return *it->second;
+        }
+
+        bool moveNext() {
+            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
+            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
+            for(; it != itEnd; ++it ) {
+                if( (*it)->moveNext() )
+                    return true;
+            }
+            return false;
+        }
+
+    private:
+        std::map<std::string, IGeneratorInfo*> m_generatorsByName;
+        std::vector<IGeneratorInfo*> m_generatorsInOrder;
+    };
+
+    IGeneratorsForTest* createGeneratorsForTest()
+    {
+        return new GeneratorsForTest();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.hpp
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
+
+namespace Catch {
+
+    AssertionInfo::AssertionInfo(   std::string const& _macroName,
+                                    SourceLineInfo const& _lineInfo,
+                                    std::string const& _capturedExpression,
+                                    ResultDisposition::Flags _resultDisposition )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        capturedExpression( _capturedExpression ),
+        resultDisposition( _resultDisposition )
+    {}
+
+    AssertionResult::AssertionResult() {}
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    AssertionResult::~AssertionResult() {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return !m_info.capturedExpression.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        if( isFalseTest( m_info.resultDisposition ) )
+            return "!" + m_info.capturedExpression;
+        else
+            return m_info.capturedExpression;
+    }
+    std::string AssertionResult::getExpressionInMacro() const {
+        if( m_info.macroName.empty() )
+            return m_info.capturedExpression;
+        else
+            return m_info.macroName + "( " + m_info.capturedExpression + " )";
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        return m_resultData.reconstructedExpression;
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    std::string AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_test_case_info.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+namespace Catch {
+
+    inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+        if( startsWith( tag, "." ) ||
+            tag == "hide" ||
+            tag == "!hide" )
+            return TestCaseInfo::IsHidden;
+        else if( tag == "!throws" )
+            return TestCaseInfo::Throws;
+        else if( tag == "!shouldfail" )
+            return TestCaseInfo::ShouldFail;
+        else if( tag == "!mayfail" )
+            return TestCaseInfo::MayFail;
+        else
+            return TestCaseInfo::None;
+    }
+    inline bool isReservedTag( std::string const& tag ) {
+        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] );
+    }
+    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+        if( isReservedTag( tag ) ) {
+            {
+                Colour colourGuard( Colour::Red );
+                Catch::cerr()
+                    << "Tag name [" << tag << "] not allowed.\n"
+                    << "Tag names starting with non alpha-numeric characters are reserved\n";
+            }
+            {
+                Colour colourGuard( Colour::FileName );
+                Catch::cerr() << _lineInfo << std::endl;
+            }
+            exit(1);
+        }
+    }
+
+    TestCase makeTestCase(  ITestCase* _testCase,
+                            std::string const& _className,
+                            std::string const& _name,
+                            std::string const& _descOrTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden( startsWith( _name, "./" ) ); // Legacy support
+
+        // Parse out tags
+        std::set<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
+            char c = _descOrTags[i];
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( prop == TestCaseInfo::IsHidden )
+                        isHidden = true;
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    tags.insert( tag );
+                    tag.clear();
+                    inTag = false;
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            tags.insert( "hide" );
+            tags.insert( "." );
+        }
+
+        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, info );
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::set<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        tags( _tags ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        std::ostringstream oss;
+        for( std::set<std::string>::const_iterator it = _tags.begin(), itEnd = _tags.end(); it != itEnd; ++it ) {
+            oss << "[" << *it << "]";
+            std::string lcaseTag = toLower( *it );
+            properties = static_cast<SpecialProperties>( properties | parseSpecialTag( lcaseTag ) );
+            lcaseTags.insert( lcaseTag );
+        }
+        tagsAsString = oss.str();
+    }
+
+    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
+    :   name( other.name ),
+        className( other.className ),
+        description( other.description ),
+        tags( other.tags ),
+        lcaseTags( other.lcaseTags ),
+        tagsAsString( other.tagsAsString ),
+        lineInfo( other.lineInfo ),
+        properties( other.properties )
+    {}
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
+
+    TestCase::TestCase( TestCase const& other )
+    :   TestCaseInfo( other ),
+        test( other.test )
+    {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::swap( TestCase& other ) {
+        test.swap( other.test );
+        name.swap( other.name );
+        className.swap( other.className );
+        description.swap( other.description );
+        tags.swap( other.tags );
+        lcaseTags.swap( other.lcaseTags );
+        tagsAsString.swap( other.tagsAsString );
+        std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
+        std::swap( lineInfo, other.lineInfo );
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+    TestCase& TestCase::operator = ( TestCase const& other ) {
+        TestCase temp( other );
+        swap( temp );
+        return *this;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_version.hpp
+#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
+
+namespace Catch {
+
+    // These numbers are maintained by a script
+    Version libraryVersion( 1, 1, 1, "master" );
+}
+
+// #included from: catch_message.hpp
+#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   std::string const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info )
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+    ScopedMessage::ScopedMessage( ScopedMessage const& other )
+    : m_info( other.m_info )
+    {}
+
+    ScopedMessage::~ScopedMessage() {
+        getResultCapture().popScopedMessage( m_info );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_legacy_reporter_adapter.hpp
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
+
+// #included from: catch_legacy_reporter_adapter.h
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
+
+namespace Catch
+{
+    // Deprecated
+    struct IReporter : IShared {
+        virtual ~IReporter();
+
+        virtual bool shouldRedirectStdout() const = 0;
+
+        virtual void StartTesting() = 0;
+        virtual void EndTesting( Totals const& totals ) = 0;
+        virtual void StartGroup( std::string const& groupName ) = 0;
+        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
+        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
+        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
+        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
+        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
+        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
+        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
+        virtual void Aborted() = 0;
+        virtual void Result( AssertionResult const& result ) = 0;
+    };
+
+    class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
+    {
+    public:
+        LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter );
+        virtual ~LegacyReporterAdapter();
+
+        virtual ReporterPreferences getPreferences() const;
+        virtual void noMatchingTestCases( std::string const& );
+        virtual void testRunStarting( TestRunInfo const& );
+        virtual void testGroupStarting( GroupInfo const& groupInfo );
+        virtual void testCaseStarting( TestCaseInfo const& testInfo );
+        virtual void sectionStarting( SectionInfo const& sectionInfo );
+        virtual void assertionStarting( AssertionInfo const& );
+        virtual bool assertionEnded( AssertionStats const& assertionStats );
+        virtual void sectionEnded( SectionStats const& sectionStats );
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
+        virtual void testRunEnded( TestRunStats const& testRunStats );
+        virtual void skipTest( TestCaseInfo const& );
+
+    private:
+        Ptr<IReporter> m_legacyReporter;
+    };
+}
+
+namespace Catch
+{
+    LegacyReporterAdapter::LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter )
+    :   m_legacyReporter( legacyReporter )
+    {}
+    LegacyReporterAdapter::~LegacyReporterAdapter() {}
+
+    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
+        ReporterPreferences prefs;
+        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
+        return prefs;
+    }
+
+    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
+    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
+        m_legacyReporter->StartTesting();
+    }
+    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
+        m_legacyReporter->StartGroup( groupInfo.name );
+    }
+    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        m_legacyReporter->StartTestCase( testInfo );
+    }
+    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
+        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
+    }
+    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
+        // Not on legacy interface
+    }
+
+    bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
+            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                    it != itEnd;
+                    ++it ) {
+                if( it->type == ResultWas::Info ) {
+                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
+                    rb << it->message;
+                    rb.setResultType( ResultWas::Info );
+                    AssertionResult result = rb.build();
+                    m_legacyReporter->Result( result );
+                }
+            }
+        }
+        m_legacyReporter->Result( assertionStats.assertionResult );
+        return true;
+    }
+    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
+        if( sectionStats.missingAssertions )
+            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
+        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
+    }
+    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        m_legacyReporter->EndTestCase
+            (   testCaseStats.testInfo,
+                testCaseStats.totals,
+                testCaseStats.stdOut,
+                testCaseStats.stdErr );
+    }
+    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        if( testGroupStats.aborting )
+            m_legacyReporter->Aborted();
+        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
+    }
+    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
+        m_legacyReporter->EndTesting( testRunStats.totals );
+    }
+    void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) {
+    }
+}
+
+// #included from: catch_timer.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+#endif
+
+#ifdef CATCH_PLATFORM_WINDOWS
+#include <windows.h>
+#else
+#include <sys/time.h>
+#endif
+
+namespace Catch {
+
+    namespace {
+#ifdef CATCH_PLATFORM_WINDOWS
+        uint64_t getCurrentTicks() {
+            static uint64_t hz=0, hzo=0;
+            if (!hz) {
+                QueryPerformanceFrequency( reinterpret_cast<LARGE_INTEGER*>( &hz ) );
+                QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &hzo ) );
+            }
+            uint64_t t;
+            QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &t ) );
+            return ((t-hzo)*1000000)/hz;
+        }
+#else
+        uint64_t getCurrentTicks() {
+            timeval t;
+            gettimeofday(&t,NULL);
+            return static_cast<uint64_t>( t.tv_sec ) * 1000000ull + static_cast<uint64_t>( t.tv_usec );
+        }
+#endif
+    }
+
+    void Timer::start() {
+        m_ticks = getCurrentTicks();
+    }
+    unsigned int Timer::getElapsedMicroseconds() const {
+        return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
+    }
+    unsigned int Timer::getElapsedMilliseconds() const {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    double Timer::getElapsedSeconds() const {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+// #included from: catch_common.hpp
+#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), ::tolower );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : "";
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << " " << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << "s";
+        return os;
+    }
+
+    SourceLineInfo::SourceLineInfo() : line( 0 ){}
+    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line )
+    :   file( _file ),
+        line( _line )
+    {}
+    SourceLineInfo::SourceLineInfo( SourceLineInfo const& other )
+    :   file( other.file ),
+        line( other.line )
+    {}
+    bool SourceLineInfo::empty() const {
+        return file.empty();
+    }
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
+        return line == other.line && file == other.file;
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const {
+        return line < other.line || ( line == other.line  && file < other.file );
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << "(" << info.line << ")";
+#else
+        os << info.file << ":" << info.line;
+#endif
+        return os;
+    }
+
+    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
+        std::ostringstream oss;
+        oss << locationInfo << ": Internal Catch error: '" << message << "'";
+        if( alwaysTrue() )
+            throw std::logic_error( oss.str() );
+    }
+}
+
+// #included from: catch_section.hpp
+#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name,
+            std::string const& _description )
+    :   name( _name ),
+        description( _description ),
+        lineInfo( _lineInfo )
+    {}
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+    Section::~Section() {
+        if( m_sectionIncluded )
+            getResultCapture().sectionEnded( m_info, m_assertions, m_timer.getElapsedSeconds() );
+    }
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_debugger.hpp
+#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
+
+#include <iostream>
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #include <assert.h>
+    #include <stdbool.h>
+    #include <sys/types.h>
+    #include <unistd.h>
+    #include <sys/sysctl.h>
+
+    namespace Catch{
+
+        // The following function is taken directly from the following technical note:
+        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+
+            int                 mib[4];
+            struct kinfo_proc   info;
+            size_t              size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0) != 0 ) {
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+    } // namespace Catch
+
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       inline bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+
+#ifdef CATCH_PLATFORM_WINDOWS
+    extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* );
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+#else
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
+        }
+    }
+#endif // Platform
+
+// #included from: catch_tostring.hpp
+#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
+
+namespace Catch {
+
+namespace Detail {
+
+    std::string unprintableString = "{?}";
+
+    namespace {
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                union _{
+                    int asInt;
+                    char asChar[sizeof (int)];
+                } u;
+
+                u.asInt = 1;
+                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
+            }
+        };
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size )
+    {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        std::ostringstream os;
+        os << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             os << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return os.str();
+    }
+}
+
+std::string toString( std::string const& value ) {
+    std::string s = value;
+    if( getCurrentContext().getConfig()->showInvisibles() ) {
+        for(size_t i = 0; i < s.size(); ++i ) {
+            std::string subs;
+            switch( s[i] ) {
+            case '\n': subs = "\\n"; break;
+            case '\t': subs = "\\t"; break;
+            default: break;
+            }
+            if( !subs.empty() ) {
+                s = s.substr( 0, i ) + subs + s.substr( i+1 );
+                ++i;
+            }
+        }
+    }
+    return "\"" + s + "\"";
+}
+std::string toString( std::wstring const& value ) {
+
+    std::string s;
+    s.reserve( value.size() );
+    for(size_t i = 0; i < value.size(); ++i )
+        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
+    return Catch::toString( s );
+}
+
+std::string toString( const char* const value ) {
+    return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" );
+}
+
+std::string toString( char* const value ) {
+    return Catch::toString( static_cast<const char*>( value ) );
+}
+
+std::string toString( const wchar_t* const value )
+{
+	return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" );
+}
+
+std::string toString( wchar_t* const value )
+{
+	return Catch::toString( static_cast<const wchar_t*>( value ) );
+}
+
+std::string toString( int value ) {
+    std::ostringstream oss;
+    if( value > 8192 )
+        oss << "0x" << std::hex << value;
+    else
+        oss << value;
+    return oss.str();
+}
+
+std::string toString( unsigned long value ) {
+    std::ostringstream oss;
+    if( value > 8192 )
+        oss << "0x" << std::hex << value;
+    else
+        oss << value;
+    return oss.str();
+}
+
+std::string toString( unsigned int value ) {
+    return Catch::toString( static_cast<unsigned long>( value ) );
+}
+
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    std::ostringstream oss;
+    oss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = oss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+std::string toString( const double value ) {
+    return fpToString( value, 10 );
+}
+std::string toString( const float value ) {
+    return fpToString( value, 5 ) + "f";
+}
+
+std::string toString( bool value ) {
+    return value ? "true" : "false";
+}
+
+std::string toString( char value ) {
+    return value < ' '
+        ? toString( static_cast<unsigned int>( value ) )
+        : Detail::makeString( value );
+}
+
+std::string toString( signed char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
+std::string toString( unsigned char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t ) {
+    return "nullptr";
+}
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring ) {
+        if( !nsstring )
+            return "nil";
+        return "@" + toString([nsstring UTF8String]);
+    }
+    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) {
+        if( !nsstring )
+            return "nil";
+        return "@" + toString([nsstring UTF8String]);
+    }
+    std::string toString( NSObject* const& nsObject ) {
+        return toString( [nsObject description] );
+    }
+#endif
+
+} // end namespace Catch
+
+// #included from: catch_result_builder.hpp
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
+
+namespace Catch {
+
+    ResultBuilder::ResultBuilder(   char const* macroName,
+                                    SourceLineInfo const& lineInfo,
+                                    char const* capturedExpression,
+                                    ResultDisposition::Flags resultDisposition )
+    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition ),
+        m_shouldDebugBreak( false ),
+        m_shouldThrow( false )
+    {}
+
+    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
+        m_data.resultType = result;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setResultType( bool result ) {
+        m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setLhs( std::string const& lhs ) {
+        m_exprComponents.lhs = lhs;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setRhs( std::string const& rhs ) {
+        m_exprComponents.rhs = rhs;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setOp( std::string const& op ) {
+        m_exprComponents.op = op;
+        return *this;
+    }
+
+    void ResultBuilder::endExpression() {
+        m_exprComponents.testFalse = isFalseTest( m_assertionInfo.resultDisposition );
+        captureExpression();
+    }
+
+    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
+        m_assertionInfo.resultDisposition = resultDisposition;
+        m_stream.oss << Catch::translateActiveException();
+        captureResult( ResultWas::ThrewException );
+    }
+
+    void ResultBuilder::captureResult( ResultWas::OfType resultType ) {
+        setResultType( resultType );
+        captureExpression();
+    }
+
+    void ResultBuilder::captureExpression() {
+        AssertionResult result = build();
+        getResultCapture().assertionEnded( result );
+
+        if( !result.isOk() ) {
+            if( getCurrentContext().getConfig()->shouldDebugBreak() )
+                m_shouldDebugBreak = true;
+            if( getCurrentContext().getRunner()->aborting() || m_assertionInfo.resultDisposition == ResultDisposition::Normal )
+                m_shouldThrow = true;
+        }
+    }
+    void ResultBuilder::react() {
+        if( m_shouldThrow )
+            throw Catch::TestFailureException();
+    }
+
+    bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
+    bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }
+
+    AssertionResult ResultBuilder::build() const
+    {
+        assert( m_data.resultType != ResultWas::Unknown );
+
+        AssertionResultData data = m_data;
+
+        // Flip bool results if testFalse is set
+        if( m_exprComponents.testFalse ) {
+            if( data.resultType == ResultWas::Ok )
+                data.resultType = ResultWas::ExpressionFailed;
+            else if( data.resultType == ResultWas::ExpressionFailed )
+                data.resultType = ResultWas::Ok;
+        }
+
+        data.message = m_stream.oss.str();
+        data.reconstructedExpression = reconstructExpression();
+        if( m_exprComponents.testFalse ) {
+            if( m_exprComponents.op == "" )
+                data.reconstructedExpression = "!" + data.reconstructedExpression;
+            else
+                data.reconstructedExpression = "!(" + data.reconstructedExpression + ")";
+        }
+        return AssertionResult( m_assertionInfo, data );
+    }
+    std::string ResultBuilder::reconstructExpression() const {
+        if( m_exprComponents.op == "" )
+            return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs;
+        else if( m_exprComponents.op == "matches" )
+            return m_exprComponents.lhs + " " + m_exprComponents.rhs;
+        else if( m_exprComponents.op != "!" ) {
+            if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 &&
+                m_exprComponents.lhs.find("\n") == std::string::npos &&
+                m_exprComponents.rhs.find("\n") == std::string::npos )
+                return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs;
+            else
+                return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs;
+        }
+        else
+            return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}";
+    }
+
+} // end namespace Catch
+
+// #included from: catch_tag_alias_registry.hpp
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+// #included from: catch_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        virtual ~TagAliasRegistry();
+        virtual Option<TagAlias> find( std::string const& alias ) const;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
+        void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+        static TagAliasRegistry& get();
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+#include <map>
+#include <iostream>
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    Option<TagAlias> TagAliasRegistry::find( std::string const& alias ) const {
+        std::map<std::string, TagAlias>::const_iterator it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return it->second;
+        else
+            return Option<TagAlias>();
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
+                it != itEnd;
+                ++it ) {
+            std::size_t pos = expandedTestSpec.find( it->first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    it->second.tag +
+                                    expandedTestSpec.substr( pos + it->first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
+
+        if( !startsWith( alias, "[@" ) || !endsWith( alias, "]" ) ) {
+            std::ostringstream oss;
+            oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo;
+            throw std::domain_error( oss.str().c_str() );
+        }
+        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
+            std::ostringstream oss;
+            oss << "error: tag alias, \"" << alias << "\" already registered.\n"
+                << "\tFirst seen at " << find(alias)->lineInfo << "\n"
+                << "\tRedefined at " << lineInfo;
+            throw std::domain_error( oss.str().c_str() );
+        }
+    }
+
+    TagAliasRegistry& TagAliasRegistry::get() {
+        static TagAliasRegistry instance;
+        return instance;
+
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+    ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); }
+
+    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
+        try {
+            TagAliasRegistry::get().add( alias, tag, lineInfo );
+        }
+        catch( std::exception& ex ) {
+            Colour colourGuard( Colour::Red );
+            Catch::cerr() << ex.what() << std::endl;
+            exit(1);
+        }
+    }
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_xml.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
+
+// #included from: catch_reporter_bases.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
+
+#include <cstring>
+
+namespace Catch {
+
+    struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {}
+
+        virtual ~StreamingReporterBase();
+
+        virtual void noMatchingTestCases( std::string const& ) {}
+
+        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) {
+            currentTestRunInfo = _testRunInfo;
+        }
+        virtual void testGroupStarting( GroupInfo const& _groupInfo ) {
+            currentGroupInfo = _groupInfo;
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) {
+            currentTestCaseInfo = _testInfo;
+        }
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
+            m_sectionStack.push_back( _sectionInfo );
+        }
+
+        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) {
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) {
+            currentTestCaseInfo.reset();
+        }
+        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) {
+            currentGroupInfo.reset();
+        }
+        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        virtual void skipTest( TestCaseInfo const& ) {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        Ptr<IConfig> m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+    };
+
+    struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
+        template<typename T, typename ChildNodeT>
+        struct Node : SharedImpl<> {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            typedef std::vector<Ptr<ChildNodeT> > ChildNodes;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode : SharedImpl<> {
+            explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {}
+            virtual ~SectionNode();
+
+            bool operator == ( SectionNode const& other ) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == ( Ptr<SectionNode> const& other ) const {
+                return operator==( *other );
+            }
+
+            SectionStats stats;
+            typedef std::vector<Ptr<SectionNode> > ChildSections;
+            typedef std::vector<AssertionStats> Assertions;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+			BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() ( Ptr<SectionNode> const& node ) const {
+                return node->stats.sectionInfo.lineInfo == m_other.lineInfo;
+            }
+        private:
+			void operator=( BySectionInfo const& );
+            SectionInfo const& m_other;
+        };
+
+        typedef Node<TestCaseStats, SectionNode> TestCaseNode;
+        typedef Node<TestGroupStats, TestCaseNode> TestGroupNode;
+        typedef Node<TestRunStats, TestGroupNode> TestRunNode;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {}
+        ~CumulativeReporterBase();
+
+        virtual void testRunStarting( TestRunInfo const& ) {}
+        virtual void testGroupStarting( GroupInfo const& ) {}
+
+        virtual void testCaseStarting( TestCaseInfo const& ) {}
+
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            Ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = new SectionNode( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                SectionNode::ChildSections::const_iterator it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = new SectionNode( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = node;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {}
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
+            assert( !m_sectionStack.empty() );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back( assertionStats );
+            return true;
+        }
+        virtual void sectionEnded( SectionStats const& sectionStats ) {
+            assert( !m_sectionStack.empty() );
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
+            Ptr<TestCaseNode> node = new TestCaseNode( testCaseStats );
+            assert( m_sectionStack.size() == 0 );
+            node->children.push_back( m_rootSection );
+            m_testCases.push_back( node );
+            m_rootSection.reset();
+
+            assert( m_deepestSection );
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
+            Ptr<TestGroupNode> node = new TestGroupNode( testGroupStats );
+            node->children.swap( m_testCases );
+            m_testGroups.push_back( node );
+        }
+        virtual void testRunEnded( TestRunStats const& testRunStats ) {
+            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
+            node->children.swap( m_testGroups );
+            m_testRuns.push_back( node );
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        virtual void skipTest( TestCaseInfo const& ) {}
+
+        Ptr<IConfig> m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<Ptr<SectionNode> > > m_sections;
+        std::vector<Ptr<TestCaseNode> > m_testCases;
+        std::vector<Ptr<TestGroupNode> > m_testGroups;
+
+        std::vector<Ptr<TestRunNode> > m_testRuns;
+
+        Ptr<SectionNode> m_rootSection;
+        Ptr<SectionNode> m_deepestSection;
+        std::vector<Ptr<SectionNode> > m_sectionStack;
+
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+} // end namespace Catch
+
+// #included from: ../internal/catch_reporter_registrars.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+namespace Catch {
+
+    template<typename T>
+    class LegacyReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new LegacyReporterAdapter( new T( config ) );
+            }
+
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        LegacyReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+
+    template<typename T>
+    class ReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+
+            // *** Please Note ***:
+            // - If you end up here looking at a compiler error because it's trying to register
+            // your custom reporter class be aware that the native reporter interface has changed
+            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
+            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
+            // However please consider updating to the new interface as the old one is now
+            // deprecated and will probably be removed quite soon!
+            // Please contact me via github if you have any questions at all about this.
+            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
+            // no idea who is actually using custom reporters at all (possibly no-one!).
+            // The new interface is designed to minimise exposure to interface changes in the future.
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new T( config );
+            }
+
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+}
+
+#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
+    namespace{ Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+
+// #included from: ../internal/catch_xmlwriter.hpp
+#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer )
+            :   m_writer( writer )
+            {}
+
+            ScopedElement( ScopedElement const& other )
+            :   m_writer( other.m_writer ){
+                other.m_writer = NULL;
+            }
+
+            ~ScopedElement() {
+                if( m_writer )
+                    m_writer->endElement();
+            }
+
+            ScopedElement& writeText( std::string const& text, bool indent = true ) {
+                m_writer->writeText( text, indent );
+                return *this;
+            }
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer;
+        };
+
+        XmlWriter()
+        :   m_tagIsOpen( false ),
+            m_needsNewline( false ),
+            m_os( &Catch::cout() )
+        {}
+
+        XmlWriter( std::ostream& os )
+        :   m_tagIsOpen( false ),
+            m_needsNewline( false ),
+            m_os( &os )
+        {}
+
+        ~XmlWriter() {
+            while( !m_tags.empty() )
+                endElement();
+        }
+
+//#  ifndef CATCH_CPP11_OR_GREATER
+//        XmlWriter& operator = ( XmlWriter const& other ) {
+//            XmlWriter temp( other );
+//            swap( temp );
+//            return *this;
+//        }
+//#  else
+//        XmlWriter( XmlWriter const& )              = default;
+//        XmlWriter( XmlWriter && )                  = default;
+//        XmlWriter& operator = ( XmlWriter const& ) = default;
+//        XmlWriter& operator = ( XmlWriter && )     = default;
+//#  endif
+//
+//        void swap( XmlWriter& other ) {
+//            std::swap( m_tagIsOpen, other.m_tagIsOpen );
+//            std::swap( m_needsNewline, other.m_needsNewline );
+//            std::swap( m_tags, other.m_tags );
+//            std::swap( m_indent, other.m_indent );
+//            std::swap( m_os, other.m_os );
+//        }
+
+        XmlWriter& startElement( std::string const& name ) {
+            ensureTagClosed();
+            newlineIfNecessary();
+            stream() << m_indent << "<" << name;
+            m_tags.push_back( name );
+            m_indent += "  ";
+            m_tagIsOpen = true;
+            return *this;
+        }
+
+        ScopedElement scopedElement( std::string const& name ) {
+            ScopedElement scoped( this );
+            startElement( name );
+            return scoped;
+        }
+
+        XmlWriter& endElement() {
+            newlineIfNecessary();
+            m_indent = m_indent.substr( 0, m_indent.size()-2 );
+            if( m_tagIsOpen ) {
+                stream() << "/>\n";
+                m_tagIsOpen = false;
+            }
+            else {
+                stream() << m_indent << "</" << m_tags.back() << ">\n";
+            }
+            m_tags.pop_back();
+            return *this;
+        }
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
+            if( !name.empty() && !attribute.empty() ) {
+                stream() << " " << name << "=\"";
+                writeEncodedText( attribute );
+                stream() << "\"";
+            }
+            return *this;
+        }
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
+            stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
+            return *this;
+        }
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            if( !name.empty() )
+                stream() << " " << name << "=\"" << attribute << "\"";
+            return *this;
+        }
+
+        XmlWriter& writeText( std::string const& text, bool indent = true ) {
+            if( !text.empty() ){
+                bool tagWasOpen = m_tagIsOpen;
+                ensureTagClosed();
+                if( tagWasOpen && indent )
+                    stream() << m_indent;
+                writeEncodedText( text );
+                m_needsNewline = true;
+            }
+            return *this;
+        }
+
+        XmlWriter& writeComment( std::string const& text ) {
+            ensureTagClosed();
+            stream() << m_indent << "<!--" << text << "-->";
+            m_needsNewline = true;
+            return *this;
+        }
+
+        XmlWriter& writeBlankLine() {
+            ensureTagClosed();
+            stream() << "\n";
+            return *this;
+        }
+
+        void setStream( std::ostream& os ) {
+            m_os = &os;
+        }
+
+    private:
+        XmlWriter( XmlWriter const& );
+        void operator=( XmlWriter const& );
+
+        std::ostream& stream() {
+            return *m_os;
+        }
+
+        void ensureTagClosed() {
+            if( m_tagIsOpen ) {
+                stream() << ">\n";
+                m_tagIsOpen = false;
+            }
+        }
+
+        void newlineIfNecessary() {
+            if( m_needsNewline ) {
+                stream() << "\n";
+                m_needsNewline = false;
+            }
+        }
+
+        void writeEncodedText( std::string const& text ) {
+            static const char* charsToEncode = "<&\"";
+            std::string mtext = text;
+            std::string::size_type pos = mtext.find_first_of( charsToEncode );
+            while( pos != std::string::npos ) {
+                stream() << mtext.substr( 0, pos );
+
+                switch( mtext[pos] ) {
+                    case '<':
+                        stream() << "&lt;";
+                        break;
+                    case '&':
+                        stream() << "&amp;";
+                        break;
+                    case '\"':
+                        stream() << "&quot;";
+                        break;
+                }
+                mtext = mtext.substr( pos+1 );
+                pos = mtext.find_first_of( charsToEncode );
+            }
+            stream() << mtext;
+        }
+
+        bool m_tagIsOpen;
+        bool m_needsNewline;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream* m_os;
+    };
+
+}
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase {
+    public:
+        XmlReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_sectionDepth( 0 )
+        {}
+
+        virtual ~XmlReporter();
+
+        static std::string getDescription() {
+            return "Reports test results as an XML document";
+        }
+
+    public: // StreamingReporterBase
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = true;
+            return prefs;
+        }
+
+        virtual void noMatchingTestCases( std::string const& s ) {
+            StreamingReporterBase::noMatchingTestCases( s );
+        }
+
+        virtual void testRunStarting( TestRunInfo const& testInfo ) {
+            StreamingReporterBase::testRunStarting( testInfo );
+            m_xml.setStream( stream );
+            m_xml.startElement( "Catch" );
+            if( !m_config->name().empty() )
+                m_xml.writeAttribute( "name", m_config->name() );
+        }
+
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) {
+            StreamingReporterBase::testGroupStarting( groupInfo );
+            m_xml.startElement( "Group" )
+                .writeAttribute( "name", groupInfo.name );
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) {
+            StreamingReporterBase::testCaseStarting(testInfo);
+            m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                m_testCaseTimer.start();
+        }
+
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) {
+            StreamingReporterBase::sectionStarting( sectionInfo );
+            if( m_sectionDepth++ > 0 ) {
+                m_xml.startElement( "Section" )
+                    .writeAttribute( "name", trim( sectionInfo.name ) )
+                    .writeAttribute( "description", sectionInfo.description );
+            }
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) { }
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
+            const AssertionResult& assertionResult = assertionStats.assertionResult;
+
+            // Print any info messages in <Info> tags.
+            if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
+                for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                        it != itEnd;
+                        ++it ) {
+                    if( it->type == ResultWas::Info ) {
+                        m_xml.scopedElement( "Info" )
+                            .writeText( it->message );
+                    } else if ( it->type == ResultWas::Warning ) {
+                        m_xml.scopedElement( "Warning" )
+                            .writeText( it->message );
+                    }
+                }
+            }
+
+            // Drop out if result was successful but we're not printing them.
+            if( !m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()) )
+                return true;
+
+            // Print the expression if there is one.
+            if( assertionResult.hasExpression() ) {
+                m_xml.startElement( "Expression" )
+                    .writeAttribute( "success", assertionResult.succeeded() )
+					.writeAttribute( "type", assertionResult.getTestMacroName() )
+                    .writeAttribute( "filename", assertionResult.getSourceInfo().file )
+                    .writeAttribute( "line", assertionResult.getSourceInfo().line );
+
+                m_xml.scopedElement( "Original" )
+                    .writeText( assertionResult.getExpression() );
+                m_xml.scopedElement( "Expanded" )
+                    .writeText( assertionResult.getExpandedExpression() );
+            }
+
+            // And... Print a result applicable to each result type.
+            switch( assertionResult.getResultType() ) {
+                case ResultWas::ThrewException:
+                    m_xml.scopedElement( "Exception" )
+                        .writeAttribute( "filename", assertionResult.getSourceInfo().file )
+                        .writeAttribute( "line", assertionResult.getSourceInfo().line )
+                        .writeText( assertionResult.getMessage() );
+                    break;
+                case ResultWas::FatalErrorCondition:
+                    m_xml.scopedElement( "Fatal Error Condition" )
+                        .writeAttribute( "filename", assertionResult.getSourceInfo().file )
+                        .writeAttribute( "line", assertionResult.getSourceInfo().line )
+                        .writeText( assertionResult.getMessage() );
+                    break;
+                case ResultWas::Info:
+                    m_xml.scopedElement( "Info" )
+                        .writeText( assertionResult.getMessage() );
+                    break;
+                case ResultWas::Warning:
+                    // Warning will already have been written
+                    break;
+                case ResultWas::ExplicitFailure:
+                    m_xml.scopedElement( "Failure" )
+                        .writeText( assertionResult.getMessage() );
+                    break;
+                default:
+                    break;
+            }
+
+            if( assertionResult.hasExpression() )
+                m_xml.endElement();
+
+            return true;
+        }
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) {
+            StreamingReporterBase::sectionEnded( sectionStats );
+            if( --m_sectionDepth > 0 ) {
+                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+                e.writeAttribute( "successes", sectionStats.assertions.passed );
+                e.writeAttribute( "failures", sectionStats.assertions.failed );
+                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+                if ( m_config->showDurations() == ShowDurations::Always )
+                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+                m_xml.endElement();
+            }
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+            m_xml.endElement();
+        }
+
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            // TODO: Check testGroupStats.aborting and act accordingly.
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+            m_xml.endElement();
+        }
+
+        virtual void testRunEnded( TestRunStats const& testRunStats ) {
+            StreamingReporterBase::testRunEnded( testRunStats );
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+            m_xml.endElement();
+        }
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth;
+    };
+
+     INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_junit.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+#include <assert.h>
+
+namespace Catch {
+
+    class JunitReporter : public CumulativeReporterBase {
+    public:
+        JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() )
+        {}
+
+        ~JunitReporter();
+
+        static std::string getDescription() {
+            return "Reports test results in an XML format that looks like Ant's junitreport target";
+        }
+
+        virtual void noMatchingTestCases( std::string const& /*spec*/ ) {}
+
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = true;
+            return prefs;
+        }
+
+        virtual void testRunStarting( TestRunInfo const& runInfo ) {
+            CumulativeReporterBase::testRunStarting( runInfo );
+            xml.startElement( "testsuites" );
+        }
+
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) {
+            suiteTimer.start();
+            stdOutForSuite.str("");
+            stdErrForSuite.str("");
+            unexpectedExceptions = 0;
+            CumulativeReporterBase::testGroupStarting( groupInfo );
+        }
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
+            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException )
+                unexpectedExceptions++;
+            return CumulativeReporterBase::assertionEnded( assertionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
+            stdOutForSuite << testCaseStats.stdOut;
+            stdErrForSuite << testCaseStats.stdErr;
+            CumulativeReporterBase::testCaseEnded( testCaseStats );
+        }
+
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
+            double suiteTime = suiteTimer.getElapsedSeconds();
+            CumulativeReporterBase::testGroupEnded( testGroupStats );
+            writeGroup( *m_testGroups.back(), suiteTime );
+        }
+
+        virtual void testRunEndedCumulative() {
+            xml.endElement();
+        }
+
+        void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+            TestGroupStats const& stats = groupNode.value;
+            xml.writeAttribute( "name", stats.groupInfo.name );
+            xml.writeAttribute( "errors", unexpectedExceptions );
+            xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+            xml.writeAttribute( "tests", stats.totals.assertions.total() );
+            xml.writeAttribute( "hostname", "tbd" ); // !TBD
+            if( m_config->showDurations() == ShowDurations::Never )
+                xml.writeAttribute( "time", "" );
+            else
+                xml.writeAttribute( "time", suiteTime );
+            xml.writeAttribute( "timestamp", "tbd" ); // !TBD
+
+            // Write test cases
+            for( TestGroupNode::ChildNodes::const_iterator
+                    it = groupNode.children.begin(), itEnd = groupNode.children.end();
+                    it != itEnd;
+                    ++it )
+                writeTestCase( **it );
+
+            xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
+            xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
+        }
+
+        void writeTestCase( TestCaseNode const& testCaseNode ) {
+            TestCaseStats const& stats = testCaseNode.value;
+
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert( testCaseNode.children.size() == 1 );
+            SectionNode const& rootSection = *testCaseNode.children.front();
+
+            std::string className = stats.testInfo.className;
+
+            if( className.empty() ) {
+                if( rootSection.childSections.empty() )
+                    className = "global";
+            }
+            writeSection( className, "", rootSection );
+        }
+
+        void writeSection(  std::string const& className,
+                            std::string const& rootName,
+                            SectionNode const& sectionNode ) {
+            std::string name = trim( sectionNode.stats.sectionInfo.name );
+            if( !rootName.empty() )
+                name = rootName + "/" + name;
+
+            if( !sectionNode.assertions.empty() ||
+                !sectionNode.stdOut.empty() ||
+                !sectionNode.stdErr.empty() ) {
+                XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+                if( className.empty() ) {
+                    xml.writeAttribute( "classname", name );
+                    xml.writeAttribute( "name", "root" );
+                }
+                else {
+                    xml.writeAttribute( "classname", className );
+                    xml.writeAttribute( "name", name );
+                }
+                xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) );
+
+                writeAssertions( sectionNode );
+
+                if( !sectionNode.stdOut.empty() )
+                    xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
+                if( !sectionNode.stdErr.empty() )
+                    xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
+            }
+            for( SectionNode::ChildSections::const_iterator
+                    it = sectionNode.childSections.begin(),
+                    itEnd = sectionNode.childSections.end();
+                    it != itEnd;
+                    ++it )
+                if( className.empty() )
+                    writeSection( name, "", **it );
+                else
+                    writeSection( className, name, **it );
+        }
+
+        void writeAssertions( SectionNode const& sectionNode ) {
+            for( SectionNode::Assertions::const_iterator
+                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
+                    it != itEnd;
+                    ++it )
+                writeAssertion( *it );
+        }
+        void writeAssertion( AssertionStats const& stats ) {
+            AssertionResult const& result = stats.assertionResult;
+            if( !result.isOk() ) {
+                std::string elementName;
+                switch( result.getResultType() ) {
+                    case ResultWas::ThrewException:
+                    case ResultWas::FatalErrorCondition:
+                        elementName = "error";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        elementName = "failure";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        elementName = "failure";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        elementName = "failure";
+                        break;
+
+                    // We should never see these here:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                    case ResultWas::Ok:
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        elementName = "internalError";
+                        break;
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+                xml.writeAttribute( "message", result.getExpandedExpression() );
+                xml.writeAttribute( "type", result.getTestMacroName() );
+
+                std::ostringstream oss;
+                if( !result.getMessage().empty() )
+                    oss << result.getMessage() << "\n";
+                for( std::vector<MessageInfo>::const_iterator
+                        it = stats.infoMessages.begin(),
+                        itEnd = stats.infoMessages.end();
+                            it != itEnd;
+                            ++it )
+                    if( it->type == ResultWas::Info )
+                        oss << it->message << "\n";
+
+                oss << "at " << result.getSourceInfo();
+                xml.writeText( oss.str(), false );
+            }
+        }
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::ostringstream stdOutForSuite;
+        std::ostringstream stdErrForSuite;
+        unsigned int unexpectedExceptions;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_console.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+namespace Catch {
+
+    struct ConsoleReporter : StreamingReporterBase {
+        ConsoleReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_headerPrinted( false )
+        {}
+
+        virtual ~ConsoleReporter();
+        static std::string getDescription() {
+            return "Reports test results as plain lines of text";
+        }
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = false;
+            return prefs;
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {
+        }
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            lazyPrint();
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
+            m_headerPrinted = false;
+            StreamingReporterBase::sectionStarting( _sectionInfo );
+        }
+        virtual void sectionEnded( SectionStats const& _sectionStats ) {
+            if( _sectionStats.missingAssertions ) {
+                lazyPrint();
+                Colour colour( Colour::ResultError );
+                if( m_sectionStack.size() > 1 )
+                    stream << "\nNo assertions in section";
+                else
+                    stream << "\nNo assertions in test case";
+                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+            }
+            if( m_headerPrinted ) {
+                if( m_config->showDurations() == ShowDurations::Always )
+                    stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
+                m_headerPrinted = false;
+            }
+            else {
+                if( m_config->showDurations() == ShowDurations::Always )
+                    stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
+            }
+            StreamingReporterBase::sectionEnded( _sectionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) {
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+            m_headerPrinted = false;
+        }
+        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) {
+            if( currentGroupInfo.used ) {
+                printSummaryDivider();
+                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+                printTotals( _testGroupStats.totals );
+                stream << "\n" << std::endl;
+            }
+            StreamingReporterBase::testGroupEnded( _testGroupStats );
+        }
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotalsDivider( _testRunStats.totals );
+            printTotals( _testRunStats.totals );
+            stream << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
+            :   stream( _stream ),
+                stats( _stats ),
+                result( _stats.assertionResult ),
+                colour( Colour::None ),
+                message( result.getMessage() ),
+                messages( _stats.infoMessages ),
+                printInfoMessages( _printInfoMessages )
+            {
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        colour = Colour::Success;
+                        passOrFail = "PASSED";
+                        //if( result.hasMessage() )
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() ) {
+                            colour = Colour::Success;
+                            passOrFail = "FAILED - but was ok";
+                        }
+                        else {
+                            colour = Colour::Error;
+                            passOrFail = "FAILED";
+                        }
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ThrewException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to unexpected exception with message";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to a fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "because no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::Info:
+                        messageLabel = "info";
+                        break;
+                    case ResultWas::Warning:
+                        messageLabel = "warning";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        passOrFail = "FAILED";
+                        colour = Colour::Error;
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "explicitly with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "explicitly with messages";
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        passOrFail = "** internal error **";
+                        colour = Colour::Error;
+                        break;
+                }
+            }
+
+            void print() const {
+                printSourceInfo();
+                if( stats.totals.assertions.total() > 0 ) {
+                    if( result.isOk() )
+                        stream << "\n";
+                    printResultType();
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                }
+                else {
+                    stream << "\n";
+                }
+                printMessage();
+            }
+
+        private:
+            void printResultType() const {
+                if( !passOrFail.empty() ) {
+                    Colour colourGuard( colour );
+                    stream << passOrFail << ":\n";
+                }
+            }
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    Colour colourGuard( Colour::OriginalExpression );
+                    stream  << "  ";
+                    stream << result.getExpressionInMacro();
+                    stream << "\n";
+                }
+            }
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    stream << "with expansion:\n";
+                    Colour colourGuard( Colour::ReconstructedExpression );
+                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
+                }
+            }
+            void printMessage() const {
+                if( !messageLabel.empty() )
+                    stream << messageLabel << ":" << "\n";
+                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
+                        it != itEnd;
+                        ++it ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || it->type != ResultWas::Info )
+                        stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
+                }
+            }
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ": ";
+            }
+
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            Colour::Code colour;
+            std::string passOrFail;
+            std::string messageLabel;
+            std::string message;
+            std::vector<MessageInfo> messages;
+            bool printInfoMessages;
+        };
+
+        void lazyPrint() {
+
+            if( !currentTestRunInfo.used )
+                lazyPrintRunInfo();
+            if( !currentGroupInfo.used )
+                lazyPrintGroupInfo();
+
+            if( !m_headerPrinted ) {
+                printTestCaseAndSectionHeader();
+                m_headerPrinted = true;
+            }
+        }
+        void lazyPrintRunInfo() {
+            stream  << "\n" << getLineOfChars<'~'>() << "\n";
+            Colour colour( Colour::SecondaryText );
+            stream  << currentTestRunInfo->name
+                    << " is a Catch v"  << libraryVersion.majorVersion << "."
+                    << libraryVersion.minorVersion << " b"
+                    << libraryVersion.buildNumber;
+            if( libraryVersion.branchName != std::string( "master" ) )
+                stream << " (" << libraryVersion.branchName << ")";
+            stream  << " host application.\n"
+                    << "Run with -? for options\n\n";
+
+            if( m_config->rngSeed() != 0 )
+                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+            currentTestRunInfo.used = true;
+        }
+        void lazyPrintGroupInfo() {
+            if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
+                printClosedHeader( "Group: " + currentGroupInfo->name );
+                currentGroupInfo.used = true;
+            }
+        }
+        void printTestCaseAndSectionHeader() {
+            assert( !m_sectionStack.empty() );
+            printOpenHeader( currentTestCaseInfo->name );
+
+            if( m_sectionStack.size() > 1 ) {
+                Colour colourGuard( Colour::Headers );
+
+                std::vector<SectionInfo>::const_iterator
+                    it = m_sectionStack.begin()+1, // Skip first section (test case)
+                    itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( it->name, 2 );
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            if( !lineInfo.empty() ){
+                stream << getLineOfChars<'-'>() << "\n";
+                Colour colourGuard( Colour::FileName );
+                stream << lineInfo << "\n";
+            }
+            stream << getLineOfChars<'.'>() << "\n" << std::endl;
+        }
+
+        void printClosedHeader( std::string const& _name ) {
+            printOpenHeader( _name );
+            stream << getLineOfChars<'.'>() << "\n";
+        }
+        void printOpenHeader( std::string const& _name ) {
+            stream  << getLineOfChars<'-'>() << "\n";
+            {
+                Colour colourGuard( Colour::Headers );
+                printHeaderString( _name );
+            }
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            stream << Text( _string, TextAttributes()
+                                        .setIndent( indent+i)
+                                        .setInitialIndent( indent ) ) << "\n";
+        }
+
+        struct SummaryColumn {
+
+            SummaryColumn( std::string const& _label, Colour::Code _colour )
+            :   label( _label ),
+                colour( _colour )
+            {}
+            SummaryColumn addRow( std::size_t count ) {
+                std::ostringstream oss;
+                oss << count;
+                std::string row = oss.str();
+                for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
+                    while( it->size() < row.size() )
+                        *it = " " + *it;
+                    while( it->size() > row.size() )
+                        row = " " + row;
+                }
+                rows.push_back( row );
+                return *this;
+            }
+
+            std::string label;
+            Colour::Code colour;
+            std::vector<std::string> rows;
+
+        };
+
+        void printTotals( Totals const& totals ) {
+            if( totals.testCases.total() == 0 ) {
+                stream << Colour( Colour::Warning ) << "No tests ran\n";
+            }
+            else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) {
+                stream << Colour( Colour::ResultSuccess ) << "All tests passed";
+                stream << " ("
+                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
+                        << pluralise( totals.testCases.passed, "test case" ) << ")"
+                        << "\n";
+            }
+            else {
+
+                std::vector<SummaryColumn> columns;
+                columns.push_back( SummaryColumn( "", Colour::None )
+                                        .addRow( totals.testCases.total() )
+                                        .addRow( totals.assertions.total() ) );
+                columns.push_back( SummaryColumn( "passed", Colour::Success )
+                                        .addRow( totals.testCases.passed )
+                                        .addRow( totals.assertions.passed ) );
+                columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+                                        .addRow( totals.testCases.failed )
+                                        .addRow( totals.assertions.failed ) );
+                columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+                                        .addRow( totals.testCases.failedButOk )
+                                        .addRow( totals.assertions.failedButOk ) );
+
+                printSummaryRow( "test cases", columns, 0 );
+                printSummaryRow( "assertions", columns, 1 );
+            }
+        }
+        void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
+            for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
+                std::string value = it->rows[row];
+                if( it->label.empty() ) {
+                    stream << label << ": ";
+                    if( value != "0" )
+                        stream << value;
+                    else
+                        stream << Colour( Colour::Warning ) << "- none -";
+                }
+                else if( value != "0" ) {
+                    stream  << Colour( Colour::LightGrey ) << " | ";
+                    stream  << Colour( it->colour )
+                            << value << " " << it->label;
+                }
+            }
+            stream << "\n";
+        }
+
+        static std::size_t makeRatio( std::size_t number, std::size_t total ) {
+            std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
+            return ( ratio == 0 && number > 0 ) ? 1 : ratio;
+        }
+        static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
+            if( i > j && i > k )
+                return i;
+            else if( j > k )
+                return j;
+            else
+                return k;
+        }
+
+        void printTotalsDivider( Totals const& totals ) {
+            if( totals.testCases.total() > 0 ) {
+                std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
+                std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
+                std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
+                while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
+                    findMax( failedRatio, failedButOkRatio, passedRatio )++;
+                while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
+                    findMax( failedRatio, failedButOkRatio, passedRatio )--;
+
+                stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
+                stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
+                if( totals.testCases.allPassed() )
+                    stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
+                else
+                    stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
+            }
+            else {
+                stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
+            }
+            stream << "\n";
+        }
+        void printSummaryDivider() {
+            stream << getLineOfChars<'-'>() << "\n";
+        }
+
+    private:
+        bool m_headerPrinted;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_compact.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase {
+
+        CompactReporter( ReporterConfig const& _config )
+        : StreamingReporterBase( _config )
+        {}
+
+        virtual ~CompactReporter();
+
+        static std::string getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = false;
+            return prefs;
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {
+        }
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
+            : stream( _stream )
+            , stats( _stats )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( _printInfoMessages )
+            {}
+
+            void print() {
+                printSourceInfo();
+
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( Colour::ResultSuccess, passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() )
+                            printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
+                        else
+                            printResultType( Colour::Error, failedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( Colour::None, "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( Colour::None, "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( Colour::Error, "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            // Colour::LightGrey
+
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+#ifdef CATCH_PLATFORM_MAC
+            static const char* failedString() { return "FAILED"; }
+            static const char* passedString() { return "PASSED"; }
+#else
+            static const char* failedString() { return "failed"; }
+            static const char* passedString() { return "passed"; }
+#endif
+
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ":";
+            }
+
+            void printResultType( Colour::Code colour, std::string passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    {
+                        Colour colourGuard( colour );
+                        stream << " " << passOrFail;
+                    }
+                    stream << ":";
+                }
+            }
+
+            void printIssue( std::string issue ) const {
+                stream << " " << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ";";
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << " " << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    stream << result.getExpandedExpression();
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << "'";
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if ( itMessage == messages.end() )
+                    return;
+
+                // using messages.end() directly yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ":";
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << "'";
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+        };
+
+        // Colour, message variants:
+        // - white: No tests ran.
+        // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+        // - white: Passed [both/all] N test cases (no assertions).
+        // -   red: Failed N tests cases, failed M assertions.
+        // - green: Passed [both/all] N tests cases with M assertions.
+
+        std::string bothOrAll( std::size_t count ) const {
+            return count == 1 ? "" : count == 2 ? "both " : "all " ;
+        }
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "No tests ran.";
+            }
+            else if( totals.testCases.failed == totals.testCases.total() ) {
+                Colour colour( Colour::ResultError );
+                const std::string qualify_assertions_failed =
+                    totals.assertions.failed == totals.assertions.total() ?
+                        bothOrAll( totals.assertions.failed ) : "";
+                stream <<
+                    "Failed " << bothOrAll( totals.testCases.failed )
+                              << pluralise( totals.testCases.failed, "test case"  ) << ", "
+                    "failed " << qualify_assertions_failed <<
+                                 pluralise( totals.assertions.failed, "assertion" ) << ".";
+            }
+            else if( totals.assertions.total() == 0 ) {
+                stream <<
+                    "Passed " << bothOrAll( totals.testCases.total() )
+                              << pluralise( totals.testCases.total(), "test case" )
+                              << " (no assertions).";
+            }
+            else if( totals.assertions.failed ) {
+                Colour colour( Colour::ResultError );
+                stream <<
+                    "Failed " << pluralise( totals.testCases.failed, "test case"  ) << ", "
+                    "failed " << pluralise( totals.assertions.failed, "assertion" ) << ".";
+            }
+            else {
+                Colour colour( Colour::ResultSuccess );
+                stream <<
+                    "Passed " << bothOrAll( totals.testCases.passed )
+                              << pluralise( totals.testCases.passed, "test case"  ) <<
+                    " with "  << pluralise( totals.assertions.passed, "assertion" ) << ".";
+            }
+        }
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+
+} // end namespace Catch
+
+namespace Catch {
+    NonCopyable::~NonCopyable() {}
+    IShared::~IShared() {}
+    StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
+    IContext::~IContext() {}
+    IResultCapture::~IResultCapture() {}
+    ITestCase::~ITestCase() {}
+    ITestCaseRegistry::~ITestCaseRegistry() {}
+    IRegistryHub::~IRegistryHub() {}
+    IMutableRegistryHub::~IMutableRegistryHub() {}
+    IExceptionTranslator::~IExceptionTranslator() {}
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
+    IReporter::~IReporter() {}
+    IReporterFactory::~IReporterFactory() {}
+    IReporterRegistry::~IReporterRegistry() {}
+    IStreamingReporter::~IStreamingReporter() {}
+    AssertionStats::~AssertionStats() {}
+    SectionStats::~SectionStats() {}
+    TestCaseStats::~TestCaseStats() {}
+    TestGroupStats::~TestGroupStats() {}
+    TestRunStats::~TestRunStats() {}
+    CumulativeReporterBase::SectionNode::~SectionNode() {}
+    CumulativeReporterBase::~CumulativeReporterBase() {}
+
+    StreamingReporterBase::~StreamingReporterBase() {}
+    ConsoleReporter::~ConsoleReporter() {}
+    CompactReporter::~CompactReporter() {}
+    IRunner::~IRunner() {}
+    IMutableContext::~IMutableContext() {}
+    IConfig::~IConfig() {}
+    XmlReporter::~XmlReporter() {}
+    JunitReporter::~JunitReporter() {}
+    TestRegistry::~TestRegistry() {}
+    FreeFunctionTestCase::~FreeFunctionTestCase() {}
+    IGeneratorInfo::~IGeneratorInfo() {}
+    IGeneratorsForTest::~IGeneratorsForTest() {}
+    TestSpec::Pattern::~Pattern() {}
+    TestSpec::NamePattern::~NamePattern() {}
+    TestSpec::TagPattern::~TagPattern() {}
+    TestSpec::ExcludedPattern::~ExcludedPattern() {}
+
+    Matchers::Impl::StdString::Equals::~Equals() {}
+    Matchers::Impl::StdString::Contains::~Contains() {}
+    Matchers::Impl::StdString::StartsWith::~StartsWith() {}
+    Matchers::Impl::StdString::EndsWith::~EndsWith() {}
+
+    void Config::dummy() {}
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// #included from: internal/catch_default_main.hpp
+#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
+
+#ifndef __OBJC__
+
+// Standard C/C++ main entry point
+int main (int argc, char * const argv[]) {
+    return Catch::Session().run( argc, argv );
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main (int argc, char * const argv[]) {
+#if !CATCH_ARC_ENABLED
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+    Catch::registerTestMethods();
+    int result = Catch::Session().run( argc, (char* const*)argv );
+
+#if !CATCH_ARC_ENABLED
+    [pool drain];
+#endif
+
+    return result;
+}
+
+#endif // __OBJC__
+
+#endif
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#  undef CLARA_CONFIG_MAIN
+#endif
+
+//////
+
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" )
+
+#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS" )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" )
+#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" )
+
+#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" )
+#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" )
+#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" )
+#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" )
+#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" )
+
+#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" )
+#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" )
+
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" )
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" )
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg )
+#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
+#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )
+#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ )
+    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ )
+#else
+    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg )
+    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg )
+#endif
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
+
+#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
+
+#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#else
+#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
+#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define CATCH_GIVEN( desc )    CATCH_SECTION( "Given: " desc, "" )
+#define CATCH_WHEN( desc )     CATCH_SECTION( " When: " desc, "" )
+#define CATCH_AND_WHEN( desc ) CATCH_SECTION( "  And: " desc, "" )
+#define CATCH_THEN( desc )     CATCH_SECTION( " Then: " desc, "" )
+#define CATCH_AND_THEN( desc ) CATCH_SECTION( "  And: " desc, "" )
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" )
+
+#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "REQUIRE_THROWS" )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" )
+#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" )
+
+#define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" )
+#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" )
+#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" )
+#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" )
+#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" )
+
+#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS" )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" )
+#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" )
+
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" )
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" )
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
+#define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg )
+#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
+#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )
+#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+    #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ )
+    #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ )
+#else
+    #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg )
+    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg )
+#endif
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
+
+#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
+
+#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#else
+#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
+#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define GIVEN( desc )    SECTION( "   Given: " desc, "" )
+#define WHEN( desc )     SECTION( "    When: " desc, "" )
+#define AND_WHEN( desc ) SECTION( "And when: " desc, "" )
+#define THEN( desc )     SECTION( "    Then: " desc, "" )
+#define AND_THEN( desc ) SECTION( "     And: " desc, "" )
+
+using Catch::Detail::Approx;
+
+// #included from: internal/catch_reenable_warnings.h
+
+#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
+
+#ifdef __clang__
+#    ifdef __ICC // icpc defines the __clang__ macro
+#        pragma warning(pop)
+#    else
+#        pragma clang diagnostic pop
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
diff --git a/tests/file_log.cpp b/tests/file_log.cpp
new file mode 100644
index 00000000..c57cd21f
--- /dev/null
+++ b/tests/file_log.cpp
@@ -0,0 +1,136 @@
+#include "includes.h"
+
+static std::string file_contents(const std::string& filename)
+{
+    std::ifstream ifs(filename);
+    if (!ifs)
+        throw std::exception("Failed open file ");
+    return std::string((std::istreambuf_iterator<char>(ifs)),
+                       (std::istreambuf_iterator<char>()));
+
+}
+
+
+static std::size_t count_lines(const std::string& filename)
+{
+    std::ifstream ifs(filename);
+    if (!ifs)
+        throw std::exception("Failed open file ");
+
+    std::string line;
+    size_t counter = 0;
+    while(std::getline(ifs, line))
+        counter++;
+    return counter;
+}
+
+std::ifstream::pos_type filesize(const std::string& filename)
+{
+    std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary);
+    if (!ifs)
+        throw std::exception("Failed open file ");
+
+    return ifs.tellg();
+}
+
+static void delete_logs()
+{
+    spdlog::drop_all();
+#ifdef _WIN32
+    system("del /F /Q logs\\*");
+#else
+    system("rm -f logs/*");
+#endif
+}
+
+
+
+TEST_CASE("simple_file_logger", "[simple_logger]]")
+{
+    delete_logs();
+    std::string filename = "logs/simple_log.txt";
+
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
+
+    REQUIRE_THROWS_AS(
+        auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger2", filename);
+        , spdlog::spdlog_ex);
+
+    logger->set_pattern("%v");
+    logger->info("Test message {}", 1);
+    logger->info("Test message {}", 2);
+    logger->flush();
+    REQUIRE(file_contents(filename) == std::string("Test message 1\nTest message 2\n"));
+    REQUIRE(count_lines(filename) == 2);
+
+}
+
+
+TEST_CASE("rotating_file_logger1", "[rotating_logger]]")
+{
+    delete_logs();
+    std::string basename = "logs/rotating_log";
+    auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 0, true);
+    for (int i = 0; i < 10; ++i)
+        logger->info("Test message {}", i);
+
+    auto filename = basename + ".txt";
+    REQUIRE(count_lines(filename) == 10);
+    for (int i = 0; i < 1000; i++)
+        logger->info("Test message {}", i);
+
+}
+
+
+TEST_CASE("rotating_file_logger2", "[rotating_logger]]")
+{
+    delete_logs();
+    std::string basename = "logs/rotating_log";
+    auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 1, false);
+    for (int i = 0; i < 10; ++i)
+        logger->info("Test message {}", i);
+
+    logger->flush();
+    auto filename = basename + ".txt";
+    REQUIRE(count_lines(filename) == 10);
+    for (int i = 0; i < 1000; i++)
+        logger->info("Test message {}", i);
+
+    logger->flush();
+    REQUIRE(filesize(filename) <= 1024);
+    auto filename1 = basename + ".1.txt";
+    REQUIRE(filesize(filename1) <= 1024);
+}
+
+
+TEST_CASE("daily_logger", "[daily_logger]]")
+{
+
+    delete_logs();
+    //calculate filename (time based)
+    std::string basename = "logs/daily_log";
+    std::tm tm = spdlog::details::os::localtime();
+    fmt::MemoryWriter w;
+    w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.txt", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min);
+
+    auto logger = spdlog::daily_logger_mt("logger", basename, 0, 0, true);
+    for (int i = 0; i < 10; ++i)
+        logger->info("Test message {}", i);
+
+    auto filename = w.str();
+    REQUIRE(count_lines(filename) == 10);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/format.cpp b/tests/format.cpp
new file mode 100644
index 00000000..2221900f
--- /dev/null
+++ b/tests/format.cpp
@@ -0,0 +1,87 @@
+
+#include "includes.h"
+
+template<class T>
+std::string log_info(const T& what, spdlog::level::level_enum logger_level = spdlog::level::info) {
+
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+
+    spdlog::logger oss_logger("oss", oss_sink);
+    oss_logger.set_level(logger_level);
+    oss_logger.set_pattern("%v");
+    oss_logger.info() << what;
+
+    //strip last eol and return the logged string
+    auto eol_size = strlen(spdlog::details::os::eol());
+    return oss.str().substr(0, oss.str().length() - eol_size);
+}
+
+
+
+
+
+
+//User defined class with operator<<
+struct some_logged_class
+{
+    some_logged_class(const std::string val) :value(val) {};
+    std::string value;
+};
+std::ostream& operator<<(std::ostream& os, const some_logged_class& c) {
+    return os << c.value;
+}
+
+
+
+TEST_CASE("basic_logging ", "[basic_logging]") {
+    //const char
+    REQUIRE(log_info("Hello") == "Hello");
+    REQUIRE(log_info("") == "");
+
+    //std::string
+    REQUIRE(log_info(std::string("Hello")) == "Hello");
+    REQUIRE(log_info(std::string()) == std::string());
+
+    //Numbers
+    REQUIRE(log_info(5) == "5");
+    REQUIRE(log_info(5.6) == "5.6");
+
+    //User defined class
+    REQUIRE(log_info(some_logged_class("some_val")) == "some_val");
+}
+
+
+TEST_CASE("log_levels", "[log_levels]")
+{
+    REQUIRE(log_info("Hello", spdlog::level::err) == "");
+    REQUIRE(log_info("Hello", spdlog::level::critical) == "");
+    REQUIRE(log_info("Hello", spdlog::level::emerg) == "");
+    REQUIRE(log_info("Hello", spdlog::level::alert) == "");
+    REQUIRE(log_info("Hello", spdlog::level::info) == "Hello");
+    REQUIRE(log_info("Hello", spdlog::level::debug) == "Hello");
+    REQUIRE(log_info("Hello", spdlog::level::trace) == "Hello");
+}
+
+TEST_CASE("invalid_format", "[format]")
+{
+
+    using namespace spdlog::sinks;
+    spdlog::logger null_logger("null_logger", std::make_shared<null_sink_st>());
+    REQUIRE_THROWS_AS(
+        null_logger.info("{} {}", "first"),
+        spdlog::spdlog_ex);
+
+    REQUIRE_THROWS_AS(
+        null_logger.info("{0:f}", "aads"),
+        spdlog::spdlog_ex);
+
+    REQUIRE_THROWS_AS(
+        null_logger.info("{0:kk}", 123),
+        spdlog::spdlog_ex);
+
+}
+
+
+
+
diff --git a/tests/includes.h b/tests/includes.h
new file mode 100644
index 00000000..3f74cd5f
--- /dev/null
+++ b/tests/includes.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <cstdio>
+#include <fstream>
+#include <string>
+#include <ostream>
+#include <chrono>
+#include "catch.hpp"
+#include "../include/spdlog/spdlog.h"
+#include "../include/spdlog/sinks/null_sink.h"
\ No newline at end of file
diff --git a/tests/logs/placeholder.txt b/tests/logs/placeholder.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/main.cpp b/tests/main.cpp
new file mode 100644
index 00000000..063e8787
--- /dev/null
+++ b/tests/main.cpp
@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
\ No newline at end of file
diff --git a/tests/registry.cpp b/tests/registry.cpp
new file mode 100644
index 00000000..47e3966d
--- /dev/null
+++ b/tests/registry.cpp
@@ -0,0 +1,53 @@
+#include "includes.h"
+
+static const char *logger_name = "null_logger";
+
+TEST_CASE("register_drop", "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::create<spdlog::sinks::null_sink_mt>(logger_name);
+    REQUIRE(spdlog::get(logger_name)!=nullptr);
+    //Throw if registring existing name
+    REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(logger_name), spdlog::spdlog_ex);
+}
+
+
+TEST_CASE("explicit register" "[registry]")
+{
+    spdlog::drop_all();
+    auto logger = std::make_shared<spdlog::logger>(logger_name, std::make_shared<spdlog::sinks::null_sink_st>());
+    spdlog::register_logger(logger);
+    REQUIRE(spdlog::get(logger_name) != nullptr);
+    //Throw if registring existing name
+    REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(logger_name), spdlog::spdlog_ex);
+}
+
+TEST_CASE("drop" "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::create<spdlog::sinks::null_sink_mt>(logger_name);
+    spdlog::drop(logger_name);
+    REQUIRE_FALSE(spdlog::get(logger_name));
+}
+
+TEST_CASE("drop_all" "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::create<spdlog::sinks::null_sink_mt>(logger_name);
+    spdlog::create<spdlog::sinks::null_sink_mt>("name2");
+    spdlog::drop_all();
+    REQUIRE_FALSE(spdlog::get(logger_name));
+    REQUIRE_FALSE(spdlog::get("name2"));
+}
+
+
+TEST_CASE("drop non existing" "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::create<spdlog::sinks::null_sink_mt>(logger_name);
+    spdlog::drop("some_name");
+    REQUIRE_FALSE(spdlog::get("some_name"));
+    REQUIRE(spdlog::get(logger_name));
+    spdlog::drop_all();
+}
+
diff --git a/tests/tests.vcxproj b/tests/tests.vcxproj
new file mode 100644
index 00000000..92fa3b67
--- /dev/null
+++ b/tests/tests.vcxproj
@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="file_log.cpp" />
+    <ClCompile Include="format.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="registry.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="catch.hpp" />
+    <ClInclude Include="includes.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{1274FDEC-109A-45DF-8AEC-E3334C3A925F}</ProjectGuid>
+    <RootNamespace>tests</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <OutDir>$(ProjectDir)</OutDir>
+    <IntDir>$(ProjectDir)\$(Configuration-obj)\</IntDir>
+    <TargetName>$(ProjectName)-debug</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <OutDir>$(ProjectDir)</OutDir>
+    <IntDir>$(ProjectDir)\$(Configuration)-obj\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/tests/tests.vcxproj.filters b/tests/tests.vcxproj.filters
new file mode 100644
index 00000000..1651327d
--- /dev/null
+++ b/tests/tests.vcxproj.filters
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Headers">
+      <UniqueIdentifier>{9e4e82c2-35fe-4707-a66a-5cc069b44224}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="catch.hpp">
+      <Filter>Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="includes.h">
+      <Filter>Headers</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>
\ No newline at end of file

From b5eaef81d4651d1e8003191ccf87a76442955a3a Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 20:48:38 +0300
Subject: [PATCH 31/61] fixed tests under gcc

---
 tests/Makefile     | 15 ++++++++++++---
 tests/file_log.cpp |  6 +++---
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/tests/Makefile b/tests/Makefile
index 7580ee7d..c1347d40 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -1,10 +1,19 @@
 CXX	?= g++
 CXXFLAGS	=  -D_WIN32_WINNT=0x600 -march=native -Wall -Wextra -Wshadow -pedantic -std=c++11 -pthread -Wl,--no-as-needed  -I../include 
+LDPFALGS = -pthread
+
+CPP_FILES := $(wildcard *.cpp)
+OBJ_FILES := $(addprefix ./,$(notdir $(CPP_FILES:.cpp=.o)))
+
+
+tests: $(OBJ_FILES)
+	$(CXX) $(CXXFLAGS) $(LDPFALGS) -o $@ $^
+
+%.o: %.cpp
+	g++ $(CXXFLAGS) -c -o $@ $<
 
-all: %.cpp
-    $(CXX) $^ -o tests $(CXXFLAGS) $(CXX_RELEASE_FLAGS)    
 clean:
-    rm -f tests *.o logs/*     
+	rm -f tests *.o logs/*     
  
 rebuild: clean all
 
diff --git a/tests/file_log.cpp b/tests/file_log.cpp
index c57cd21f..5fc92664 100644
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -4,7 +4,7 @@ static std::string file_contents(const std::string& filename)
 {
     std::ifstream ifs(filename);
     if (!ifs)
-        throw std::exception("Failed open file ");
+        throw std::runtime_error("Failed open file ");
     return std::string((std::istreambuf_iterator<char>(ifs)),
                        (std::istreambuf_iterator<char>()));
 
@@ -15,7 +15,7 @@ static std::size_t count_lines(const std::string& filename)
 {
     std::ifstream ifs(filename);
     if (!ifs)
-        throw std::exception("Failed open file ");
+        throw std::runtime_error("Failed open file ");
 
     std::string line;
     size_t counter = 0;
@@ -28,7 +28,7 @@ std::ifstream::pos_type filesize(const std::string& filename)
 {
     std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary);
     if (!ifs)
-        throw std::exception("Failed open file ");
+        throw std::runtime_error("Failed open file ");
 
     return ifs.tellg();
 }

From c701420cf6233e7eaa21e5b6c711b50bbc85e00a Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 20:54:01 +0300
Subject: [PATCH 32/61] fixed tests

---
 tests/Makefile             | 6 +++---
 tests/file_log.cpp         | 4 ++--
 tests/includes.h           | 4 +++-
 tests/logs/placeholder.txt | 0
 4 files changed, 8 insertions(+), 6 deletions(-)
 delete mode 100644 tests/logs/placeholder.txt

diff --git a/tests/Makefile b/tests/Makefile
index c1347d40..5d58c35c 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -1,6 +1,6 @@
 CXX	?= g++
-CXXFLAGS	=  -D_WIN32_WINNT=0x600 -march=native -Wall -Wextra -Wshadow -pedantic -std=c++11 -pthread -Wl,--no-as-needed  -I../include 
-LDPFALGS = -pthread
+CXXFLAGS	=  -D_WIN32_WINNT=0x600 -march=native -Wall  -pedantic -std=c++11 -pthread -Wl,--no-as-needed -O
+LDPFALGS = -pthread -flto
 
 CPP_FILES := $(wildcard *.cpp)
 OBJ_FILES := $(addprefix ./,$(notdir $(CPP_FILES:.cpp=.o)))
@@ -15,7 +15,7 @@ tests: $(OBJ_FILES)
 clean:
 	rm -f tests *.o logs/*     
  
-rebuild: clean all
+rebuild: clean tests
 
 
 
diff --git a/tests/file_log.cpp b/tests/file_log.cpp
index 5fc92664..41167f05 100644
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -37,9 +37,9 @@ static void delete_logs()
 {
     spdlog::drop_all();
 #ifdef _WIN32
-    system("del /F /Q logs\\*");
+    auto rv = system("del /F /Q logs\\*");
 #else
-    system("rm -f logs/*");
+    auto rv = system("rm -f logs/*");
 #endif
 }
 
diff --git a/tests/includes.h b/tests/includes.h
index 3f74cd5f..7cda161d 100644
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -5,6 +5,8 @@
 #include <string>
 #include <ostream>
 #include <chrono>
+#include <exception>
+
 #include "catch.hpp"
 #include "../include/spdlog/spdlog.h"
-#include "../include/spdlog/sinks/null_sink.h"
\ No newline at end of file
+#include "../include/spdlog/sinks/null_sink.h"
diff --git a/tests/logs/placeholder.txt b/tests/logs/placeholder.txt
deleted file mode 100644
index e69de29b..00000000

From 8387d779b44c1228fb0ef66188f92531e12f65dd Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 21:45:10 +0300
Subject: [PATCH 33/61] fixed tests

---
 tests/Makefile     |  2 +-
 tests/file_log.cpp | 10 +++-------
 tests/format.cpp   |  9 ++++++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/tests/Makefile b/tests/Makefile
index 5d58c35c..fc428a9b 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -1,5 +1,5 @@
 CXX	?= g++
-CXXFLAGS	=  -D_WIN32_WINNT=0x600 -march=native -Wall  -pedantic -std=c++11 -pthread -Wl,--no-as-needed -O
+CXXFLAGS	=  -Wall  -pedantic -std=c++11 -pthread -Wl,--no-as-needed -O2
 LDPFALGS = -pthread -flto
 
 CPP_FILES := $(wildcard *.cpp)
diff --git a/tests/file_log.cpp b/tests/file_log.cpp
index 41167f05..ac8bc158 100644
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -10,7 +10,6 @@ static std::string file_contents(const std::string& filename)
 
 }
 
-
 static std::size_t count_lines(const std::string& filename)
 {
     std::ifstream ifs(filename);
@@ -51,12 +50,9 @@ TEST_CASE("simple_file_logger", "[simple_logger]]")
     std::string filename = "logs/simple_log.txt";
 
     auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
-
-    REQUIRE_THROWS_AS(
-        auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger2", filename);
-        , spdlog::spdlog_ex);
-
     logger->set_pattern("%v");
+
+    
     logger->info("Test message {}", 1);
     logger->info("Test message {}", 2);
     logger->flush();
@@ -107,7 +103,7 @@ TEST_CASE("daily_logger", "[daily_logger]]")
 {
 
     delete_logs();
-    //calculate filename (time based)
+//calculate filename (time based)
     std::string basename = "logs/daily_log";
     std::tm tm = spdlog::details::os::localtime();
     fmt::MemoryWriter w;
diff --git a/tests/format.cpp b/tests/format.cpp
index 2221900f..5182b267 100644
--- a/tests/format.cpp
+++ b/tests/format.cpp
@@ -2,7 +2,8 @@
 #include "includes.h"
 
 template<class T>
-std::string log_info(const T& what, spdlog::level::level_enum logger_level = spdlog::level::info) {
+std::string log_info(const T& what, spdlog::level::level_enum logger_level = spdlog::level::info)
+{
 
     std::ostringstream oss;
     auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
@@ -28,13 +29,15 @@ struct some_logged_class
     some_logged_class(const std::string val) :value(val) {};
     std::string value;
 };
-std::ostream& operator<<(std::ostream& os, const some_logged_class& c) {
+std::ostream& operator<<(std::ostream& os, const some_logged_class& c)
+{
     return os << c.value;
 }
 
 
 
-TEST_CASE("basic_logging ", "[basic_logging]") {
+TEST_CASE("basic_logging ", "[basic_logging]")
+{
     //const char
     REQUIRE(log_info("Hello") == "Hello");
     REQUIRE(log_info("") == "");

From dcdf2280c8506d425bb3cfd898a1ff68aa791867 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 21:51:09 +0300
Subject: [PATCH 34/61] fixed tests

---
 tests/file_log.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/file_log.cpp b/tests/file_log.cpp
index ac8bc158..0c2d21d9 100644
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -32,13 +32,13 @@ std::ifstream::pos_type filesize(const std::string& filename)
     return ifs.tellg();
 }
 
-static void delete_logs()
+static void prepare_logdir()
 {
     spdlog::drop_all();
 #ifdef _WIN32
-    auto rv = system("del /F /Q logs\\*");
+    auto rv = system("mkdir logs;del /F /Q logs\\*");
 #else
-    auto rv = system("rm -f logs/*");
+    auto rv = system("mkdir logs;rm -f logs/*");
 #endif
 }
 
@@ -46,7 +46,7 @@ static void delete_logs()
 
 TEST_CASE("simple_file_logger", "[simple_logger]]")
 {
-    delete_logs();
+    prepare_logdir();
     std::string filename = "logs/simple_log.txt";
 
     auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
@@ -64,7 +64,7 @@ TEST_CASE("simple_file_logger", "[simple_logger]]")
 
 TEST_CASE("rotating_file_logger1", "[rotating_logger]]")
 {
-    delete_logs();
+    prepare_logdir();
     std::string basename = "logs/rotating_log";
     auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 0, true);
     for (int i = 0; i < 10; ++i)
@@ -80,7 +80,7 @@ TEST_CASE("rotating_file_logger1", "[rotating_logger]]")
 
 TEST_CASE("rotating_file_logger2", "[rotating_logger]]")
 {
-    delete_logs();
+    prepare_logdir();
     std::string basename = "logs/rotating_log";
     auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 1, false);
     for (int i = 0; i < 10; ++i)
@@ -102,8 +102,8 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]]")
 TEST_CASE("daily_logger", "[daily_logger]]")
 {
 
-    delete_logs();
-//calculate filename (time based)
+    prepare_logdir();
+    //calculate filename (time based)
     std::string basename = "logs/daily_log";
     std::tm tm = spdlog::details::os::localtime();
     fmt::MemoryWriter w;

From d7b0b54c9cd43f616c916be576c18b0a86523394 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 21:56:06 +0300
Subject: [PATCH 35/61] fixed tests

---
 tests/file_log.cpp    | 4 ++--
 tests/logs/.gitignore | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)
 create mode 100644 tests/logs/.gitignore

diff --git a/tests/file_log.cpp b/tests/file_log.cpp
index 0c2d21d9..d8e5aa19 100644
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -36,9 +36,9 @@ static void prepare_logdir()
 {
     spdlog::drop_all();
 #ifdef _WIN32
-    auto rv = system("mkdir logs;del /F /Q logs\\*");
+    auto rv = system("del /F /Q logs\\*");
 #else
-    auto rv = system("mkdir logs;rm -f logs/*");
+    auto rv = system("rm -f logs/*");
 #endif
 }
 
diff --git a/tests/logs/.gitignore b/tests/logs/.gitignore
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/tests/logs/.gitignore
@@ -0,0 +1 @@
+

From 1fef4bbd622405e1ee9fbdc5aedb4788f843df96 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 22:08:34 +0300
Subject: [PATCH 36/61] added tests to travis

---
 .travis.yml                                  | 4 +++-
 install_libcxx.sh => tests/install_libcxx.sh | 0
 2 files changed, 3 insertions(+), 1 deletion(-)
 rename install_libcxx.sh => tests/install_libcxx.sh (100%)

diff --git a/.travis.yml b/.travis.yml
index 76822575..8cf9a9ae 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -107,7 +107,7 @@ before_install:
   - which $CXX
   - which $CC
   - which valgrind
-  - if [ -n "$CLANG_VERSION" ]; then sudo CXX=$CXX CC=$CC ./install_libcxx.sh; fi
+  - if [ -n "$CLANG_VERSION" ]; then sudo CXX=$CXX CC=$CC .tests/install_libcxx.sh; fi
 
 install:
   - cd $CHECKOUT_PATH
@@ -131,10 +131,12 @@ install:
   - cd example
   - if [ "$BUILD_TYPE" == "Release" ]; then make rebuild CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; export BIN=example; fi
   - if [ "$BUILD_TYPE" == "Debug" ]; then make rebuild debug CXXFLAGS="${CXX_FLAGS} ${CXX_LINKER_FLAGS}" VERBOSE=1; export BIN=example-debug; fi
+  
 
 script:
   - ./"${BIN}"
   - valgrind --trace-children=yes --leak-check=full ./"${BIN}"
+  - cd tests; make rebuild; ./tests
 
 notifications:
   email: false
diff --git a/install_libcxx.sh b/tests/install_libcxx.sh
similarity index 100%
rename from install_libcxx.sh
rename to tests/install_libcxx.sh

From 83d47aa6457fd27646dffe8f0030c38429c727f6 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 22:21:37 +0300
Subject: [PATCH 37/61] VS 2013 solution for unit tests

---
 tests/logs/.gitignore       |  1 -
 tests/tests.sln             | 22 ++++++++++++++++++++++
 tests/tests.vcxproj         | 32 ++++++++++++--------------------
 tests/tests.vcxproj.filters | 35 +++++++++++++++++++++++++++++------
 4 files changed, 63 insertions(+), 27 deletions(-)
 delete mode 100644 tests/logs/.gitignore
 create mode 100644 tests/tests.sln

diff --git a/tests/logs/.gitignore b/tests/logs/.gitignore
deleted file mode 100644
index 8b137891..00000000
--- a/tests/logs/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/tests/tests.sln b/tests/tests.sln
new file mode 100644
index 00000000..8423a780
--- /dev/null
+++ b/tests/tests.sln
@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tests", "tests.vcxproj", "{59A07559-5F38-4DD6-A7FA-DB4153690B42}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Debug|Win32.ActiveCfg = Debug|Win32
+		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Debug|Win32.Build.0 = Debug|Win32
+		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Release|Win32.ActiveCfg = Release|Win32
+		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/tests/tests.vcxproj b/tests/tests.vcxproj
index 92fa3b67..6bf3a3d9 100644
--- a/tests/tests.vcxproj
+++ b/tests/tests.vcxproj
@@ -10,18 +10,8 @@
       <Platform>Win32</Platform>
     </ProjectConfiguration>
   </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="file_log.cpp" />
-    <ClCompile Include="format.cpp" />
-    <ClCompile Include="main.cpp" />
-    <ClCompile Include="registry.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="catch.hpp" />
-    <ClInclude Include="includes.h" />
-  </ItemGroup>
   <PropertyGroup Label="Globals">
-    <ProjectGuid>{1274FDEC-109A-45DF-8AEC-E3334C3A925F}</ProjectGuid>
+    <ProjectGuid>{59A07559-5F38-4DD6-A7FA-DB4153690B42}</ProjectGuid>
     <RootNamespace>tests</RootNamespace>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
@@ -48,15 +38,7 @@
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>$(ProjectDir)</OutDir>
-    <IntDir>$(ProjectDir)\$(Configuration-obj)\</IntDir>
-    <TargetName>$(ProjectName)-debug</TargetName>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>$(ProjectDir)</OutDir>
-    <IntDir>$(ProjectDir)\$(Configuration)-obj\</IntDir>
-  </PropertyGroup>
+  <PropertyGroup />
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
@@ -83,6 +65,16 @@
       <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="file_log.cpp" />
+    <ClCompile Include="format.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="registry.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="catch.hpp" />
+    <ClInclude Include="includes.h" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
diff --git a/tests/tests.vcxproj.filters b/tests/tests.vcxproj.filters
index 1651327d..36fe0a87 100644
--- a/tests/tests.vcxproj.filters
+++ b/tests/tests.vcxproj.filters
@@ -1,16 +1,39 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <Filter Include="Headers">
-      <UniqueIdentifier>{9e4e82c2-35fe-4707-a66a-5cc069b44224}</UniqueIdentifier>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="catch.hpp">
-      <Filter>Headers</Filter>
-    </ClInclude>
+    <ClCompile Include="file_log.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="format.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="registry.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
     <ClInclude Include="includes.h">
-      <Filter>Headers</Filter>
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="catch.hpp">
+      <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file

From 05a7d9f61caeb4fa8a6eb2ba8993e0db635ba4f1 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 22:25:02 +0300
Subject: [PATCH 38/61] fixed travis

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 8cf9a9ae..85eb8491 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -136,7 +136,7 @@ install:
 script:
   - ./"${BIN}"
   - valgrind --trace-children=yes --leak-check=full ./"${BIN}"
-  - cd tests; make rebuild; ./tests
+  - cd $CHECKOUT_PATH/tests; make rebuild; ./tests
 
 notifications:
   email: false

From 19a2abaab8c56a8f18ed3710de424fda4e2dea02 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 22:47:05 +0300
Subject: [PATCH 39/61] fixed travis

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 85eb8491..6018b7f1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -107,7 +107,7 @@ before_install:
   - which $CXX
   - which $CC
   - which valgrind
-  - if [ -n "$CLANG_VERSION" ]; then sudo CXX=$CXX CC=$CC .tests/install_libcxx.sh; fi
+  - if [ -n "$CLANG_VERSION" ]; then sudo CXX=$CXX CC=$CC ./tests/install_libcxx.sh; fi
 
 install:
   - cd $CHECKOUT_PATH

From d0f145f0094596a666d5b64904d9177dd906753c Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 22:54:07 +0300
Subject: [PATCH 40/61] fixed tests make file

---
 tests/Makefile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/Makefile b/tests/Makefile
index fc428a9b..5f841a85 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -1,6 +1,6 @@
 CXX	?= g++
-CXXFLAGS	=  -Wall  -pedantic -std=c++11 -pthread -Wl,--no-as-needed -O2
-LDPFALGS = -pthread -flto
+CXXFLAGS	=  -Wall  -pedantic -std=c++11 -pthread -O2
+LDPFALGS = -pthread
 
 CPP_FILES := $(wildcard *.cpp)
 OBJ_FILES := $(addprefix ./,$(notdir $(CPP_FILES:.cpp=.o)))
@@ -10,7 +10,7 @@ tests: $(OBJ_FILES)
 	$(CXX) $(CXXFLAGS) $(LDPFALGS) -o $@ $^
 
 %.o: %.cpp
-	g++ $(CXXFLAGS) -c -o $@ $<
+	$(CXX) $(CXXFLAGS) -c -o $@ $<
 
 clean:
 	rm -f tests *.o logs/*     

From 319a62d73f0d6fd8262c606b071499be26f472b1 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 15 May 2015 23:04:09 +0300
Subject: [PATCH 41/61] fixed tests makefile

---
 tests/Makefile | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/tests/Makefile b/tests/Makefile
index 5f841a85..5be7be50 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -5,15 +5,16 @@ LDPFALGS = -pthread
 CPP_FILES := $(wildcard *.cpp)
 OBJ_FILES := $(addprefix ./,$(notdir $(CPP_FILES:.cpp=.o)))
 
-
-tests: $(OBJ_FILES)
+    
+tests: $(OBJ_FILES)    
 	$(CXX) $(CXXFLAGS) $(LDPFALGS) -o $@ $^
+	mkdir -p logs
 
 %.o: %.cpp
 	$(CXX) $(CXXFLAGS) -c -o $@ $<
 
 clean:
-	rm -f tests *.o logs/*     
+	rm -f tests *.o logs/*.txt     
  
 rebuild: clean tests
 

From 51f69dfcca1d7ba8d81a1fdbb4b0e1d9dcf7e24e Mon Sep 17 00:00:00 2001
From: nick <nickrossi@creativepath.net>
Date: Tue, 2 Jun 2015 13:01:24 -0700
Subject: [PATCH 42/61] Expose line_logger enabled state to support custom
 operator<<'s

---
 include/spdlog/details/line_logger.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h
index 3a946cb6..da121c11 100644
--- a/include/spdlog/details/line_logger.h
+++ b/include/spdlog/details/line_logger.h
@@ -206,6 +206,11 @@ public:
         _enabled = false;
     }
 
+    bool is_enabled()
+    {
+        return _enabled;
+    }
+
 
 private:
     logger* _callback_logger;

From ba1de0abb298826eb5ca37e3bc502e9088cb7d7e Mon Sep 17 00:00:00 2001
From: nick <nickrossi@creativepath.net>
Date: Tue, 2 Jun 2015 14:38:11 -0700
Subject: [PATCH 43/61] make is_enabled() const

---
 include/spdlog/details/line_logger.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h
index da121c11..80d7cc13 100644
--- a/include/spdlog/details/line_logger.h
+++ b/include/spdlog/details/line_logger.h
@@ -206,7 +206,7 @@ public:
         _enabled = false;
     }
 
-    bool is_enabled()
+    bool is_enabled() const
     {
         return _enabled;
     }

From 1c13f5d7ff3025c49fa2fdb76f460fa717085b11 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Wed, 8 Jul 2015 23:45:48 +0300
Subject: [PATCH 44/61] Updated cppformat to fix issue #110

---
 include/spdlog/details/format.cc | 1812 ++++++++-------
 include/spdlog/details/format.h  | 3621 +++++++++++++++++-------------
 2 files changed, 2978 insertions(+), 2455 deletions(-)

diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc
index 4de135cf..fb0ef9ea 100644
--- a/include/spdlog/details/format.cc
+++ b/include/spdlog/details/format.cc
@@ -1,29 +1,29 @@
 /*
- Formatting library for C++
+Formatting library for C++
 
- Copyright (c) 2012 - 2015, Victor Zverovich
- All rights reserved.
+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:
+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.
+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.
- */
+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"
 
@@ -35,11 +35,18 @@
 #include <cmath>
 #include <cstdarg>
 
-#ifdef _WIN32
-# ifdef __MINGW32__
-#  include <cstring>
+#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
-# include <windows.h>
 #endif
 
 using fmt::internal::Arg;
@@ -88,24 +95,25 @@ using fmt::internal::Arg;
 
 // Dummy implementations of strerror_r and strerror_s called if corresponding
 // system functions are not available.
-static inline fmt::internal::None<> strerror_r(int, char *, ...) {
-  return fmt::internal::None<>();
+static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
+    return fmt::internal::Null<>();
 }
-static inline fmt::internal::None<> strerror_s(char *, std::size_t, ...) {
-  return fmt::internal::None<>();
+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;
+    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
@@ -120,24 +128,27 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
 // 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;
-  }
+    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;
-  }
+    template <typename T>
+    static bool fits_in_int(T value) {
+        return value >= INT_MIN && value <= INT_MAX;
+    }
 };
 
 const char RESET_COLOR[] = "\x1b[0m";
 
-typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
+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.
@@ -149,287 +160,428 @@ typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
 //   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 {
-  assert(buffer != 0 && buffer_size != 0);
+    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_;
+    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 &) {}
+        // 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 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 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::None<>) {
-      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
-    }
+        // 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 ?
+        // 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::None<>) {
-      errno = 0;
-      buffer_ = strerror(error_code_);
-      return errno;
-    }
+        // 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 error_code, char *&buffer, std::size_t buffer_size)
-      : error_code_(error_code), buffer_(buffer), buffer_size_(buffer_size) {}
+    public:
+        StrError(int error_code, char *&buffer, std::size_t buffer_size)
+            : error_code_(error_code), buffer_(buffer), buffer_size_(buffer_size) {}
 
-    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
-  };
-  return StrError(error_code, buffer, buffer_size).run();
+        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 ";
-  fmt::internal::IntTraits<int>::MainType ec_value = error_code;
-  // 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;
-  error_code_size += fmt::internal::count_digits(ec_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);
+                       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 ";
+    fmt::internal::IntTraits<int>::MainType ec_value = error_code;
+    // 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;
+    error_code_size += fmt::internal::count_digits(ec_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);
+                  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; }
+public:
+    template <typename T>
+    bool visit_any_int(T value) {
+        return value == 0;
+    }
 };
 
 // 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>
 int 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 = UINT_MAX;
-      break;
-    }
-    value = new_value;
-  } while ('0' <= *s && *s <= '9');
-  if (value > INT_MAX)
-    FMT_THROW(fmt::FormatError("number is too big"));
-  return value;
+    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 = UINT_MAX;
+            break;
+        }
+        value = new_value;
+    } while ('0' <= *s && *s <= '9');
+    if (value > INT_MAX)
+        FMT_THROW(fmt::FormatError("number is too big"));
+    return value;
+}
+
+template <typename Char>
+inline bool is_name_start(Char c) {
+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
 }
 
 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));
-  }
+    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(fmt::FormatError(fmt::format(
-      "format specifier '{}' requires signed argument", sign)));
-  }
-  ++s;
+    char sign = static_cast<char>(*s);
+    require_numeric_argument(arg, sign);
+    if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
+        FMT_THROW(fmt::FormatError(fmt::format(
+                                       "format specifier '{}' requires signed argument", sign)));
+    }
+    ++s;
 }
 
 // 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_;
+private:
+    fmt::FormatSpec &spec_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
+    FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
 
- public:
-  explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}
+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 = value;
-    if (fmt::internal::is_negative(value)) {
-      spec_.align_ = fmt::ALIGN_LEFT;
-      width = 0 - width;
+    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 = 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);
     }
-    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"));
-  }
+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>
+    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);
+    }
 };
 
 // Converts an integer argument to an integral type T for printf.
 template <typename T>
 class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
- private:
-  fmt::internal::Arg &arg_;
-  wchar_t type_;
+private:
+    fmt::internal::Arg &arg_;
+    wchar_t type_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
+    FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
 
- public:
-  ArgConverter(fmt::internal::Arg &arg, wchar_t type)
-    : arg_(arg), type_(type) {}
+public:
+    ArgConverter(fmt::internal::Arg &arg, wchar_t type)
+        : arg_(arg), type_(type) {}
 
-  template <typename U>
-  void visit_any_int(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    using fmt::internal::Arg;
-    if (sizeof(T) <= sizeof(int)) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_.type = Arg::INT;
-        arg_.int_value = static_cast<int>(static_cast<T>(value));
-      } else {
-        arg_.type = Arg::UINT;
-        arg_.uint_value = static_cast<unsigned>(
-            static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));
-      }
-    } else {
-      if (is_signed) {
-        arg_.type = Arg::LONG_LONG;
-        arg_.long_long_value =
-            static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
-      } else {
-        arg_.type = Arg::ULONG_LONG;
-        arg_.ulong_long_value =
-            static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
-      }
+    template <typename U>
+    void visit_any_int(U value) {
+        bool is_signed = type_ == 'd' || type_ == 'i';
+        using fmt::internal::Arg;
+        if (sizeof(T) <= sizeof(int)) {
+            // Extra casts are used to silence warnings.
+            if (is_signed) {
+                arg_.type = Arg::INT;
+                arg_.int_value = static_cast<int>(static_cast<T>(value));
+            }
+            else {
+                arg_.type = Arg::UINT;
+                arg_.uint_value = static_cast<unsigned>(
+                                      static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));
+            }
+        }
+        else {
+            if (is_signed) {
+                arg_.type = Arg::LONG_LONG;
+                arg_.long_long_value =
+                    static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(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_;
+private:
+    fmt::internal::Arg &arg_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
+    FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
 
- public:
-  explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}
+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);
-  }
+    template <typename T>
+    void visit_any_int(T value) {
+        arg_.type = Arg::CHAR;
+        arg_.int_value = static_cast<char>(value);
+    }
 };
-
-// This function template is used to prevent compile errors when handling
-// incompatible string arguments, e.g. handling a wide string in a narrow
-// string formatter.
-template <typename Char>
-Arg::StringValue<Char> ignore_incompatible_str(Arg::StringValue<wchar_t>);
-
-template <>
-inline Arg::StringValue<char> ignore_incompatible_str(
-    Arg::StringValue<wchar_t>) { return Arg::StringValue<char>(); }
-
-template <>
-inline Arg::StringValue<wchar_t> ignore_incompatible_str(
-    Arg::StringValue<wchar_t> s) { return s; }
 }  // namespace
 
+namespace internal {
+
+template <typename Impl, typename Char>
+class BasicArgFormatter : public ArgVisitor<Impl, void> {
+private:
+    BasicWriter<Char> &writer_;
+    FormatSpec &spec_;
+
+    FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter);
+
+protected:
+    BasicWriter<Char> &writer() {
+        return writer_;
+    }
+    const FormatSpec &spec() const {
+        return spec_;
+    }
+
+public:
+    BasicArgFormatter(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_) {
+            writer_.write_int(value, spec_);
+            return;
+        }
+        const char *str_value = value ? "true" : "false";
+        Arg::StringValue<char> str = { str_value, strlen(str_value) };
+        writer_.write_str(str, spec_);
+    }
+
+    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();
+        if (spec_.width_ > 1) {
+            out = writer_.grow_buffer(spec_.width_);
+            if (spec_.align_ == ALIGN_RIGHT) {
+                std::fill_n(out, spec_.width_ - 1, fill);
+                out += spec_.width_ - 1;
+            }
+            else if (spec_.align_ == ALIGN_CENTER) {
+                out = writer_.fill_padding(out, spec_.width_, 1, fill);
+            }
+            else {
+                std::fill_n(out + 1, spec_.width_ - 1, fill);
+            }
+        }
+        else {
+            out = writer_.grow_buffer(1);
+        }
+        *out = internal::CharTraits<Char>::cast(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");
+        spec_.flags_ = HASH_FLAG;
+        spec_.type_ = 'x';
+        writer_.write_int(reinterpret_cast<uintptr_t>(value), spec_);
+    }
+};
+
+// An argument formatter.
+template <typename Char>
+class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char> {
+private:
+    BasicFormatter<Char> &formatter_;
+    const Char *format_;
+
+public:
+    ArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)
+        : BasicArgFormatter<ArgFormatter<Char>, Char>(f.writer(), s),
+          formatter_(f), format_(fmt) {}
+
+    void visit_custom(Arg::CustomValue c) {
+        c.format(&formatter_, c.value, &format_);
+    }
+};
+
+template <typename Char>
+class PrintfArgFormatter :
+    public BasicArgFormatter<PrintfArgFormatter<Char>, Char> {
+public:
+    PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
+        : BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}
+
+    void visit_char(int value) {
+        const FormatSpec &spec = this->spec();
+        BasicWriter<Char> &writer = this->writer();
+        if (spec.type_ && spec.type_ != 'c')
+            writer.write_int(value, spec);
+        typedef typename BasicWriter<Char>::CharPtr CharPtr;
+        CharPtr out = CharPtr();
+        if (spec.width_ > 1) {
+            Char fill = ' ';
+            out = writer.grow_buffer(spec.width_);
+            if (spec.align_ != ALIGN_LEFT) {
+                std::fill_n(out, spec.width_ - 1, fill);
+                out += spec.width_ - 1;
+            }
+            else {
+                std::fill_n(out + 1, spec.width_ - 1, fill);
+            }
+        }
+        else {
+            out = writer.grow_buffer(1);
+        }
+        *out = static_cast<Char>(value);
+    }
+};
+}  // namespace internal
+}  // namespace fmt
+
 FMT_FUNC void fmt::SystemError::init(
-    int err_code, StringRef 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());
+    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) {
+    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, 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);
+           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) {
+    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, 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);
+           FMT_SWPRINTF(buffer, size, format, width, value) :
+           FMT_SWPRINTF(buffer, size, format, width, precision, value);
 }
 
 template <typename T>
@@ -453,710 +605,704 @@ const char fmt::internal::BasicData<T>::DIGITS[] =
 
 template <typename T>
 const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
-  0, FMT_POWERS_OF_10(1)
+    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
+    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))) {
+    (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 '{}' for {}", code, type)));
-  }
-  FMT_THROW(fmt::FormatError(
-      fmt::format("unknown format code '\\x{:02x}' for {}",
-        static_cast<unsigned>(code), type)));
+                  fmt::format("unknown format code '\\x{:02x}' for {}",
+                              static_cast<unsigned>(code), type)));
 }
 
-#ifdef _WIN32
+#if FMT_USE_WINDOWS_H
 
 FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
-  int length = MultiByteToWideChar(
-      CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, 0, 0);
-  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
-  if (length == 0)
-    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
-  buffer_.resize(length);
-  length = MultiByteToWideChar(
-    CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, &buffer_[0], length);
-  if (length == 0)
-    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
+    int length = MultiByteToWideChar(
+                     CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s.size(), 0, 0);
+    static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
+    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"));
-  }
+    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) {
-  int length = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), -1, 0, 0, 0, 0);
-  if (length == 0)
-    return GetLastError();
-  buffer_.resize(length);
-  length = WideCharToMultiByte(
-    CP_UTF8, 0, s.c_str(), -1, &buffer_[0], length, 0, 0);
-  if (length == 0)
-    return GetLastError();
-  return 0;
+    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, StringRef 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());
+    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());
 }
 
-#endif
-
-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(...) {}
-  format_error_code(out, error_code, message);
-}
-
-#ifdef _WIN32
 FMT_FUNC void fmt::internal::format_windows_error(
     fmt::Writer &out, int error_code,
-    fmt::StringRef message) FMT_NOEXCEPT {
-  class String {
-   private:
-    LPWSTR str_;
+    fmt::StringRef message) FMT_NOEXCEPT{
+    class String {
+    private:
+        LPWSTR str_;
 
-   public:
-    String() : str_() {}
-    ~String() { LocalFree(str_); }
-    LPWSTR *ptr() { return &str_; }
-    LPCWSTR c_str() const { return str_; }
-  };
-  FMT_TRY {
-    String system_message;
-    if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+    public:
+        String() : str_() {}
+        ~String() {
+            LocalFree(str_);
+        }
+        LPWSTR *ptr() {
+            return &str_;
+        }
+        LPCWSTR c_str() const { return str_; }
+    };
+    FMT_TRY{
+        String system_message;
+        if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
         FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
         error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
         reinterpret_cast<LPWSTR>(system_message.ptr()), 0, 0)) {
-      UTF16ToUTF8 utf8_message;
-      if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) {
-        out << message << ": " << utf8_message;
-        return;
-      }
-    }
-  } FMT_CATCH(...) {}
-  format_error_code(out, error_code, message);
+            UTF16ToUTF8 utf8_message;
+            if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) {
+                out << message << ": " << utf8_message;
+                return;
+            }
+        }
+    } FMT_CATCH(...) {}
+    format_error_code(out, error_code, message);
+}
+
+#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(...) {}
+    format_error_code(out, error_code, message);
 }
-#endif
 
-// An argument formatter.
 template <typename Char>
-class fmt::internal::ArgFormatter :
-    public fmt::internal::ArgVisitor<fmt::internal::ArgFormatter<Char>, void> {
- private:
-  fmt::BasicFormatter<Char> &formatter_;
-  fmt::BasicWriter<Char> &writer_;
-  fmt::FormatSpec &spec_;
-  const Char *format_;
-
-  FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatter);
-
- public:
-  ArgFormatter(
-      fmt::BasicFormatter<Char> &f,fmt::FormatSpec &s, const Char *fmt)
-  : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {}
-
-  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_char(int value) {
-    if (spec_.type_ && spec_.type_ != 'c') {
-      spec_.flags_ |= CHAR_FLAG;
-      writer_.write_int(value, spec_);
-      return;
+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_.insert(Pair(named_arg->name, *named_arg));
+                break;
+            default:
+                /*nothing*/
+                ;
+            }
+        }
+        return;
     }
-    if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
-      FMT_THROW(FormatError("invalid format specifier for char"));
-    typedef typename fmt::BasicWriter<Char>::CharPtr CharPtr;
-    Char fill = static_cast<Char>(spec_.fill());
-    if (spec_.precision_ == 0) {
-      std::fill_n(writer_.grow_buffer(spec_.width_), spec_.width_, fill);
-      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_.insert(Pair(named_arg->name, *named_arg));
+        }
     }
-    CharPtr out = CharPtr();
-    if (spec_.width_ > 1) {
-      out = writer_.grow_buffer(spec_.width_);
-      if (spec_.align_ == fmt::ALIGN_RIGHT) {
-        std::fill_n(out, spec_.width_ - 1, fill);
-        out += spec_.width_ - 1;
-      } else if (spec_.align_ == fmt::ALIGN_CENTER) {
-        out = writer_.fill_padding(out, spec_.width_, 1, fill);
-      } else {
-        std::fill_n(out + 1, spec_.width_ - 1, fill);
-      }
-    } else {
-      out = writer_.grow_buffer(1);
+    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_.insert(Pair(named_arg->name, *named_arg));
+            break;
+        default:
+            /*nothing*/
+            ;
+        }
     }
-    *out = static_cast<Char>(value);
-  }
-
-  void visit_string(Arg::StringValue<char> value) {
-    writer_.write_str(value, spec_);
-  }
-  void visit_wstring(Arg::StringValue<wchar_t> value) {
-    writer_.write_str(ignore_incompatible_str<Char>(value), spec_);
-  }
-
-  void visit_pointer(const void *value) {
-    if (spec_.type_ && spec_.type_ != 'p')
-      fmt::internal::report_unknown_type(spec_.type_, "pointer");
-    spec_.flags_ = fmt::HASH_FLAG;
-    spec_.type_ = 'x';
-    writer_.write_int(reinterpret_cast<uintptr_t>(value), spec_);
-  }
-
-  void visit_custom(Arg::CustomValue c) {
-    c.format(&formatter_, c.value, &format_);
-  }
-};
+}
 
 template <typename Char>
 void fmt::internal::FixedBuffer<Char>::grow(std::size_t) {
-  FMT_THROW(std::runtime_error("buffer overflow"));
+    FMT_THROW(std::runtime_error("buffer overflow"));
 }
 
 template <typename Char>
 template <typename StrChar>
 void fmt::BasicWriter<Char>::write_str(
     const 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"));
-    if (*str_value)
-      str_size = std::char_traits<StrChar>::length(str_value);
-  }
-  std::size_t precision = spec.precision_;
-  if (spec.precision_ >= 0 && precision < str_size)
-    str_size = spec.precision_;
-  write_str(str_value, str_size, 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"));
+        if (*str_value)
+            str_size = std::char_traits<StrChar>::length(str_value);
+    }
+    std::size_t precision = spec.precision_;
+    if (spec.precision_ >= 0 && precision < str_size)
+        str_size = spec.precision_;
+    write_str(str_value, str_size, spec);
+}
+
+template <typename Char>
+inline Arg fmt::BasicFormatter<Char>::get_arg(
+    BasicStringRef<Char> arg_name, const char *&error) {
+    if (check_no_auto_index(error)) {
+        map_.init(args());
+        const Arg *arg = map_.find(arg_name);
+        if (arg)
+            return *arg;
+        error = "argument not found";
+    }
+    return Arg();
 }
 
 template <typename Char>
 inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
-  const char *error = 0;
-  Arg arg = *s < '0' || *s > '9' ?
-        next_arg(error) : get_arg(parse_nonnegative_int(s), error);
-  if (error) {
-    FMT_THROW(FormatError(
-                *s != '}' && *s != ':' ? "invalid format string" : error));
-  }
-  return arg;
+    const char *error = 0;
+    Arg arg = *s < '0' || *s > '9' ?
+              next_arg(error) : get_arg(parse_nonnegative_int(s), error);
+    if (error) {
+        FMT_THROW(FormatError(
+                      *s != '}' && *s != ':' ? "invalid format string" : error));
+    }
+    return arg;
+}
+
+template <typename Char>
+inline Arg fmt::BasicFormatter<Char>::parse_arg_name(const Char *&s) {
+    assert(is_name_start(*s));
+    const Char *start = s;
+    Char c;
+    do {
+        c = *++s;
+    } while (is_name_start(c) || ('0' <= c && c <= '9'));
+    const char *error = 0;
+    Arg arg = get_arg(fmt::BasicStringRef<Char>(start, s - start), error);
+    if (error)
+        FMT_THROW(fmt::FormatError(error));
+    return arg;
 }
 
 FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
     unsigned arg_index, const char *&error) {
-  Arg arg = args_[arg_index];
-  if (arg.type == Arg::NONE)
-    error = "argument index out of range";
-  return arg;
+    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);
+    default:
+        /*nothing*/
+        ;
+    }
+    return arg;
 }
 
 inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) {
-  if (next_arg_index_ >= 0)
-    return do_get_arg(next_arg_index_++, error);
-  error = "cannot switch from manual to automatic argument indexing";
-  return Arg();
+    if (next_arg_index_ >= 0)
+        return do_get_arg(next_arg_index_++, error);
+    error = "cannot switch from manual to automatic argument indexing";
+    return Arg();
+}
+
+inline bool fmt::internal::FormatterBase::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;
 }
 
 inline Arg fmt::internal::FormatterBase::get_arg(
     unsigned arg_index, const char *&error) {
-  if (next_arg_index_ <= 0) {
-    next_arg_index_ = -1;
-    return do_get_arg(arg_index, error);
-  }
-  error = "cannot switch from automatic to manual argument indexing";
-  return Arg();
+    return check_no_auto_index(error) ? do_get_arg(arg_index, error) : 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;
+    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;
+    (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;
-      }
+    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;
+    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, BasicStringRef<Char> format_str,
+    BasicWriter<Char> &writer, BasicCStringRef<Char> format_str,
     const ArgList &args) {
-  const Char *start = format_str.c_str();
-  set_args(args);
-  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_ = 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_ &= ~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<size_t>(arg, *s).visit(arg);
-      break;
-    case 't':
-      ArgConverter<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<int>(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.
-    switch (arg.type) {
-    case Arg::INT:
-      writer.write_int(arg.int_value, spec);
-      break;
-    case Arg::UINT:
-      writer.write_int(arg.uint_value, spec);
-      break;
-    case Arg::LONG_LONG:
-      writer.write_int(arg.long_long_value, spec);
-      break;
-    case Arg::ULONG_LONG:
-      writer.write_int(arg.ulong_long_value, spec);
-      break;
-    case Arg::CHAR: {
-      if (spec.type_ && spec.type_ != 'c')
-        writer.write_int(arg.int_value, spec);
-      typedef typename BasicWriter<Char>::CharPtr CharPtr;
-      CharPtr out = CharPtr();
-      if (spec.width_ > 1) {
-        Char fill = ' ';
-        out = writer.grow_buffer(spec.width_);
-        if (spec.align_ != ALIGN_LEFT) {
-          std::fill_n(out, spec.width_ - 1, fill);
-          out += spec.width_ - 1;
-        } else {
-          std::fill_n(out + 1, spec.width_ - 1, fill);
+    const Char *start = format_str.c_str();
+    set_args(args);
+    const Char *s = start;
+    while (*s) {
+        Char c = *s++;
+        if (c != '%') continue;
+        if (*s == c) {
+            write(writer, start, s);
+            start = ++s;
+            continue;
         }
-      } else {
-        out = writer.grow_buffer(1);
-      }
-      *out = static_cast<Char>(arg.int_value);
-      break;
+        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_ = 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_ &= ~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<size_t>(arg, *s).visit(arg);
+            break;
+        case 't':
+            ArgConverter<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<int>(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);
     }
-    case Arg::DOUBLE:
-      writer.write_double(arg.double_value, spec);
-      break;
-    case Arg::LONG_DOUBLE:
-      writer.write_double(arg.long_double_value, spec);
-      break;
-    case Arg::CSTRING:
-      arg.string.size = 0;
-      writer.write_str(arg.string, spec);
-      break;
-    case Arg::STRING:
-      writer.write_str(arg.string, spec);
-      break;
-    case Arg::WSTRING:
-      writer.write_str(ignore_incompatible_str<Char>(arg.wstring), spec);
-      break;
-    case Arg::POINTER:
-      if (spec.type_ && spec.type_ != 'p')
-        internal::report_unknown_type(spec.type_, "pointer");
-      spec.flags_= HASH_FLAG;
-      spec.type_ = 'x';
-      writer.write_int(reinterpret_cast<uintptr_t>(arg.pointer), spec);
-      break;
-    case Arg::CUSTOM: {
-      if (spec.type_)
-        internal::report_unknown_type(spec.type_, "object");
-      const void *str_format = "s";
-      arg.custom.format(&writer, arg.custom.value, &str_format);
-      break;
-    }
-    default:
-      assert(false);
-      break;
-    }
-  }
-  write(writer, start, s);
+    write(writer, start, s);
 }
 
 template <typename Char>
 const Char *fmt::BasicFormatter<Char>::format(
     const Char *&format_str, const Arg &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;
+    const Char *s = format_str;
+    FormatSpec spec;
+    if (*s == ':') {
+        if (arg.type == Arg::CUSTOM) {
+            arg.custom.format(this, arg.custom.value, &s);
+            return s;
         }
-        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 width and zero flag.
-    if ('0' <= *s && *s <= '9') {
-      if (*s == '0') {
-        require_numeric_argument(arg, '0');
-        spec.align_ = ALIGN_NUMERIC;
-        spec.fill_ = '0';
-      }
-      // Zero may be parsed again as a part of the width, but it is simpler
-      // and more efficient than checking if the next char is a digit.
-      spec.width_ = parse_nonnegative_int(s);
-    }
-
-    // Parse precision.
-    if (*s == '.') {
-      ++s;
-      spec.precision_ = 0;
-      if ('0' <= *s && *s <= '9') {
-        spec.precision_ = parse_nonnegative_int(s);
-      } else if (*s == '{') {
         ++s;
-        const Arg &precision_arg = 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"));
+        // 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);
         }
-        if (value > 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 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_ = parse_nonnegative_int(s);
+        }
+        else if (*s == '{') {
+            ++s;
+            Arg width_arg = 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 > 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_ = parse_nonnegative_int(s);
+            }
+            else if (*s == '{') {
+                ++s;
+                Arg precision_arg =
+                    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 > 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++);
     }
 
-    // Parse type.
-    if (*s != '}' && *s)
-      spec.type_ = static_cast<char>(*s++);
-  }
+    if (*s++ != '}')
+        FMT_THROW(FormatError("missing '}' in format string"));
+    start_ = s;
 
-  if (*s++ != '}')
-    FMT_THROW(FormatError("missing '}' in format string"));
-  start_ = s;
-
-  // Format argument.
-  internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg);
-  return s;
+    // Format argument.
+    internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg);
+    return s;
 }
 
 template <typename Char>
 void fmt::BasicFormatter<Char>::format(
-    BasicStringRef<Char> format_str, const ArgList &args) {
-  const Char *s = start_ = format_str.c_str();
-  set_args(args);
-  while (*s) {
-    Char c = *s++;
-    if (c != '{' && c != '}') continue;
-    if (*s == c) {
-      write(writer_, start_, s);
-      start_ = ++s;
-      continue;
+    BasicCStringRef<Char> format_str, const ArgList &args) {
+    const Char *s = start_ = format_str.c_str();
+    set_args(args);
+    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);
+        Arg arg = is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
+        s = format(s, arg);
     }
-    if (c == '}')
-      FMT_THROW(FormatError("unmatched '}' in format string"));
-    write(writer_, start_, s - 1);
-    Arg arg = parse_arg_index(s);
-    s = format(s, arg);
-  }
-  write(writer_, start_, s);
+    write(writer_, start_, s);
 }
 
 FMT_FUNC void fmt::report_system_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
-  report_error(internal::format_system_error, error_code, message);
+    int error_code, fmt::StringRef message) FMT_NOEXCEPT{
+    report_error(internal::format_system_error, error_code, message);
 }
 
-#ifdef _WIN32
+#if FMT_USE_WINDOWS_H
 FMT_FUNC void fmt::report_windows_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
-  report_error(internal::format_windows_error, error_code, message);
+    int error_code, fmt::StringRef message) FMT_NOEXCEPT{
+    report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-FMT_FUNC void fmt::print(std::FILE *f, StringRef format_str, ArgList args) {
-  MemoryWriter w;
-  w.write(format_str, args);
-  std::fwrite(w.data(), 1, w.size(), f);
+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(StringRef format_str, ArgList args) {
-  print(stdout, format_str, args);
+FMT_FUNC void fmt::print(CStringRef format_str, ArgList args) {
+    print(stdout, format_str, args);
 }
 
-FMT_FUNC void fmt::print(std::ostream &os, StringRef format_str, ArgList args) {
-  MemoryWriter w;
-  w.write(format_str, args);
-  os.write(w.data(), w.size());
+FMT_FUNC void fmt::print(std::ostream &os, CStringRef format_str, ArgList args) {
+    MemoryWriter w;
+    w.write(format_str, args);
+    os.write(w.data(), w.size());
 }
 
-FMT_FUNC void fmt::print_colored(Color c, StringRef format, ArgList args) {
-  char escape[] = "\x1b[30m";
-  escape[3] = '0' + static_cast<char>(c);
-  std::fputs(escape, stdout);
-  print(format, args);
-  std::fputs(RESET_COLOR, stdout);
+FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
+    char escape[] = "\x1b[30m";
+    escape[3] = '0' + static_cast<char>(c);
+    std::fputs(escape, stdout);
+    print(format, args);
+    std::fputs(RESET_COLOR, stdout);
 }
 
-FMT_FUNC int fmt::fprintf(std::FILE *f, StringRef 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::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);
 }
 
 #ifndef FMT_HEADER_ONLY
 
+template struct fmt::internal::BasicData<void>;
+
 // Explicit instantiations for char.
 
 template void fmt::internal::FixedBuffer<char>::grow(std::size_t);
@@ -1165,10 +1311,10 @@ template const char *fmt::BasicFormatter<char>::format(
     const char *&format_str, const fmt::internal::Arg &arg);
 
 template void fmt::BasicFormatter<char>::format(
-  BasicStringRef<char> format, const ArgList &args);
+    CStringRef format, const ArgList &args);
 
 template void fmt::internal::PrintfFormatter<char>::format(
-  BasicWriter<char> &writer, BasicStringRef<char> format, const ArgList &args);
+    BasicWriter<char> &writer, CStringRef format, const ArgList &args);
 
 template int fmt::internal::CharTraits<char>::format_float(
     char *buffer, std::size_t size, const char *format,
@@ -1186,10 +1332,10 @@ template const wchar_t *fmt::BasicFormatter<wchar_t>::format(
     const wchar_t *&format_str, const fmt::internal::Arg &arg);
 
 template void fmt::BasicFormatter<wchar_t>::format(
-    BasicStringRef<wchar_t> format, const ArgList &args);
+    BasicCStringRef<wchar_t> format, const ArgList &args);
 
 template void fmt::internal::PrintfFormatter<wchar_t>::format(
-    BasicWriter<wchar_t> &writer, BasicStringRef<wchar_t> format,
+    BasicWriter<wchar_t> &writer, WCStringRef format,
     const ArgList &args);
 
 template int fmt::internal::CharTraits<wchar_t>::format_float(
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index 0e63d8e9..7ec3b390 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -1,29 +1,29 @@
 /*
- Formatting library for C++
+Formatting library for C++
 
- Copyright (c) 2012 - 2015, Victor Zverovich
- All rights reserved.
+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:
+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.
+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.
- */
+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_
@@ -41,6 +41,7 @@
 #include <stdexcept>
 #include <string>
 #include <sstream>
+#include <map>
 
 #if _SECURE_SCL
 # include <iterator>
@@ -53,9 +54,9 @@ namespace fmt {
 namespace internal {
 # pragma intrinsic(_BitScanReverse)
 inline uint32_t clz(uint32_t x) {
-  unsigned long r = 0;
-  _BitScanReverse(&r, x);
-  return 31 - r;
+    unsigned long r = 0;
+    _BitScanReverse(&r, x);
+    return 31 - r;
 }
 # define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
 
@@ -64,18 +65,18 @@ inline uint32_t clz(uint32_t x) {
 # endif
 
 inline uint32_t clzll(uint64_t x) {
-  unsigned long r = 0;
+    unsigned long r = 0;
 # ifdef _WIN64
-  _BitScanReverse64(&r, x);
+    _BitScanReverse64(&r, x);
 # else
-  // Scan the high 32 bits.
-  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
-    return 63 - (r + 32);
+    // 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));
+    // Scan the low 32 bits.
+    _BitScanReverse(&r, static_cast<uint32_t>(x));
 # endif
-  return 63 - r;
+    return 63 - r;
 }
 # define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
 }
@@ -154,26 +155,34 @@ inline uint32_t clzll(uint64_t x) {
 #endif
 
 // Define FMT_USE_NOEXCEPT to make C++ Format use noexcept (C++11 feature).
-#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
-  (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11)
-# define FMT_NOEXCEPT noexcept
-#else
-# define FMT_NOEXCEPT throw()
+#ifndef FMT_NOEXCEPT
+# if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
+   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11)
+#  define FMT_NOEXCEPT noexcept
+# else
+#  define FMT_NOEXCEPT throw()
+# endif
 #endif
 
 // A macro to disallow the copy constructor and operator= functions
 // This should be used in the private: declarations for a class
 #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_ASSERT
+# define FMT_ASSERT(condition, message) assert((condition) && message)
+#endif
+
 namespace fmt {
 
 // Fix the warning about long long on older versions of GCC
@@ -198,90 +207,148 @@ 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:
+\rst
+A string reference. It can be constructed from a C string or ``std::string``.
 
-  +------------+-------------------------+
-  | Type       | Definition              |
-  +============+=========================+
-  | StringRef  | BasicStringRef<char>    |
-  +------------+-------------------------+
-  | WStringRef | BasicStringRef<wchar_t> |
-  +------------+-------------------------+
+You can use one of the following typedefs for common character types:
 
-  This class is most useful as a parameter type to allow passing
-  different types of strings to a function, for example::
++------------+-------------------------+
+| Type       | Definition              |
++============+=========================+
+| StringRef  | BasicStringRef<char>    |
++------------+-------------------------+
+| WStringRef | BasicStringRef<wchar_t> |
++------------+-------------------------+
 
-    template <typename... Args>
-    std::string format(StringRef format_str, const Args & ... args);
+This class is most useful as a parameter type to allow passing
+different types of strings to a function, for example::
 
-    format("{}", 42);
-    format(std::string("{}"), 42);
-  \endrst
- */
+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_;
+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) {}
+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``.
-   */
-  BasicStringRef(const Char *s)
-    : data_(s), size_(std::char_traits<Char>::length(s)) {}
+    \endrst
+    */
+    BasicStringRef(const Char *s)
+        : data_(s), size_(std::char_traits<Char>::length(s)) {}
 
-  /**
-    Constructs a string reference from an `std::string` object.
-   */
-  BasicStringRef(const std::basic_string<Char> &s)
-  : data_(s.c_str()), size_(s.size()) {}
+    /**
+    \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()) {}
 
-  /**
-    Converts a string reference to an `std::string` object.
-   */
-  operator std::basic_string<Char>() const {
-    return std::basic_string<Char>(data_, 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 the pointer to a C string.
-   */
-  const Char *c_str() const { return data_; }
+    /** Returns the pointer to a C string. */
+    const Char *data() const {
+        return data_;
+    }
 
-  /**
-    Returns the string size.
-   */
-  std::size_t size() const { return size_; }
+    /** Returns the string size. */
+    std::size_t size() const {
+        return size_;
+    }
 
-  friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.data_ == rhs.data_;
-  }
-  friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.data_ != rhs.data_;
-  }
+    friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
+        return lhs.data_ == rhs.data_;
+    }
+    friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
+        return lhs.data_ != rhs.data_;
+    }
+    friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
+        return std::lexicographical_compare(
+                   lhs.data_, lhs.data_ + lhs.size_, rhs.data_, rhs.data_ + rhs.size_);
+    }
 };
 
 typedef BasicStringRef<char> StringRef;
 typedef BasicStringRef<wchar_t> WStringRef;
 
+
 /**
-  A formatting error such as invalid format string.
+\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(StringRef message)
-  : std::runtime_error(message.c_str()) {}
+public:
+    explicit FormatError(CStringRef message)
+        : std::runtime_error(message.c_str()) {}
 };
 
 namespace internal {
@@ -293,80 +360,102 @@ enum { INLINE_BUFFER_SIZE = 500 };
 // 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);
+    return stdext::checked_array_iterator<T*>(ptr, size);
 }
 #else
 template <typename T>
-inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
+inline T *make_ptr(T *ptr, std::size_t) {
+    return ptr;
+}
 #endif
 }  // namespace internal
 
-/** A buffer supporting a subset of ``std::vector``'s operations. */
+/**
+\rst
+A buffer supporting a subset of ``std::vector``'s operations.
+\endrst
+*/
 template <typename T>
 class Buffer {
- private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
+private:
+    FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
 
- protected:
-  T *ptr_;
-  std::size_t size_;
-  std::size_t capacity_;
+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) {}
+    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_``.
-   */
-  virtual void grow(std::size_t size) = 0;
+    \endrst
+    */
+    virtual void grow(std::size_t size) = 0;
 
- public:
-  virtual ~Buffer() {}
+public:
+    virtual ~Buffer() {}
 
-  /** Returns the size of this buffer. */
-  std::size_t size() const { return size_; }
+    /** 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_; }
+    /** 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;
-  }
+    */
+    void resize(std::size_t new_size) {
+        if (new_size > capacity_)
+            grow(new_size);
+        size_ = new_size;
+    }
 
-  /** Reserves space to store at least *capacity* elements. */
-  void reserve(std::size_t capacity) {
-    if (capacity > capacity_)
-      grow(capacity);
-  }
+    /**
+    \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 clear() FMT_NOEXCEPT{ size_ = 0; }
 
-  void push_back(const T &value) {
-    if (size_ == capacity_)
-      grow(size_ + 1);
-    ptr_[size_++] = value;
-  }
+    void push_back(const T &value) {
+        if (size_ == capacity_)
+            grow(size_ + 1);
+        ptr_[size_++] = value;
+    }
 
-  /** Appends data to the end of the buffer. */
-  void append(const T *begin, const T *end);
+    /** 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]; }
+    T &operator[](std::size_t index) {
+        return ptr_[index];
+    }
+    const T &operator[](std::size_t index) const {
+        return ptr_[index];
+    }
 };
 
 template <typename T>
-void Buffer<T>::append(const T *begin, const T *end) {
-  std::ptrdiff_t num_elements = end - begin;
-  if (size_ + num_elements > capacity_)
-    grow(size_ + num_elements);
-  std::copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_);
-  size_ += num_elements;
+template <typename U>
+void Buffer<T>::append(const U *begin, const U *end) {
+    std::ptrdiff_t num_elements = end - begin;
+    if (size_ + num_elements > capacity_)
+        grow(size_ + num_elements);
+    std::copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_);
+    size_ += num_elements;
 }
 
 namespace internal {
@@ -375,129 +464,149 @@ namespace internal {
 // 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];
+private:
+    T data_[SIZE];
 
-  // Free memory allocated by the buffer.
-  void free() {
-    if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_);
-  }
+    // Free memory allocated by the buffer.
+    void free() {
+        if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_);
+    }
 
- protected:
-  void grow(std::size_t size);
+protected:
+    void grow(std::size_t size);
 
- public:
-  explicit MemoryBuffer(const Allocator &alloc = Allocator())
-      : Allocator(alloc), Buffer<T>(data_, SIZE) {}
-  ~MemoryBuffer() { free(); }
+public:
+    explicit MemoryBuffer(const Allocator &alloc = Allocator())
+        : Allocator(alloc), Buffer<T>(data_, SIZE) {}
+    ~MemoryBuffer() {
+        free();
+    }
 
 #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::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 freeing.
-      other.ptr_ = other.data_;
+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::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 freeing.
+            other.ptr_ = other.data_;
+        }
     }
-  }
 
- public:
-  MemoryBuffer(MemoryBuffer &&other) {
-    move(other);
-  }
+public:
+    MemoryBuffer(MemoryBuffer &&other) {
+        move(other);
+    }
 
-  MemoryBuffer &operator=(MemoryBuffer &&other) {
-    assert(this != &other);
-    free();
-    move(other);
-    return *this;
-  }
+    MemoryBuffer &operator=(MemoryBuffer &&other) {
+        assert(this != &other);
+        free();
+        move(other);
+        return *this;
+    }
 #endif
 
-  // Returns a copy of the allocator associated with this buffer.
-  Allocator get_allocator() const { return *this; }
+    // 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 =
-      (std::max)(size, this->capacity_ + this->capacity_ / 2);
-  T *new_ptr = this->allocate(new_capacity);
-  // The following code doesn't throw, so the raw pointer above doesn't leak.
-  std::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_)
-    this->deallocate(old_ptr, old_capacity);
+    std::size_t new_capacity =
+        (std::max)(size, this->capacity_ + this->capacity_ / 2);
+    T *new_ptr = this->allocate(new_capacity);
+    // The following code doesn't throw, so the raw pointer above doesn't leak.
+    std::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_)
+        this->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) {}
+public:
+    FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
 
- protected:
-  void grow(std::size_t size);
+protected:
+    void grow(std::size_t size);
 };
 
 #ifndef _MSC_VER
 // Portable version of signbit.
 inline int getsign(double x) {
-  // When compiled in C++11 mode signbit is no longer a macro but a function
-  // defined in namespace std and the macro is undefined.
+    // When compiled in C++11 mode signbit is no longer a macro but a function
+    // defined in namespace std and the macro is undefined.
 # ifdef signbit
-  return signbit(x);
+    return signbit(x);
 # else
-  return std::signbit(x);
+    return std::signbit(x);
 # endif
 }
 
 // Portable version of isinf.
 # ifdef isinf
-inline int isinfinity(double x) { return isinf(x); }
-inline int isinfinity(long double x) { return isinf(x); }
+inline int isinfinity(double x) {
+    return isinf(x);
+}
+inline int isinfinity(long double x) {
+    return isinf(x);
+}
 # else
-inline int isinfinity(double x) { return std::isinf(x); }
-inline int isinfinity(long double x) { return std::isinf(x); }
+inline int isinfinity(double x) {
+    return std::isinf(x);
+}
+inline int isinfinity(long double x) {
+    return std::isinf(x);
+}
 # endif
 #else
 inline int getsign(double value) {
-  if (value < 0) return 1;
-  if (value == value) return 0;
-  int dec = 0, sign = 0;
-  char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
-  _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign);
-  return sign;
+    if (value < 0) return 1;
+    if (value == value) return 0;
+    int dec = 0, sign = 0;
+    char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
+    _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign);
+    return sign;
+}
+inline int isinfinity(double x) {
+    return !_finite(x);
+}
+inline int isinfinity(long double x) {
+    return !_finite(static_cast<double>(x));
 }
-inline int isinfinity(double x) { return !_finite(x); }
-inline int isinfinity(long double x) { return !_finite(static_cast<double>(x)); }
 #endif
 
 template <typename Char>
 class BasicCharTraits {
- public:
+public:
 #if _SECURE_SCL
-  typedef stdext::checked_array_iterator<Char*> CharPtr;
+    typedef stdext::checked_array_iterator<Char*> CharPtr;
 #else
-  typedef Char *CharPtr;
+    typedef Char *CharPtr;
 #endif
+    static Char cast(wchar_t value) {
+        return static_cast<Char>(value);
+    }
 };
 
 template <typename Char>
@@ -505,68 +614,84 @@ class CharTraits;
 
 template <>
 class CharTraits<char> : public BasicCharTraits<char> {
- private:
-  // Conversion from wchar_t to char is not allowed.
-  static char convert(wchar_t);
+private:
+    // Conversion from wchar_t to char is not allowed.
+    static char convert(wchar_t);
 
 public:
-  static char convert(char value) { return value; }
+    static char convert(char value) {
+        return value;
+    }
 
-  // Formats a floating-point number.
-  template <typename T>
-  static int format_float(char *buffer, std::size_t size,
-      const char *format, unsigned width, int precision, T value);
+    // Formats a floating-point number.
+    template <typename T>
+    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; }
+public:
+    static wchar_t convert(char value) {
+        return value;
+    }
+    static wchar_t convert(wchar_t value) {
+        return value;
+    }
 
-  template <typename T>
-  static int format_float(wchar_t *buffer, std::size_t size,
-      const wchar_t *format, unsigned width, int precision, T value);
+    template <typename T>
+    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 <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; }
+    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);
+    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; };
+struct TypeSelector {
+    typedef uint32_t Type;
+};
 
 template <>
-struct TypeSelector<false> { typedef uint64_t Type; };
+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
+    // 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;
 };
 
 // MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
 template <typename T>
-struct MakeUnsigned { typedef T Type; };
+struct MakeUnsigned {
+    typedef T Type;
+};
 
 #define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
   template <> \
@@ -585,9 +710,9 @@ void report_unknown_type(char code, const char *type);
 // configuration.
 template <typename T = void>
 struct BasicData {
-  static const uint32_t POWERS_OF_10_32[];
-  static const uint64_t POWERS_OF_10_64[];
-  static const char DIGITS[];
+    static const uint32_t POWERS_OF_10_32[];
+    static const uint64_t POWERS_OF_10_64[];
+    static const char DIGITS[];
 };
 
 typedef BasicData<> Data;
@@ -604,188 +729,206 @@ typedef BasicData<> Data;
 // 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.
-  unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-  return t - (n < Data::POWERS_OF_10_64[t]) + 1;
+    // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
+    // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
+    unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
+    return 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;
-  }
+    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) {
-  uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
-  return t - (n < Data::POWERS_OF_10_32[t]) + 1;
+    uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
+    return 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) {
-  --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 = (value % 100) * 2;
-    value /= 100;
-    buffer[num_digits] = Data::DIGITS[index + 1];
-    buffer[num_digits - 1] = Data::DIGITS[index];
-    num_digits -= 2;
-  }
-  if (value < 10) {
-    *buffer = static_cast<char>('0' + value);
-    return;
-  }
-  unsigned index = static_cast<unsigned>(value * 2);
-  buffer[1] = Data::DIGITS[index + 1];
-  buffer[0] = Data::DIGITS[index];
+    --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 = (value % 100) * 2;
+        value /= 100;
+        buffer[num_digits] = Data::DIGITS[index + 1];
+        buffer[num_digits - 1] = Data::DIGITS[index];
+        num_digits -= 2;
+    }
+    if (value < 10) {
+        *buffer = static_cast<char>('0' + value);
+        return;
+    }
+    unsigned index = static_cast<unsigned>(value * 2);
+    buffer[1] = Data::DIGITS[index + 1];
+    buffer[0] = Data::DIGITS[index];
 }
 
-#ifdef _WIN32
+#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_;
+private:
+    MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
 
- public:
-  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()); }
+public:
+    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_;
+private:
+    MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
 
- public:
-  UTF16ToUTF8() {}
-  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()); }
+public:
+    UTF16ToUTF8() {}
+    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.
-  int convert(WStringRef s);
+    // 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.
+    int convert(WStringRef s);
 };
+
+void format_windows_error(fmt::Writer &out, int error_code,
+                          fmt::StringRef message) FMT_NOEXCEPT;
 #endif
 
 void format_system_error(fmt::Writer &out, int error_code,
                          fmt::StringRef message) FMT_NOEXCEPT;
 
-#ifdef _WIN32
-void format_windows_error(fmt::Writer &out, int error_code,
-                          fmt::StringRef message) FMT_NOEXCEPT;
-#endif
-
-// Computes max(N, 1) at compile time. It is used to avoid errors about
-// allocating an array of 0 size.
-template <unsigned N>
-struct NonZero {
-  enum { VALUE = N > 0 ? N : 1 };
-};
-
 // A formatting argument value.
 struct Value {
-  template <typename Char>
-  struct StringValue {
-    const Char *value;
-    std::size_t size;
-  };
+    template <typename Char>
+    struct StringValue {
+        const Char *value;
+        std::size_t size;
+    };
 
-  typedef void (*FormatFunc)(
-      void *formatter, const void *arg, void *format_str_ptr);
+    typedef void(*FormatFunc)(
+        void *formatter, const void *arg, void *format_str_ptr);
 
-  struct CustomValue {
-    const void *value;
-    FormatFunc format;
-  };
+    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;
-  };
+    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,
-    // Integer types should go first,
-    INT, UINT, LONG_LONG, ULONG_LONG, CHAR, LAST_INTEGER_TYPE = CHAR,
-    // followed by floating-point types.
-    DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
-    CSTRING, STRING, WSTRING, POINTER, 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 POD type to allow storage in
 // internal::MemoryBuffer.
 struct Arg : Value {
-  Type type;
+    Type type;
 };
 
+template <typename Char>
+struct NamedArg;
+
 template <typename T = void>
-struct None {};
+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 None<T> Supported;
-  typedef T Unsupported;
+    typedef Null<T> Supported;
+    typedef T Unsupported;
 };
 
 template <typename T>
 struct WCharHelper<T, wchar_t> {
-  typedef T Supported;
-  typedef None<T> Unsupported;
+    typedef T Supported;
+    typedef Null<T> Unsupported;
 };
 
 template <typename T>
 class IsConvertibleToInt {
- private:
-  typedef char yes[1];
-  typedef char no[2];
+private:
+    typedef char yes[1];
+    typedef char no[2];
 
-  static const T &get();
+    static const T &get();
 
-  static yes &check(fmt::ULongLong);
-  static no &check(...);
-  
- public:
-  enum { value = (sizeof(check(get())) == sizeof(yes)) };
+    static yes &check(fmt::ULongLong);
+    static no &check(...);
+
+public:
+    enum { value = (sizeof(check(get())) == sizeof(yes)) };
 };
 
 #define FMT_CONVERTIBLE_TO_INT(Type) \
@@ -793,7 +936,7 @@ class IsConvertibleToInt {
   class IsConvertibleToInt<Type> { \
    public: \
     enum { value = 1 }; \
-  }
+          }
 
 // Silence warnings about convering float to int.
 FMT_CONVERTIBLE_TO_INT(float);
@@ -804,153 +947,190 @@ template<bool B, class T = void>
 struct EnableIf {};
 
 template<class T>
-struct EnableIf<true, T> { typedef T type; };
+struct EnableIf<true, T> {
+    typedef T type;
+};
 
 template<bool B, class T, class F>
-struct Conditional { typedef T type; };
+struct Conditional {
+    typedef T type;
+};
 
 template<class T, class F>
-struct Conditional<false, T, F> { typedef F type; };
+struct Conditional<false, T, F> {
+    typedef F type;
+};
 
 // A helper function to suppress bogus "conditional expression is constant"
 // warnings.
-inline bool check(bool value) { return value; }
+inline bool check(bool value) {
+    return value;
+}
 
 // Makes an Arg object from any type.
 template <typename Char>
 class MakeValue : public Arg {
- 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);
+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").
-  MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
-  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);
+    // 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").
+    MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
+    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.c_str();
-    string.size = str.size();
-  }
+    void set_string(StringRef str) {
+        string.value = str.data();
+        string.size = str.size();
+    }
 
-  void set_string(WStringRef str) {
-    wstring.value = str.c_str();
-    wstring.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<BasicFormatter<Char>*>(formatter),
-           *static_cast<const Char**>(format_str_ptr),
-           *static_cast<const T*>(arg));
-  }
+    // 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<BasicFormatter<Char>*>(formatter),
+               *static_cast<const Char**>(format_str_ptr),
+               *static_cast<const T*>(arg));
+    }
 
- public:
-  MakeValue() {}
+public:
+    MakeValue() {}
 
-#define FMT_MAKE_VALUE(Type, field, TYPE) \
-  MakeValue(Type value) { field = value; } \
+#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
+  MakeValue(Type value) { field = rhs; } \
   static uint64_t type(Type) { return Arg::TYPE; }
 
-  FMT_MAKE_VALUE(bool, int_value, INT)
-  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)
+#define FMT_MAKE_VALUE(Type, field, TYPE) \
+  FMT_MAKE_VALUE_(Type, field, TYPE, value)
 
-  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;
-  }
+    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(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;
-  }
+    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;
+    }
 
-  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, CHAR)
-  FMT_MAKE_VALUE(unsigned char, int_value, CHAR)
-  FMT_MAKE_VALUE(char, int_value, CHAR)
+    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;
+    }
 
-  MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
-    int_value = value;
-  }
-  static uint64_t type(wchar_t) { return Arg::CHAR; }
+    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, CHAR)
+    FMT_MAKE_VALUE(unsigned char, int_value, CHAR)
+    FMT_MAKE_VALUE(char, int_value, CHAR)
+
+    MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
+        int_value = value;
+    }
+    static uint64_t type(wchar_t) {
+        return Arg::CHAR;
+    }
 
 #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(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_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)
+    FMT_MAKE_VALUE(void *, pointer, POINTER)
+    FMT_MAKE_VALUE(const void *, pointer, POINTER)
 
-  template <typename T>
-  MakeValue(const T &value,
-            typename EnableIf<!IsConvertibleToInt<T>::value, int>::type = 0) {
-    custom.value = &value;
-    custom.format = &format_custom_arg<T>;
-  }
+    template <typename T>
+    MakeValue(const T &value,
+              typename EnableIf<!IsConvertibleToInt<T>::value, int>::type = 0) {
+        custom.value = &value;
+        custom.format = &format_custom_arg<T>;
+    }
 
-  template <typename T>
-  MakeValue(const T &value,
-            typename EnableIf<IsConvertibleToInt<T>::value, int>::type = 0) {
-    int_value = value;
-  }
+    template <typename T>
+    MakeValue(const T &value,
+              typename EnableIf<IsConvertibleToInt<T>::value, int>::type = 0) {
+        int_value = value;
+    }
 
-  template <typename T>
-  static uint64_t type(const T &) {
-    return IsConvertibleToInt<T>::value ? Arg::INT : Arg::CUSTOM;
-  }
+    template <typename T>
+    static uint64_t type(const T &) {
+        return IsConvertibleToInt<T>::value ? Arg::INT : Arg::CUSTOM;
+    }
+
+    // Additional template param `Char_` is needed here because make_type always
+    // uses MakeValue<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 Char>
+struct NamedArg : Arg {
+    BasicStringRef<Char> name;
+
+    template <typename T>
+    NamedArg(BasicStringRef<Char> name, const T &value)
+        : name(name), Arg(MakeValue<Char>(value)) {
+        type = static_cast<internal::Arg::Type>(MakeValue<Char>::type(value));
+    }
 };
 
 #define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
@@ -977,253 +1157,295 @@ class MakeValue : public Arg {
 // http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
 template <typename Impl, typename Result>
 class ArgVisitor {
- public:
-  void report_unhandled_arg() {}
+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_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_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:
-      assert(false);
-      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::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::CHAR:
-      return FMT_DISPATCH(visit_char(arg.int_value));
-    case Arg::CSTRING: {
-      Arg::StringValue<char> str = arg.string;
-      str.size = 0;
-      return FMT_DISPATCH(visit_string(str));
+    Result visit_unhandled_arg() {
+        FMT_DISPATCH(report_unhandled_arg());
+        return Result();
     }
-    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));
+
+    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_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: {
+            Arg::StringValue<char> str = arg.string;
+            str.size = 0;
+            return FMT_DISPATCH(visit_string(str));
+        }
+        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("") {}
+protected:
+    RuntimeError() : std::runtime_error("") {}
 };
 
+template <typename Impl, typename Char>
+class BasicArgFormatter;
+
 template <typename Char>
-class ArgFormatter;
+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_;
-  };
+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);
-  }
-
- public:
-  // Maximum number of arguments with packed types.
-  enum { MAX_PACKED_ARGS = 16 };
-
-  ArgList() : types_(0) {}
-
-  // TODO: MakeArgList(const Args &...)
-  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;
+    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);
     }
-    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;
+
+    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];
     }
-    for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) {
-      if (args_[i].type == Arg::NONE)
-        return args_[i];
-    }
-    return args_[index];
-  }
 };
 
 struct FormatSpec;
 
 namespace internal {
 
-template <std::size_t NUM_ARGS>
-struct SelectValueType {
-  typedef typename Conditional<
-    (NUM_ARGS < ArgList::MAX_PACKED_ARGS), Value, Arg>::type Type;
+template <typename Char>
+class ArgMap {
+private:
+    typedef std::map<fmt::BasicStringRef<Char>, internal::Arg> MapType;
+    typedef typename MapType::value_type Pair;
+
+    MapType map_;
+
+public:
+    void init(const ArgList &args);
+
+    const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const {
+        typename MapType::const_iterator it = map_.find(name);
+        return it != map_.end() ? &it->second : 0;
+    }
 };
 
 class FormatterBase {
- private:
-  ArgList args_;
-  int next_arg_index_;
+private:
+    ArgList args_;
+    int next_arg_index_;
 
-  // Returns the argument with specified index.
-  Arg do_get_arg(unsigned arg_index, const char *&error);
+    // Returns the argument with specified index.
+    Arg do_get_arg(unsigned arg_index, const char *&error);
 
- protected:
-  void set_args(const ArgList &args) {
-    args_ = args;
-    next_arg_index_ = 0;
-  }
+protected:
+    const ArgList &args() const {
+        return args_;
+    }
 
-  // Returns the next argument.
-  Arg next_arg(const char *&error);
+    void set_args(const ArgList &args) {
+        args_ = args;
+        next_arg_index_ = 0;
+    }
 
-  // Checks if manual indexing is used and returns the argument with
-  // specified index.
-  Arg get_arg(unsigned arg_index, const char *&error);
+    // Returns the next argument.
+    Arg next_arg(const char *&error);
 
-  template <typename Char>
-  void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
-    if (start != end)
-      w << BasicStringRef<Char>(start, end - start);
-  }
+    // Checks if manual indexing is used and returns the argument with
+    // specified index.
+    Arg get_arg(unsigned arg_index, const char *&error);
+
+    bool check_no_auto_index(const char *&error);
+
+    template <typename Char>
+    void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
+        if (start != end)
+            w << BasicStringRef<Char>(start, end - start);
+    }
 };
 
 // A printf formatter.
 template <typename Char>
 class PrintfFormatter : private FormatterBase {
- private:
-  void parse_flags(FormatSpec &spec, const Char *&s);
+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)());
+    // 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);
+    // Parses argument index, flags and width and returns the argument index.
+    unsigned parse_header(const Char *&s, FormatSpec &spec);
 
- public:
-  void format(BasicWriter<Char> &writer,
-    BasicStringRef<Char> format_str, const ArgList &args);
+public:
+    void format(BasicWriter<Char> &writer,
+                BasicCStringRef<Char> format_str, const ArgList &args);
 };
 }  // namespace internal
 
 // A formatter.
 template <typename Char>
 class BasicFormatter : private internal::FormatterBase {
- private:
-  BasicWriter<Char> &writer_;
-  const Char *start_;
-  
-  FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
+private:
+    BasicWriter<Char> &writer_;
+    const Char *start_;
+    internal::ArgMap<Char> map_;
 
-  // Parses argument index and returns corresponding argument.
-  internal::Arg parse_arg_index(const Char *&s);
+    FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
 
- public:
-  explicit BasicFormatter(BasicWriter<Char> &w) : writer_(w) {}
+    using FormatterBase::get_arg;
 
-  BasicWriter<Char> &writer() { return writer_; }
+    // Checks if manual indexing is used and returns the argument with
+    // specified name.
+    internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
 
-  void format(BasicStringRef<Char> format_str, const ArgList &args);
+    // Parses argument index and returns corresponding argument.
+    internal::Arg parse_arg_index(const Char *&s);
 
-  const Char *format(const Char *&format_str, const internal::Arg &arg);
+    // Parses argument name and returns corresponding argument.
+    internal::Arg parse_arg_name(const Char *&s);
+
+public:
+    explicit BasicFormatter(BasicWriter<Char> &w) : writer_(w) {}
+
+    BasicWriter<Char> &writer() {
+        return writer_;
+    }
+
+    void format(BasicCStringRef<Char> format_str, const ArgList &args);
+
+    const Char *format(const Char *&format_str, const internal::Arg &arg);
 };
 
 enum Alignment {
-  ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
+    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.
+    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.
@@ -1232,125 +1454,162 @@ 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 ' '; }
+    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_;
+    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) {}
+    WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
 
-  unsigned width() const { return width_; }
-  wchar_t fill() const { return fill_; }
+    unsigned width() const {
+        return width_;
+    }
+    wchar_t fill() const {
+        return fill_;
+    }
 };
 
 // An alignment specifier.
 struct AlignSpec : WidthSpec {
-  Alignment align_;
+    Alignment align_;
 
-  AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
-  : WidthSpec(width, fill), align_(align) {}
+    AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
+        : WidthSpec(width, fill), align_(align) {}
 
-  Alignment align() const { return align_; }
+    Alignment align() const {
+        return align_;
+    }
 
-  int precision() const { return -1; }
+    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) {}
+    AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
 
-  bool flag(unsigned) const { return false; }
-  char type() const { return TYPE; }
+    bool flag(unsigned) const {
+        return false;
+    }
+    char type() const {
+        return TYPE;
+    }
 };
 
 // A full format specifier.
 struct FormatSpec : AlignSpec {
-  unsigned flags_;
-  int precision_;
-  char type_;
+    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) {}
+    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_; }
+    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_;
+private:
+    T value_;
 
- public:
-  IntFormatSpec(T val, const SpecT &spec = SpecT())
-  : SpecT(spec), value_(val) {}
+public:
+    IntFormatSpec(T val, const SpecT &spec = SpecT())
+        : SpecT(spec), value_(val) {}
 
-  T value() const { return value_; }
+    T value() const {
+        return value_;
+    }
 };
 
 // A string format specifier.
-template <typename T>
+template <typename Char>
 class StrFormatSpec : public AlignSpec {
- private:
-  const T *str_;
+private:
+    const Char *str_;
 
- public:
-  StrFormatSpec(const T *str, unsigned width, wchar_t fill)
-  : AlignSpec(width, fill), str_(str) {}
+public:
+    template <typename FillChar>
+    StrFormatSpec(const Char *str, unsigned width, FillChar fill)
+        : AlignSpec(width, fill), str_(str) {
+        internal::CharTraits<Char>::convert(FillChar());
+    }
 
-  const T *str() const { return str_; }
+    const Char *str() const {
+        return str_;
+    }
 };
 
 /**
-  Returns an integer format specifier to format the value in base 2.
- */
+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.
- */
+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.
- */
+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.
- */
+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.
+\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**::
+**Example**::
 
-    MemoryWriter out;
-    out << pad(hex(0xcafe), 8, '0');
-    // out.str() == "0000cafe"
+MemoryWriter out;
+out << pad(hex(0xcafe), 8, '0');
+// out.str() == "0000cafe"
 
-  \endrst
- */
+\endrst
+*/
 template <char TYPE_CODE, typename Char>
 IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
     int value, unsigned width, Char fill = ' ');
@@ -1358,26 +1617,26 @@ IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
 #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 */ \
@@ -1389,20 +1648,20 @@ inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
     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)
@@ -1412,26 +1671,26 @@ 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.
+\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**::
+**Example**::
 
-    std::string s = str(MemoryWriter() << pad("abc", 8));
-    // s == "abc     "
+std::string s = str(MemoryWriter() << pad("abc", 8));
+// s == "abc     "
 
-  \endrst
- */
+\endrst
+*/
 template <typename Char>
 inline StrFormatSpec<Char> pad(
     const Char *str, unsigned width, Char fill = ' ') {
-  return StrFormatSpec<Char>(str, width, 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);
+    return StrFormatSpec<wchar_t>(str, width, fill);
 }
 
 // Generates a comma-separated list with results of applying f to
@@ -1454,34 +1713,91 @@ inline StrFormatSpec<wchar_t> pad(
 # define FMT_GEN15(f) FMT_GEN14(f), f(14)
 
 namespace internal {
-inline uint64_t make_type() { return 0; }
+inline uint64_t make_type() {
+    return 0;
+}
 
 template <typename T>
-inline uint64_t make_type(const T &arg) { return MakeValue<char>::type(arg); }
+inline uint64_t make_type(const T &arg) {
+    return MakeValue<char>::type(arg);
+}
+
+template <unsigned N>
+struct ArgArray {
+    // Computes the argument array size by adding 1 to N, which is the number of
+    // arguments, if N is zero, because array of zero size is invalid, or if N
+    // is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra
+    // argument that marks the end of the list.
+    enum { SIZE = N + (N == 0 || N >= ArgList::MAX_PACKED_ARGS ? 1 : 0) };
+
+    typedef typename Conditional<
+    (N < ArgList::MAX_PACKED_ARGS), Value, Arg>::type Type[SIZE];
+};
 
 #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);
+    return make_type(first) | (make_type(tail...) << 4);
+}
+
+inline void do_set_types(Arg *) {}
+
+template <typename T, typename... Args>
+inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) {
+    args->type = static_cast<Arg::Type>(MakeValue<T>::type(arg));
+    do_set_types(args + 1, tail...);
+}
+
+template <typename... Args>
+inline void set_types(Arg *array, const Args & ... args) {
+    if (check(sizeof...(Args) > ArgList::MAX_PACKED_ARGS))
+        do_set_types(array, args...);
+    array[sizeof...(Args)].type = Arg::NONE;
+}
+
+template <typename... Args>
+inline void set_types(Value *, const Args & ...) {
+    // Do nothing as types are passed separately from values.
+}
+
+template <typename Char, typename Value>
+inline void store_args(Value *) {}
+
+template <typename Char, typename Arg, typename T, typename... Args>
+inline void store_args(Arg *args, const T &arg, const Args & ... tail) {
+    // Assign only the Value subobject of Arg and don't overwrite type (if any)
+    // that is assigned by set_types.
+    Value &value = *args;
+    value = MakeValue<Char>(arg);
+    store_args<Char>(args + 1, tail...);
+}
+
+template <typename Char, typename... Args>
+ArgList make_arg_list(typename ArgArray<sizeof...(Args)>::Type array,
+                      const Args & ... args) {
+    if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS))
+        set_types(array, args...);
+    store_args<Char>(array, args...);
+    return ArgList(make_type(args...), array);
 }
 #else
 
 struct ArgType {
-  uint64_t type;
+    uint64_t type;
 
-  ArgType() : type(0) {}
+    ArgType() : type(0) {}
 
-  template <typename T>
-  ArgType(const T &arg) : type(make_type(arg)) {}
+    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);
+    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
 }  // namespace internal
@@ -1497,25 +1813,17 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
 # define FMT_VARIADIC_VOID(func, arg_type) \
   template <typename... Args> \
   void func(arg_type arg0, const Args & ... args) { \
-    namespace internal = fmt::internal; \
-    typedef typename internal::SelectValueType<sizeof...(Args)>::Type Value; \
-    const Value array[internal::NonZero<sizeof...(Args)>::VALUE] = { \
-      internal::MakeValue<Char>(args)... \
-    }; \
-    func(arg0, ArgList(internal::make_type(args...), array)); \
-  }
+    typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
+    func(arg0, fmt::internal::make_arg_list<Char>(array, args...)); \
+      }
 
 // 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) { \
-    namespace internal = fmt::internal; \
-    typedef typename internal::SelectValueType<sizeof...(Args)>::Type Value; \
-    const Value array[internal::NonZero<sizeof...(Args)>::VALUE] = { \
-      internal::MakeValue<Char>(args)... \
-    }; \
-    func(arg0, arg1, ArgList(internal::make_type(args...), array)); \
-  }
+    typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
+    func(arg0, arg1, fmt::internal::make_arg_list<Char>(array, args...)); \
+      }
 
 #else
 
@@ -1527,10 +1835,10 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
 # 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::Value values[] = {FMT_GEN(n, FMT_MAKE_REF)}; \
+    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)), values)); \
-  }
+      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) \
@@ -1544,10 +1852,10 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
 # 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::Value values[] = {FMT_GEN(n, FMT_MAKE_REF)}; \
+    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)), values)); \
-  }
+      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) \
@@ -1586,698 +1894,744 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
   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.
+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, StringRef format_str, ArgList args);
+private:
+    void init(int err_code, CStringRef format_str, ArgList args);
 
- protected:
-  int error_code_;
+protected:
+    int error_code_;
 
-  typedef char Char;  // For FMT_VARIADIC_CTOR.
+    typedef char Char;  // For FMT_VARIADIC_CTOR.
 
-  SystemError() {}
+    SystemError() {}
 
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::SystemError` object with the description
-   of the form
+public:
+    /**
+    \rst
+    Constructs a :class:`fmt::SystemError` object with the description
+    of the form
 
-   .. parsed-literal::
-     *<message>*: *<system-message>*
+    .. 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**::
+    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.
 
-     // 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, StringRef message) {
-    init(error_code, message, ArgList());
-  }
-  FMT_VARIADIC_CTOR(SystemError, init, int, StringRef)
+    **Example**::
 
-  int error_code() const { return error_code_; }
+    // 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`.
+\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:
+You can use one of the following typedefs for common character types:
 
-  +---------+----------------------+
-  | Type    | Definition           |
-  +=========+======================+
-  | Writer  | BasicWriter<char>    |
-  +---------+----------------------+
-  | WWriter | BasicWriter<wchar_t> |
-  +---------+----------------------+
++---------+----------------------+
+| Type    | Definition           |
++=========+======================+
+| Writer  | BasicWriter<char>    |
++---------+----------------------+
+| WWriter | BasicWriter<wchar_t> |
++---------+----------------------+
 
-  \endrst
- */
+\endrst
+*/
 template <typename Char>
 class BasicWriter {
- private:
-  // Output buffer.
-  Buffer<Char> &buffer_;
+private:
+    // Output buffer.
+    Buffer<Char> &buffer_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
+    FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
 
-  typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
+    typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
 
 #if _SECURE_SCL
-  // Returns pointer value.
-  static Char *get(CharPtr p) { return p.base(); }
+    // Returns pointer value.
+    static Char *get(CharPtr p) {
+        return p.base();
+    }
 #else
-  static Char *get(Char *p) { return p; }
+    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);
+    // 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);
-  }
+    // 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);
+    }
 
-  // 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::copy(prefix, prefix + prefix_size, p);
-    return p + size - 1;
-  }
+    // 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::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);
+    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 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);
+    // 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);
+    // 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);
+    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);
+    // 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';
-  }
+    // 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 T>
+    void append_float_length(Char *&, T) {}
 
-  friend class internal::ArgFormatter<Char>;
-  friend class internal::PrintfFormatter<Char>;
+    template <typename Impl, typename Char_>
+    friend class internal::BasicArgFormatter;
 
- protected:
-  /**
+    friend class internal::PrintfArgFormatter<Char>;
+
+protected:
+    /**
     Constructs a ``BasicWriter`` object.
-   */
-  explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
+    */
+    explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
 
- public:
-  /**
+public:
+    /**
+    \rst
     Destroys a ``BasicWriter`` object.
-   */
-  virtual ~BasicWriter() {}
+    \endrst
+    */
+    virtual ~BasicWriter() {}
 
-  /**
+    /**
     Returns the total number of characters written.
-   */
-  std::size_t size() const { return buffer_.size(); }
+    */
+    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]; }
+    */
+    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];
-  }
+    */
+    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`.
-   */
-  std::basic_string<Char> str() const {
-    return std::basic_string<Char>(&buffer_[0], buffer_.size());
-  }
+    \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);
+    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)
+    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(BasicStringRef<Char> format, ArgList args) {
-    BasicFormatter<Char>(*this).format(format, args);
-  }
-  FMT_VARIADIC_VOID(write, BasicStringRef<Char>)
+    */
+    void write(BasicCStringRef<Char> format, ArgList args) {
+        BasicFormatter<Char>(*this).format(format, args);
+    }
+    FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
 
-  BasicWriter &operator<<(int value) {
-    return *this << IntFormatSpec<int>(value);
-  }
-  BasicWriter &operator<<(unsigned value) {
-    return *this << IntFormatSpec<unsigned>(value);
-  }
-  BasicWriter &operator<<(long value) {
-    return *this << IntFormatSpec<long>(value);
-  }
-  BasicWriter &operator<<(unsigned long value) {
-    return *this << IntFormatSpec<unsigned long>(value);
-  }
-  BasicWriter &operator<<(LongLong value) {
-    return *this << IntFormatSpec<LongLong>(value);
-  }
+    BasicWriter &operator<<(int value) {
+        return *this << IntFormatSpec<int>(value);
+    }
+    BasicWriter &operator<<(unsigned value) {
+        return *this << IntFormatSpec<unsigned>(value);
+    }
+    BasicWriter &operator<<(long value) {
+        return *this << IntFormatSpec<long>(value);
+    }
+    BasicWriter &operator<<(unsigned long value) {
+        return *this << IntFormatSpec<unsigned long>(value);
+    }
+    BasicWriter &operator<<(LongLong value) {
+        return *this << IntFormatSpec<LongLong>(value);
+    }
 
-  /**
+    /**
+    \rst
     Formats *value* and writes it to the stream.
-   */
-  BasicWriter &operator<<(ULongLong value) {
-    return *this << IntFormatSpec<ULongLong>(value);
-  }
+    \endrst
+    */
+    BasicWriter &operator<<(ULongLong value) {
+        return *this << IntFormatSpec<ULongLong>(value);
+    }
 
-  BasicWriter &operator<<(double value) {
-    write_double(value, FormatSpec());
-    return *this;
-  }
+    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.
-   */
-  BasicWriter &operator<<(long double value) {
-    write_double(value, FormatSpec());
-    return *this;
-  }
+    \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<<(char value) {
+        buffer_.push_back(value);
+        return *this;
+    }
 
-  BasicWriter &operator<<(
-      typename internal::WCharHelper<wchar_t, Char>::Supported 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.
-   */
-  BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
-    const Char *str = value.c_str();
-    buffer_.append(str, str + value.size());
-    return *this;
-  }
+    \endrst
+    */
+    BasicWriter &operator<<(fmt::BasicStringRef<Char> 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;
-  }
+    BasicWriter &operator<<(
+        typename internal::WCharHelper<StringRef, Char>::Supported value) {
+        const char *str = value.data();
+        buffer_.append(str, str + value.size());
+        return *this;
+    }
 
-  template <typename StrChar>
-  BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) {
-    const StrChar *s = spec.str();
-    // TODO: error if fill is not convertible to Char
-    write_str(s, std::char_traits<Char>::length(s), spec);
-    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;
+    }
 
-  void clear() FMT_NOEXCEPT { buffer_.clear(); }
+    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 = static_cast<Char>(spec.fill());
-    if (spec.align() == ALIGN_RIGHT) {
-      std::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::fill_n(out + size, spec.width() - size, fill);
+    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::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::fill_n(out + size, spec.width() - size, fill);
+        }
     }
-  } else {
-    out = grow_buffer(size);
-  }
-  std::copy(s, s + size, out);
-  return out;
+    else {
+        out = grow_buffer(size);
+    }
+    std::copy(s, s + size, out);
+    return out;
 }
 
 template <typename Char>
 typename BasicWriter<Char>::CharPtr
-  BasicWriter<Char>::fill_padding(
+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 = static_cast<Char>(fill);
-  std::fill_n(buffer, left_padding, fill_char);
-  buffer += left_padding;
-  CharPtr content = buffer;
-  std::fill_n(buffer + content_size, padding - left_padding, fill_char);
-  return content;
+    std::size_t padding = total_size - content_size;
+    std::size_t left_padding = padding / 2;
+    Char fill_char = internal::CharTraits<Char>::cast(fill);
+    std::fill_n(buffer, left_padding, fill_char);
+    buffer += left_padding;
+    CharPtr content = buffer;
+    std::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(
+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 = static_cast<Char>(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 + 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::fill(p, p + fill_size, fill);
+    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 + 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::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::fill(p, p + fill_size, fill);
+        }
+        return result;
     }
-    CharPtr result = prepare_int_buffer(
-        num_digits, subspec, prefix, prefix_size);
+    unsigned size = prefix_size + num_digits;
+    if (width <= size) {
+        CharPtr p = grow_buffer(size);
+        std::copy(prefix, prefix + prefix_size, p);
+        return p + size - 1;
+    }
+    CharPtr p = grow_buffer(width);
+    CharPtr end = p + width;
     if (align == ALIGN_LEFT) {
-      CharPtr p = grow_buffer(fill_size);
-      std::fill(p, p + fill_size, fill);
+        std::copy(prefix, prefix + prefix_size, p);
+        p += size;
+        std::fill(p, end, fill);
     }
-    return result;
-  }
-  unsigned size = prefix_size + num_digits;
-  if (width <= size) {
-    CharPtr p = grow_buffer(size);
-    std::copy(prefix, prefix + prefix_size, p);
-    return p + size - 1;
-  }
-  CharPtr p = grow_buffer(width);
-  CharPtr end = p + width;
-  if (align == ALIGN_LEFT) {
-    std::copy(prefix, prefix + prefix_size, p);
-    p += size;
-    std::fill(p, end, fill);
-  } else if (align == ALIGN_CENTER) {
-    p = fill_padding(p, width, size, fill);
-    std::copy(prefix, prefix + prefix_size, p);
-    p += size;
-  } else {
-    if (align == ALIGN_NUMERIC) {
-      if (prefix_size != 0) {
-        p = std::copy(prefix, prefix + prefix_size, p);
-        size -= prefix_size;
-      }
-    } else {
-      std::copy(prefix, prefix + prefix_size, end - size);
+    else if (align == ALIGN_CENTER) {
+        p = fill_padding(p, width, size, fill);
+        std::copy(prefix, prefix + prefix_size, p);
+        p += size;
     }
-    std::fill(p, end - size, fill);
-    p = end;
-  }
-  return p - 1;
+    else {
+        if (align == ALIGN_NUMERIC) {
+            if (prefix_size != 0) {
+                p = std::copy(prefix, prefix + prefix_size, p);
+                size -= prefix_size;
+            }
+        }
+        else {
+            std::copy(prefix, prefix + prefix_size, end - size);
+        }
+        std::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 = 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 prefix_size = 0;
+    typedef typename internal::IntTraits<T>::MainType UnsignedType;
+    UnsignedType abs_value = value;
+    char prefix[4] = "";
+    if (internal::is_negative(value)) {
+        prefix[0] = '-';
+        ++prefix_size;
+        abs_value = 0 - abs_value;
     }
-    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();
+    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-- = '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-- = '0' + (n & 7);
+        } while ((n >>= 3) != 0);
+        break;
+    }
+    default:
+        internal::report_unknown_type(
+            spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
+        break;
     }
-    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-- = '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-- = '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':
+    // 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';
+        // 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 getsign instead of value < 0 because the latter is always
-  // false for NaN.
-  if (internal::getsign(static_cast<double>(value))) {
-    sign = '-';
-    value = -value;
-  } else if (spec.flag(SIGN_FLAG)) {
-    sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
-  }
-
-  if (value != 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;
+    case 'E':
+    case 'G':
+    case 'A':
+        upper = true;
+        break;
+    default:
+        internal::report_unknown_type(type, "double");
+        break;
     }
-    CharPtr out = write_str(nan, nan_size, spec);
-    if (sign)
-      *out = sign;
-    return;
-  }
 
-  if (internal::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;
+    char sign = 0;
+    // Use getsign instead of value < 0 because the latter is always
+    // false for NaN.
+    if (internal::getsign(static_cast<double>(value))) {
+        sign = '-';
+        value = -value;
     }
-    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() + (std::max)(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 = static_cast<Char>(spec.fill());
-  for (;;) {
-    std::size_t buffer_size = buffer_.capacity() - offset;
-#if _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;
+    else if (spec.flag(SIGN_FLAG)) {
+        sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
     }
-#endif
-    Char *start = &buffer_[offset];
-    int n = internal::CharTraits<Char>::format_float(
-        start, buffer_size, format, width_for_sprintf, spec.precision(), value);
-    if (n >= 0 && offset + n < buffer_.capacity()) {
-      if (sign) {
-        if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
-            *start != ' ') {
-          *(start - 1) = sign;
-          sign = 0;
-        } else {
-          *(start - 1) = fill;
+
+    if (value != 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;
         }
-        ++n;
-      }
-      if (spec.align() == ALIGN_CENTER &&
-          spec.width() > static_cast<unsigned>(n)) {
-        width = spec.width();
-        CharPtr p = grow_buffer(width);
-        std::copy(p, p + n, p + (width - n) / 2);
-        fill_padding(p, spec.width(), n, fill);
-        return;
-      }
-      if (spec.fill() != ' ' || sign) {
-        while (*start == ' ')
-          *start++ = fill;
+        CharPtr out = write_str(nan, nan_size, spec);
         if (sign)
-          *(start - 1) = sign;
-      }
-      grow_buffer(n);
-      return;
+            *out = sign;
+        return;
+    }
+
+    if (internal::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() + (std::max)(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());
+    for (;;) {
+        std::size_t buffer_size = buffer_.capacity() - offset;
+#if _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
+        Char *start = &buffer_[offset];
+        int n = internal::CharTraits<Char>::format_float(
+                    start, buffer_size, format, width_for_sprintf, spec.precision(), value);
+        if (n >= 0 && offset + n < buffer_.capacity()) {
+            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() > static_cast<unsigned>(n)) {
+                width = spec.width();
+                CharPtr p = grow_buffer(width);
+                std::copy(p, p + n, p + (width - n) / 2);
+                fill_padding(p, spec.width(), n, fill);
+                return;
+            }
+            if (spec.fill() != ' ' || sign) {
+                while (*start == ' ')
+                    *start++ = fill;
+                if (sign)
+                    *(start - 1) = sign;
+            }
+            grow_buffer(n);
+            return;
+        }
+        // If n is negative we ask to increase the capacity by at least 1,
+        // but as std::vector, the buffer grows exponentially.
+        buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
     }
-    // If n is negative we ask to increase the capacity by at least 1,
-    // but as std::vector, the buffer grows exponentially.
-    buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
-  }
 }
 
 /**
-  \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.
+\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:
+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>> |
-  +---------------+-----------------------------------------------------+
++---------------+-----------------------------------------------------+
+| Type          | Definition                                          |
++===============+=====================================================+
+| MemoryWriter  | BasicMemoryWriter<char, std::allocator<char>>       |
++---------------+-----------------------------------------------------+
+| WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
++---------------+-----------------------------------------------------+
 
-  **Example**::
+**Example**::
 
-     MemoryWriter out;
-     out << "The answer is " << 42 << "\n";
-     out.write("({:+f}, {:+f})", -3.14, 3.14);
+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:
+This will write the following output to the ``out`` object:
 
-  .. code-block:: none
+.. code-block:: none
 
-     The answer is 42
-     (-3.140000, +3.140000)
+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
- */
+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_;
+private:
+    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
 
- public:
-  explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
-    : BasicWriter<Char>(buffer_), buffer_(alloc) {}
+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_)) {
-  }
+    */
+    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;
-  }
+    */
+    BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
+        buffer_ = std::move(other.buffer_);
+        return *this;
+    }
 #endif
 };
 
@@ -2285,50 +2639,49 @@ 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.
+\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`.
 
-  You can use one of the following typedefs for common character types:
+Any write method will throw ``std::runtime_error`` if the output doesn't fit
+into the array.
 
-  +--------------+---------------------------+
-  | Type         | Definition                |
-  +==============+===========================+
-  | ArrayWriter  | BasicArrayWriter<char>    |
-  +--------------+---------------------------+
-  | WArrayWriter | BasicArrayWriter<wchar_t> |
-  +--------------+---------------------------+
-  \endrst
- */
+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_;
+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) {}
+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) {}
 
-  // FIXME: this is temporary undocumented due to a bug in Sphinx
-  /*
-   \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) {}
+    /**
+    \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;
@@ -2337,59 +2690,59 @@ 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) {
-  std::basic_ostringstream<Char> os;
-  os << value;
-  std::basic_string<Char> str = os.str();
-  internal::Arg arg = internal::MakeValue<Char>(str);
-  arg.type = static_cast<internal::Arg::Type>(
-        internal::MakeValue<Char>::type(str));
-  format_str = f.format(format_str, arg);
+    std::basic_ostringstream<Char> os;
+    os << value;
+    std::basic_string<Char> str = os.str();
+    internal::Arg arg = internal::MakeValue<Char>(str);
+    arg.type = static_cast<internal::Arg::Type>(
+                   internal::MakeValue<Char>::type(str));
+    format_str = f.format(format_str, arg);
 }
 
 // Reports a system error without throwing an exception.
 // Can be used to report errors from destructors.
 void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT;
 
-#ifdef _WIN32
+#if FMT_USE_WINDOWS_H
 
 /** A Windows error. */
 class WindowsError : public SystemError {
- private:
-  void init(int error_code, StringRef format_str, ArgList args);
+private:
+    void init(int error_code, CStringRef format_str, ArgList args);
 
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::WindowsError` object with the description
-   of the form
+public:
+    /**
+    \rst
+    Constructs a :class:`fmt::WindowsError` object with the description
+    of the form
 
-   .. parsed-literal::
-     *<message>*: *<system-message>*
+    .. 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".
+    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**::
+    **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, StringRef message) {
-    init(error_code, message, ArgList());
-  }
-  FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef)
+    // 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.
@@ -2401,186 +2754,200 @@ void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT;
 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:
-    PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23;
- */
-void print_colored(Color c, StringRef format, ArgList args);
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    std::string message = format("The answer is {}", 42);
-  \endrst
+Formats a string and prints it to stdout using ANSI escape sequences
+to specify color (experimental).
+Example:
+PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23;
 */
-inline std::string format(StringRef format_str, ArgList args) {
-  MemoryWriter w;
-  w.write(format_str, args);
-  return w.str();
+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(WStringRef format_str, ArgList args) {
-  WMemoryWriter 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*.
+\rst
+Prints formatted data to the file *f*.
 
-  **Example**::
+**Example**::
 
-    print(stderr, "Don't {}!", "panic");
-  \endrst
- */
-void print(std::FILE *f, StringRef format_str, ArgList args);
+print(stderr, "Don't {}!", "panic");
+\endrst
+*/
+void print(std::FILE *f, CStringRef format_str, ArgList args);
 
 /**
-  \rst
-  Prints formatted data to ``stdout``.
+\rst
+Prints formatted data to ``stdout``.
 
-  **Example**::
+**Example**::
 
-    print("Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
- */
-void print(StringRef format_str, ArgList args);
+print("Elapsed time: {0:.2f} seconds", 1.23);
+\endrst
+*/
+void print(CStringRef format_str, ArgList args);
 
 /**
-  \rst
-  Prints formatted data to the stream *os*.
+\rst
+Prints formatted data to the stream *os*.
 
-  **Example**::
+**Example**::
 
-    print(cerr, "Don't {}!", "panic");
-  \endrst
- */
-void print(std::ostream &os, StringRef format_str, ArgList args);
+print(cerr, "Don't {}!", "panic");
+\endrst
+*/
+void print(std::ostream &os, CStringRef format_str, ArgList args);
 
 template <typename Char>
-void printf(BasicWriter<Char> &w, BasicStringRef<Char> format, ArgList args) {
-  internal::PrintfFormatter<Char>().format(w, format, args);
+void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args) {
+    internal::PrintfFormatter<Char>().format(w, format, args);
 }
 
 /**
-  \rst
-  Formats arguments and returns the result as a string.
+\rst
+Formats arguments and returns the result as a string.
 
-  **Example**::
+**Example**::
 
-    std::string message = fmt::sprintf("The answer is %d", 42);
-  \endrst
+std::string message = fmt::sprintf("The answer is %d", 42);
+\endrst
 */
-inline std::string sprintf(StringRef format, ArgList args) {
-  MemoryWriter w;
-  printf(w, format, args);
-  return w.str();
+inline std::string sprintf(CStringRef format, ArgList args) {
+    MemoryWriter w;
+    printf(w, format, args);
+    return w.str();
 }
 
 /**
-  \rst
-  Prints formatted data to the file *f*.
+\rst
+Prints formatted data to the file *f*.
 
-  **Example**::
+**Example**::
 
-    fmt::fprintf(stderr, "Don't %s!", "panic");
-  \endrst
- */
-int fprintf(std::FILE *f, StringRef format, ArgList args);
+fmt::fprintf(stderr, "Don't %s!", "panic");
+\endrst
+*/
+int fprintf(std::FILE *f, CStringRef format, ArgList args);
 
 /**
-  \rst
-  Prints formatted data to ``stdout``.
+\rst
+Prints formatted data to ``stdout``.
 
-  **Example**::
+**Example**::
 
-    fmt::printf("Elapsed time: %.2f seconds", 1.23);
-  \endrst
- */
-inline int printf(StringRef format, ArgList args) {
-  return fprintf(stdout, format, args);
+fmt::printf("Elapsed time: %.2f seconds", 1.23);
+\endrst
+*/
+inline int printf(CStringRef format, ArgList args) {
+    return fprintf(stdout, format, args);
 }
 
 /**
-  Fast integer formatter.
- */
+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_;
+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 = (value % 100) * 2;
-      value /= 100;
-      *--buffer_end = internal::Data::DIGITS[index + 1];
-      *--buffer_end = internal::Data::DIGITS[index];
+    // 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 = (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;
     }
-    if (value < 10) {
-      *--buffer_end = static_cast<char>('0' + value);
-      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_ = '-';
     }
-    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)) {}
 
- 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 buffer_ - str_ + BUFFER_SIZE - 1; }
+    */
+    std::size_t size() const {
+        return 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_; }
+    */
+    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_;
-  }
+    */
+    const char *c_str() const {
+        buffer_[BUFFER_SIZE - 1] = '\0';
+        return str_;
+    }
 
-  /**
-    Returns the content of the output buffer as an `std::string`.
-   */
-  std::string str() const { return std::string(str_, size()); }
+    /**
+    \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
@@ -2588,25 +2955,52 @@ class FormatInt {
 // write a terminating null character.
 template <typename T>
 inline void format_decimal(char *&buffer, T value) {
-  typename internal::IntTraits<T>::MainType abs_value = 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;
+    typename internal::IntTraits<T>::MainType abs_value = value;
+    if (internal::is_negative(value)) {
+        *buffer++ = '-';
+        abs_value = 0 - abs_value;
     }
-    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;
+    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
@@ -2637,52 +3031,13 @@ inline void format_decimal(char *&buffer, T value) {
 #define FMT_GET_ARG_NAME(type, index) arg##index
 
 #if FMT_USE_VARIADIC_TEMPLATES
-
-namespace fmt {
-namespace internal {
-inline void do_set_types(Arg *) {}
-
-template <typename T, typename... Args>
-inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) {
-  args->type = static_cast<Arg::Type>(MakeValue<T>::type(arg));
-  do_set_types(args + 1, tail...);
-}
-
-template <typename... Args>
-inline void set_types(Arg *array, const Args & ... args) {
-  do_set_types(array, args...);
-  array[sizeof...(Args)].type = Arg::NONE;
-}
-
-template <typename... Args>
-inline void set_types(Value *, const Args & ...) {
-  // Do nothing as types are passed separately from values.
-}
-
-// Computes the argument array size by adding 1 to N, which is the number of
-// arguments, if N is zero, because array of zero size is invalid, or if N
-// is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra
-// argument that marks the end of the list.
-template <unsigned N>
-struct ArgArraySize {
-  enum { VALUE = N + (N == 0 || N > ArgList::MAX_PACKED_ARGS ? 1 : 0) };
-};
-}
-}
-
 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
   template <typename... Args> \
   ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
       const Args & ... args) { \
-    namespace internal = fmt::internal; \
-    typedef typename internal::SelectValueType<sizeof...(Args)>::Type Value; \
-    Value array[internal::ArgArraySize<sizeof...(Args)>::VALUE] = { \
-      internal::MakeValue<Char>(args)... \
-    }; \
-    if (internal::check((sizeof...(Args) > fmt::ArgList::MAX_PACKED_ARGS))) \
-      set_types(array, args...); \
+    typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
     call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
-      fmt::ArgList(internal::make_type(args...), array)); \
+      fmt::internal::make_arg_list<Char>(array, args...)); \
   }
 #else
 // Defines a wrapper for a function taking __VA_ARGS__ arguments
@@ -2691,9 +3046,9 @@ struct ArgArraySize {
   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)) { \
-    const fmt::internal::Value values[] = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \
+    fmt::internal::ArgArray<n>::Type arr = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \
     call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), values)); \
+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
   }
 
 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
@@ -2718,48 +3073,70 @@ struct ArgArraySize {
 #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.
+\rst
+Defines a variadic function with the specified return type, function name
+and argument types passed as variable arguments to this macro.
 
-  **Example**::
+**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 *)
+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::
+``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
- */
+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, StringRef)
-FMT_VARIADIC_W(std::wstring, format, WStringRef)
-FMT_VARIADIC(void, print, StringRef)
-FMT_VARIADIC(void, print, std::FILE *, StringRef)
-FMT_VARIADIC(void, print, std::ostream &, StringRef)
-FMT_VARIADIC(void, print_colored, Color, StringRef)
-FMT_VARIADIC(std::string, sprintf, StringRef)
-FMT_VARIADIC(int, printf, StringRef)
-FMT_VARIADIC(int, fprintf, std::FILE *, StringRef)
+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, std::ostream &, CStringRef)
+FMT_VARIADIC(void, print_colored, Color, CStringRef)
+FMT_VARIADIC(std::string, sprintf, CStringRef)
+FMT_VARIADIC(int, printf, CStringRef)
+FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
 }
 
 // Restore warnings.
@@ -2775,4 +3152,4 @@ FMT_VARIADIC(int, fprintf, std::FILE *, StringRef)
 # include "format.cc"
 #endif
 
-#endif  // FMT_FORMAT_H_
+#endif  // FMT_FORMAT_H_
\ No newline at end of file

From 2b59393bda0a5b660e64b1526837824579040d68 Mon Sep 17 00:00:00 2001
From: Artem Martynovich <artem.martynovich@gmail.com>
Date: Mon, 13 Jul 2015 19:43:22 +0600
Subject: [PATCH 45/61] Add wchar_t support for Windows.

---
 include/spdlog/common.h              |  8 +++++
 include/spdlog/details/format.h      |  7 ++++-
 include/spdlog/details/os.h          | 20 ++++++++++--
 include/spdlog/details/spdlog_impl.h | 16 +++++-----
 include/spdlog/sinks/file_sinks.h    | 47 ++++++++++++++--------------
 include/spdlog/spdlog.h              |  8 ++---
 6 files changed, 68 insertions(+), 38 deletions(-)

diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index cde5a9eb..8e601547 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -36,6 +36,14 @@
 #define SPDLOG_NOEXCEPT throw()
 #endif
 
+#ifdef WIN32
+typedef std::wstring tstring;
+typedef wchar_t tchar;
+#else
+#define L
+typedef std::string tstring;
+typedef char tchar;
+#endif
 
 namespace spdlog
 {
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index 7ec3b390..f1cfd48b 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -2648,6 +2648,11 @@ 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:
+#ifdef WIN32
+#define TMemoryWriter WMemoryWriter
+#else
+#define TMemoryWriter MemoryWriter
+#endif
 
 +--------------+---------------------------+
 | Type         | Definition                |
@@ -3152,4 +3157,4 @@ FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
 # include "format.cc"
 #endif
 
-#endif  // FMT_FORMAT_H_
\ No newline at end of file
+#endif  // FMT_FORMAT_H_
diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h
index 753b6d91..1d010937 100644
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@@ -147,17 +147,33 @@ constexpr inline unsigned short eol_size()
 #endif
 
 //fopen_s on non windows for writing
-inline int fopen_s(FILE** fp, const std::string& filename, const char* mode)
+inline int fopen_s(FILE** fp, const tstring& filename, tchar* mode)
 {
 #ifdef _WIN32
-    *fp = _fsopen((filename.c_str()), mode, _SH_DENYWR);
+    *fp = _wfsopen((filename.c_str()), mode, _SH_DENYWR);
     return *fp == nullptr;
 #else
     *fp = fopen((filename.c_str()), mode);
     return *fp == nullptr;
 #endif
+}
 
+inline int remove(const tchar* filename)
+{
+#ifdef _WIN32
+    return _wremove(filename);
+#else
+    return std::remove(filename);
+#endif
+}
 
+inline int rename(const tchar* filename1, const tchar* filename2)
+{
+#ifdef _WIN32
+    return _wrename(filename1, filename2);
+#else
+    return std::remove(filename1, filename2);
+#endif
 }
 
 //Return utc offset in minutes or -1 on failure
diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h
index cfd6f826..18cd5b65 100644
--- a/include/spdlog/details/spdlog_impl.h
+++ b/include/spdlog/details/spdlog_impl.h
@@ -48,24 +48,24 @@ inline void spdlog::drop(const std::string &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)
+inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const tstring& 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);
+    return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, L"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)
+inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const tstring& 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);
+    return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, L"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)
+inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const tstring& filename, int hour, int minute, bool force_flush)
 {
-    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, "txt", hour, minute, force_flush);
+    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, L"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)
+inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const tstring& filename, int hour, int minute, bool force_flush)
 {
-    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", hour, minute, force_flush);
+    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, L"txt", hour, minute, force_flush);
 }
 
 
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 79cbb4e4..5f980ef3 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -29,6 +29,7 @@
 #include "../details/null_mutex.h"
 #include "../details/file_helper.h"
 #include "../details/format.h"
+#include "../details/os.h"
 
 namespace spdlog
 {
@@ -71,7 +72,7 @@ template<class Mutex>
 class rotating_file_sink : public base_sink < Mutex >
 {
 public:
-    rotating_file_sink(const std::string &base_filename, const std::string &extension,
+    rotating_file_sink(const tstring &base_filename, const tstring &extension,
                        std::size_t max_size, std::size_t max_files,
                        bool force_flush = false) :
         _base_filename(base_filename),
@@ -102,13 +103,13 @@ protected:
     }
 
 private:
-    static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
+    static tstring calc_filename(const tstring& filename, std::size_t index, const tstring& extension)
     {
-        fmt::MemoryWriter w;
+        fmt::TMemoryWriter w;
         if (index)
-            w.write("{}.{}.{}", filename, index, extension);
+            w.write(L"{}.{}.{}", filename, index, extension);
         else
-            w.write("{}.{}", filename, extension);
+            w.write(L"{}.{}", filename, extension);
         return w.str();
     }
 
@@ -123,28 +124,28 @@ private:
         _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);
+            tstring src = calc_filename(_base_filename, i - 1, _extension);
+            tstring target = calc_filename(_base_filename, i, _extension);
 
             if (details::file_helper::file_exists(target))
             {
-                if (std::remove(target.c_str()) != 0)
+                if (details::os::remove(target.c_str()) != 0)
                 {
-                    throw spdlog_ex("rotating_file_sink: failed removing " + target);
+                    throw spdlog_ex("rotating_file_sink: failed removing");
                 }
             }
-            if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str()))
+            if (details::file_helper::file_exists(src) && details::os::rename(src.c_str(), target.c_str()))
             {
-                throw spdlog_ex("rotating_file_sink: failed renaming " + src + " to " + target);
+                throw spdlog_ex("rotating_file_sink: failed renaming");
             }
         }
         _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;
+    tstring _base_filename,
+            _extension;
+    std::size_t _max_size,
+                _max_files,
+                _current_size;
     details::file_helper _file_helper;
 };
 
@@ -160,8 +161,8 @@ 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,
+        const tstring& base_filename,
+        const tstring& extension,
         int rotation_hour,
         int rotation_minute,
         bool force_flush = false) : _base_filename(base_filename),
@@ -210,16 +211,16 @@ private:
     }
 
     //Create filename for the form basename.YYYY-MM-DD.extension
-    static std::string calc_filename(const std::string& basename, const std::string& extension)
+    static tstring calc_filename(const tstring& basename, const tstring& 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);
+        fmt::TMemoryWriter w;
+        w.write(L"{}_{: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;
+    tstring _base_filename;
+    tstring _extension;
     int _rotation_h;
     int _rotation_m;
     std::chrono::system_clock::time_point _rotation_tp;
diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index 5cec5623..61e9a8b3 100644
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -76,14 +76,14 @@ 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& filename, 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);
+std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const tstring& filename, 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 tstring& 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);
+std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const tstring& filename, int hour=0, int minute=0, bool force_flush = false);
+std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const tstring& filename, int hour=0, int minute=0, bool force_flush = false);
 
 
 //

From 0e5c4b9de458e570fa41faa717488c6c044b14ca Mon Sep 17 00:00:00 2001
From: Artem Martynovich <artem.martynovich@gmail.com>
Date: Tue, 14 Jul 2015 02:13:16 +0600
Subject: [PATCH 46/61] Fix Unix build. Use S("...") instead of L"..." for
 better compatibility.

---
 include/spdlog/common.h              |  3 ++-
 include/spdlog/details/format.h      | 11 ++++++-----
 include/spdlog/details/os.h          |  4 ++--
 include/spdlog/details/spdlog_impl.h |  8 ++++----
 include/spdlog/sinks/file_sinks.h    |  6 +++---
 5 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index 8e601547..d23a86bc 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -39,8 +39,9 @@
 #ifdef WIN32
 typedef std::wstring tstring;
 typedef wchar_t tchar;
+#define S(s) L ## s
 #else
-#define L
+#define S(s) s
 typedef std::string tstring;
 typedef char tchar;
 #endif
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index f1cfd48b..af584b7f 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -2638,6 +2638,12 @@ public:
 typedef BasicMemoryWriter<char> MemoryWriter;
 typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
 
+#ifdef WIN32
+#define TMemoryWriter WMemoryWriter
+#else
+#define TMemoryWriter MemoryWriter
+#endif
+
 /**
 \rst
 This class template provides operations for formatting and writing data
@@ -2648,11 +2654,6 @@ 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:
-#ifdef WIN32
-#define TMemoryWriter WMemoryWriter
-#else
-#define TMemoryWriter MemoryWriter
-#endif
 
 +--------------+---------------------------+
 | Type         | Definition                |
diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h
index 1d010937..61e05682 100644
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@@ -147,7 +147,7 @@ constexpr inline unsigned short eol_size()
 #endif
 
 //fopen_s on non windows for writing
-inline int fopen_s(FILE** fp, const tstring& filename, tchar* mode)
+inline int fopen_s(FILE** fp, const tstring& filename, const tchar* mode)
 {
 #ifdef _WIN32
     *fp = _wfsopen((filename.c_str()), mode, _SH_DENYWR);
@@ -172,7 +172,7 @@ inline int rename(const tchar* filename1, const tchar* filename2)
 #ifdef _WIN32
     return _wrename(filename1, filename2);
 #else
-    return std::remove(filename1, filename2);
+    return std::remove(filename1);
 #endif
 }
 
diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h
index 18cd5b65..2530b596 100644
--- a/include/spdlog/details/spdlog_impl.h
+++ b/include/spdlog/details/spdlog_impl.h
@@ -50,22 +50,22 @@ inline void spdlog::drop(const std::string &name)
 // Create multi/single threaded rotating file logger
 inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const tstring& filename, size_t max_file_size, size_t max_files, bool force_flush)
 {
-    return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, L"txt", max_file_size, max_files, force_flush);
+    return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, S("txt"), max_file_size, max_files, force_flush);
 }
 
 inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const tstring& filename, size_t max_file_size, size_t max_files, bool force_flush)
 {
-    return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, L"txt", max_file_size, max_files, force_flush);
+    return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, S("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 tstring& filename, int hour, int minute, bool force_flush)
 {
-    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, L"txt", hour, minute, force_flush);
+    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, S("txt"), hour, minute, force_flush);
 }
 inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const tstring& filename, int hour, int minute, bool force_flush)
 {
-    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, L"txt", hour, minute, force_flush);
+    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, S("txt"), hour, minute, force_flush);
 }
 
 
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 5f980ef3..12e36a75 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -107,9 +107,9 @@ private:
     {
         fmt::TMemoryWriter w;
         if (index)
-            w.write(L"{}.{}.{}", filename, index, extension);
+            w.write(S("{}.{}.{}"), filename, index, extension);
         else
-            w.write(L"{}.{}", filename, extension);
+            w.write(S("{}.{}"), filename, extension);
         return w.str();
     }
 
@@ -215,7 +215,7 @@ private:
     {
         std::tm tm = spdlog::details::os::localtime();
         fmt::TMemoryWriter w;
-        w.write(L"{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension);
+        w.write(S("{}_{: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();
     }
 

From 8b6df31ec9e64f3b42936678128c5bd0fbc2c830 Mon Sep 17 00:00:00 2001
From: Artem Martynovich <artem.martynovich@gmail.com>
Date: Tue, 14 Jul 2015 02:42:50 +0600
Subject: [PATCH 47/61] Revert to original formatting.

---
 include/spdlog/sinks/file_sinks.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 12e36a75..0f0824e7 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -141,11 +141,11 @@ private:
         }
         _file_helper.reopen(true);
     }
-    tstring _base_filename,
-            _extension;
-    std::size_t _max_size,
-                _max_files,
-                _current_size;
+    tstring _base_filename;
+    tstring _extension;
+    std::size_t _max_size;
+    std::size_t _max_files;
+    std::size_t _current_size;
     details::file_helper _file_helper;
 };
 

From 7ee0ec0728e3b4963b7233d8b3d58b7db74bfcaf Mon Sep 17 00:00:00 2001
From: Artem Martynovich <artem.martynovich@gmail.com>
Date: Tue, 14 Jul 2015 15:47:20 +0600
Subject: [PATCH 48/61] Fix remaining wstring issues in file_helper.

---
 include/spdlog/details/file_helper.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h
index 8e1f600b..c9a70ef7 100644
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -62,11 +62,11 @@ public:
     }
 
 
-    void open(const std::string& fname, bool truncate=false)
+    void open(const tstring& fname, bool truncate=false)
     {
 
         close();
-        const char* mode = truncate ? "wb" : "ab";
+        tchar* mode = truncate ? S("wb") : S("ab");
         _filename = fname;
         for (int tries = 0; tries < open_tries; ++tries)
         {
@@ -76,7 +76,7 @@ public:
             std::this_thread::sleep_for(std::chrono::milliseconds(open_interval));
         }
 
-        throw spdlog_ex("Failed opening file " + fname + " for writing");
+        throw spdlog_ex("Failed opening file for writing");
     }
 
     void reopen(bool truncate)
@@ -106,22 +106,22 @@ public:
         size_t size = msg.formatted.size();
         auto data = msg.formatted.data();
         if(std::fwrite(data, 1, size, _fd) != size)
-            throw spdlog_ex("Failed writing to file " + _filename);
+            throw spdlog_ex("Failed writing to file");
 
         if(_force_flush)
             std::fflush(_fd);
 
     }
 
-    const std::string& filename() const
+    const tstring& filename() const
     {
         return _filename;
     }
 
-    static bool file_exists(const std::string& name)
+    static bool file_exists(const tstring& name)
     {
         FILE* file;
-        if (!os::fopen_s(&file, name.c_str(), "r"))
+        if (!os::fopen_s(&file, name.c_str(), S("r")))
         {
             fclose(file);
             return true;
@@ -134,7 +134,7 @@ public:
 
 private:
     FILE* _fd;
-    std::string _filename;
+    tstring _filename;
     bool _force_flush;
 
 

From 5508607dfab4b8697399034f457568c9e023c58e Mon Sep 17 00:00:00 2001
From: Artem Martynovich <artem.martynovich@gmail.com>
Date: Wed, 15 Jul 2015 11:24:49 +0600
Subject: [PATCH 49/61] Fix incorrect string type for fopen_s.

---
 include/spdlog/details/file_helper.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h
index c9a70ef7..a5f9f265 100644
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -66,7 +66,7 @@ public:
     {
 
         close();
-        tchar* mode = truncate ? S("wb") : S("ab");
+        const tchar* mode = truncate ? S("wb") : S("ab");
         _filename = fname;
         for (int tries = 0; tries < open_tries; ++tries)
         {

From 787aa4669337a51d1f24feb40a4e6478fcf857c1 Mon Sep 17 00:00:00 2001
From: Artem Martynovich <artem.martynovich@gmail.com>
Date: Tue, 21 Jul 2015 17:32:53 +0600
Subject: [PATCH 50/61] Disable usage of wchar_t in tests.

---
 include/spdlog/common.h         |  6 +++++-
 include/spdlog/details/format.h |  2 +-
 include/spdlog/details/os.h     | 12 ++++++++----
 include/spdlog/tweakme.h        |  6 ++++++
 tests/includes.h                |  1 +
 5 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index d23a86bc..dd05f1b0 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -36,7 +36,11 @@
 #define SPDLOG_NOEXCEPT throw()
 #endif
 
-#ifdef WIN32
+#if !defined(SPDLOG_NO_WCHAR) && defined(WIN32)
+#define SPDLOG_USE_WCHAR
+#endif
+
+#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
 typedef std::wstring tstring;
 typedef wchar_t tchar;
 #define S(s) L ## s
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index af584b7f..aaeb011d 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -2638,7 +2638,7 @@ public:
 typedef BasicMemoryWriter<char> MemoryWriter;
 typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
 
-#ifdef WIN32
+#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
 #define TMemoryWriter WMemoryWriter
 #else
 #define TMemoryWriter MemoryWriter
diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h
index 61e05682..6af4771e 100644
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@@ -149,8 +149,12 @@ constexpr inline unsigned short eol_size()
 //fopen_s on non windows for writing
 inline int fopen_s(FILE** fp, const tstring& filename, const tchar* mode)
 {
-#ifdef _WIN32
+#if defined(WIN32)
+  #if defined(SPDLOG_USE_WCHAR)
     *fp = _wfsopen((filename.c_str()), mode, _SH_DENYWR);
+  #else
+    *fp = _fsopen((filename.c_str()), mode, _SH_DENYWR);
+  #endif
     return *fp == nullptr;
 #else
     *fp = fopen((filename.c_str()), mode);
@@ -160,7 +164,7 @@ inline int fopen_s(FILE** fp, const tstring& filename, const tchar* mode)
 
 inline int remove(const tchar* filename)
 {
-#ifdef _WIN32
+#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
     return _wremove(filename);
 #else
     return std::remove(filename);
@@ -169,10 +173,10 @@ inline int remove(const tchar* filename)
 
 inline int rename(const tchar* filename1, const tchar* filename2)
 {
-#ifdef _WIN32
+#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
     return _wrename(filename1, filename2);
 #else
-    return std::remove(filename1);
+    return std::rename(filename1, filename2);
 #endif
 }
 
diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index b651658b..5bb33afd 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -72,3 +72,9 @@
 // Note that upon creating a logger the registry is modified by spdlog..
 // #define SPDLOG_NO_REGISTRY_MUTEX
 ///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to disable usage of wchar_t for file names on Windows.
+// #define SPDLOG_NO_WCHAR
+///////////////////////////////////////////////////////////////////////////////
diff --git a/tests/includes.h b/tests/includes.h
index 7cda161d..2c28f7d4 100644
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -7,6 +7,7 @@
 #include <chrono>
 #include <exception>
 
+#define SPDLOG_NO_WCHAR
 #include "catch.hpp"
 #include "../include/spdlog/spdlog.h"
 #include "../include/spdlog/sinks/null_sink.h"

From d905ad915fe5307dba7be61169db6b8f30eb082d Mon Sep 17 00:00:00 2001
From: Ilya Kulakov <kulakov.ilya@gmail.com>
Date: Sun, 26 Jul 2015 15:18:08 -0400
Subject: [PATCH 51/61] Use only SPDLOG_USE_WCHAR to control whether wchar_t is
 enabled.

---
 include/spdlog/common.h  | 4 ----
 include/spdlog/tweakme.h | 4 ++--
 tests/includes.h         | 1 -
 3 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index dd05f1b0..f86c02b9 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -36,10 +36,6 @@
 #define SPDLOG_NOEXCEPT throw()
 #endif
 
-#if !defined(SPDLOG_NO_WCHAR) && defined(WIN32)
-#define SPDLOG_USE_WCHAR
-#endif
-
 #if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
 typedef std::wstring tstring;
 typedef wchar_t tchar;
diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index 5bb33afd..7e0bb41b 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -75,6 +75,6 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Uncomment to disable usage of wchar_t for file names on Windows.
-// #define SPDLOG_NO_WCHAR
+// Uncomment to enable usage of wchar_t for file names on Windows.
+// #define SPDLOG_USE_WCHAR
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/tests/includes.h b/tests/includes.h
index 2c28f7d4..7cda161d 100644
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -7,7 +7,6 @@
 #include <chrono>
 #include <exception>
 
-#define SPDLOG_NO_WCHAR
 #include "catch.hpp"
 #include "../include/spdlog/spdlog.h"
 #include "../include/spdlog/sinks/null_sink.h"

From 22786f02963655ea11cb58e06bccf2f1fea9544d Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Mon, 27 Jul 2015 01:24:28 +0300
Subject: [PATCH 52/61] Update tweakme.h

---
 include/spdlog/tweakme.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index 7e0bb41b..e74566c4 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -75,6 +75,6 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable usage of wchar_t for file names on Windows.
+// Uncomment to enable usage of wchar_t for for logging and file names on Windows.
 // #define SPDLOG_USE_WCHAR
 ///////////////////////////////////////////////////////////////////////////////

From 5fc6002fc2b1211137e03c8be9422caf54a767a8 Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Mon, 27 Jul 2015 01:27:28 +0300
Subject: [PATCH 53/61] Update tweakme.h

---
 include/spdlog/tweakme.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index e74566c4..7e0bb41b 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -75,6 +75,6 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable usage of wchar_t for for logging and file names on Windows.
+// Uncomment to enable usage of wchar_t for file names on Windows.
 // #define SPDLOG_USE_WCHAR
 ///////////////////////////////////////////////////////////////////////////////

From b3050aa8a974397554b75503789dd6fa13f3d246 Mon Sep 17 00:00:00 2001
From: Radu Popescu <rpopescu@gmail.com>
Date: Tue, 4 Aug 2015 11:32:13 +0200
Subject: [PATCH 54/61] fixed issue 115 Nanosecond resolution timestamps

---
 include/spdlog/details/pattern_formatter_impl.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h
index a5b2d21f..137037ec 100644
--- a/include/spdlog/details/pattern_formatter_impl.h
+++ b/include/spdlog/details/pattern_formatter_impl.h
@@ -265,6 +265,17 @@ class f_formatter :public flag_formatter
     }
 };
 
+// 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
 {
@@ -575,6 +586,9 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
     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()));

From cadd181d8d2d97fc6b94a2a4a9682affda9f1d89 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 7 Aug 2015 14:05:34 +0300
Subject: [PATCH 55/61] Reverted pull #111 - wchar support under windows - it
 pollutes global namespace with new defines

---
 include/spdlog/common.h              | 33 +++++++-----------
 include/spdlog/details/file_helper.h | 27 +++++++--------
 include/spdlog/details/os.h          | 25 ++------------
 include/spdlog/details/spdlog_impl.h | 16 ++++-----
 include/spdlog/sinks/file_sinks.h    | 51 ++++++++++++++--------------
 include/spdlog/spdlog.h              |  8 ++---
 include/spdlog/tweakme.h             |  6 ----
 7 files changed, 64 insertions(+), 102 deletions(-)

diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index f86c02b9..01b22121 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -36,15 +36,6 @@
 #define SPDLOG_NOEXCEPT throw()
 #endif
 
-#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
-typedef std::wstring tstring;
-typedef wchar_t tchar;
-#define S(s) L ## s
-#else
-#define S(s) s
-typedef std::string tstring;
-typedef char tchar;
-#endif
 
 namespace spdlog
 {
@@ -58,8 +49,8 @@ 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 sink_ptr = std::shared_ptr < sinks::sink >;
+using sinks_init_list = std::initializer_list < sink_ptr >;
 using formatter_ptr = std::shared_ptr<spdlog::formatter>;
 
 
@@ -68,16 +59,16 @@ namespace level
 {
 typedef enum
 {
-    trace    = 0,
-    debug    = 1,
-    info     = 2,
-    notice   = 3,
-    warn     = 4,
-    err      = 5,
+    trace = 0,
+    debug = 1,
+    info = 2,
+    notice = 3,
+    warn = 4,
+    err = 5,
     critical = 6,
-    alert    = 7,
-    emerg    = 8,
-    off      = 9
+    alert = 7,
+    emerg = 8,
+    off = 9
 } level_enum;
 
 static const char* level_names[] { "trace", "debug", "info", "notice", "warning", "error", "critical", "alert", "emerg", "off"};
@@ -122,4 +113,4 @@ private:
 
 };
 
-} //spdlog
+} //spdlog
\ No newline at end of file
diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h
index a5f9f265..5062e977 100644
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -48,7 +48,7 @@ public:
     const int open_tries = 5;
     const int open_interval = 10;
 
-    explicit file_helper(bool force_flush):
+    explicit file_helper(bool force_flush) :
         _fd(nullptr),
         _force_flush(force_flush)
     {}
@@ -62,26 +62,26 @@ public:
     }
 
 
-    void open(const tstring& fname, bool truncate=false)
+    void open(const std::string& fname, bool truncate = false)
     {
 
         close();
-        const tchar* mode = truncate ? S("wb") : S("ab");
+        const char* mode = truncate ? "wb" : "ab";
         _filename = fname;
         for (int tries = 0; tries < open_tries; ++tries)
         {
-            if(!os::fopen_s(&_fd, fname, mode))
+            if (!os::fopen_s(&_fd, fname, mode))
                 return;
 
             std::this_thread::sleep_for(std::chrono::milliseconds(open_interval));
         }
 
-        throw spdlog_ex("Failed opening file for writing");
+        throw spdlog_ex("Failed opening file " + fname + " for writing");
     }
 
     void reopen(bool truncate)
     {
-        if(_filename.empty())
+        if (_filename.empty())
             throw spdlog_ex("Failed re opening file - was not opened before");
         open(_filename, truncate);
 
@@ -105,23 +105,23 @@ public:
 
         size_t size = msg.formatted.size();
         auto data = msg.formatted.data();
-        if(std::fwrite(data, 1, size, _fd) != size)
-            throw spdlog_ex("Failed writing to file");
+        if (std::fwrite(data, 1, size, _fd) != size)
+            throw spdlog_ex("Failed writing to file " + _filename);
 
-        if(_force_flush)
+        if (_force_flush)
             std::fflush(_fd);
 
     }
 
-    const tstring& filename() const
+    const std::string& filename() const
     {
         return _filename;
     }
 
-    static bool file_exists(const tstring& name)
+    static bool file_exists(const std::string& name)
     {
         FILE* file;
-        if (!os::fopen_s(&file, name.c_str(), S("r")))
+        if (!os::fopen_s(&file, name.c_str(), "r"))
         {
             fclose(file);
             return true;
@@ -134,11 +134,10 @@ public:
 
 private:
     FILE* _fd;
-    tstring _filename;
+    std::string _filename;
     bool _force_flush;
 
 
 };
 }
 }
-
diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h
index 6af4771e..5748033b 100644
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@@ -147,37 +147,17 @@ constexpr inline unsigned short eol_size()
 #endif
 
 //fopen_s on non windows for writing
-inline int fopen_s(FILE** fp, const tstring& filename, const tchar* mode)
+inline int fopen_s(FILE** fp, const std::string& filename, const char* mode)
 {
-#if defined(WIN32)
-  #if defined(SPDLOG_USE_WCHAR)
-    *fp = _wfsopen((filename.c_str()), mode, _SH_DENYWR);
-  #else
+#ifdef _WIN32
     *fp = _fsopen((filename.c_str()), mode, _SH_DENYWR);
-  #endif
     return *fp == nullptr;
 #else
     *fp = fopen((filename.c_str()), mode);
     return *fp == nullptr;
 #endif
-}
 
-inline int remove(const tchar* filename)
-{
-#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
-    return _wremove(filename);
-#else
-    return std::remove(filename);
-#endif
-}
 
-inline int rename(const tchar* filename1, const tchar* filename2)
-{
-#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
-    return _wrename(filename1, filename2);
-#else
-    return std::rename(filename1, filename2);
-#endif
 }
 
 //Return utc offset in minutes or -1 on failure
@@ -215,4 +195,3 @@ inline size_t thread_id()
 } //spdlog
 
 
-
diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h
index 2530b596..cfd6f826 100644
--- a/include/spdlog/details/spdlog_impl.h
+++ b/include/spdlog/details/spdlog_impl.h
@@ -48,24 +48,24 @@ inline void spdlog::drop(const std::string &name)
 }
 
 // Create multi/single threaded rotating file logger
-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const tstring& filename, size_t max_file_size, size_t max_files, bool force_flush)
+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, S("txt"), max_file_size, max_files, 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 tstring& filename, size_t max_file_size, size_t max_files, bool 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, S("txt"), max_file_size, max_files, 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 tstring& filename, int hour, int minute, bool force_flush)
+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, S("txt"), hour, minute, 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 tstring& filename, int hour, int minute, bool 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, S("txt"), hour, minute, force_flush);
+    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", hour, minute, force_flush);
 }
 
 
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 0f0824e7..8d36f316 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -29,7 +29,6 @@
 #include "../details/null_mutex.h"
 #include "../details/file_helper.h"
 #include "../details/format.h"
-#include "../details/os.h"
 
 namespace spdlog
 {
@@ -66,13 +65,13 @@ 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
- */
+* Rotating file sink based on size
+*/
 template<class Mutex>
 class rotating_file_sink : public base_sink < Mutex >
 {
 public:
-    rotating_file_sink(const tstring &base_filename, const tstring &extension,
+    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),
@@ -103,13 +102,13 @@ protected:
     }
 
 private:
-    static tstring calc_filename(const tstring& filename, std::size_t index, const tstring& extension)
+    static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
     {
-        fmt::TMemoryWriter w;
+        fmt::MemoryWriter w;
         if (index)
-            w.write(S("{}.{}.{}"), filename, index, extension);
+            w.write("{}.{}.{}", filename, index, extension);
         else
-            w.write(S("{}.{}"), filename, extension);
+            w.write("{}.{}", filename, extension);
         return w.str();
     }
 
@@ -124,25 +123,25 @@ private:
         _file_helper.close();
         for (auto i = _max_files; i > 0; --i)
         {
-            tstring src = calc_filename(_base_filename, i - 1, _extension);
-            tstring target = calc_filename(_base_filename, i, _extension);
+            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 (details::os::remove(target.c_str()) != 0)
+                if (std::remove(target.c_str()) != 0)
                 {
-                    throw spdlog_ex("rotating_file_sink: failed removing");
+                    throw spdlog_ex("rotating_file_sink: failed removing " + target);
                 }
             }
-            if (details::file_helper::file_exists(src) && details::os::rename(src.c_str(), target.c_str()))
+            if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str()))
             {
-                throw spdlog_ex("rotating_file_sink: failed renaming");
+                throw spdlog_ex("rotating_file_sink: failed renaming " + src + " to " + target);
             }
         }
         _file_helper.reopen(true);
     }
-    tstring _base_filename;
-    tstring _extension;
+    std::string _base_filename;
+    std::string _extension;
     std::size_t _max_size;
     std::size_t _max_files;
     std::size_t _current_size;
@@ -153,16 +152,16 @@ 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
- */
+* 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 tstring& base_filename,
-        const tstring& extension,
+        const std::string& base_filename,
+        const std::string& extension,
         int rotation_hour,
         int rotation_minute,
         bool force_flush = false) : _base_filename(base_filename),
@@ -211,16 +210,16 @@ private:
     }
 
     //Create filename for the form basename.YYYY-MM-DD.extension
-    static tstring calc_filename(const tstring& basename, const tstring& extension)
+    static std::string calc_filename(const std::string& basename, const std::string& extension)
     {
         std::tm tm = spdlog::details::os::localtime();
-        fmt::TMemoryWriter w;
-        w.write(S("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension);
+        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();
     }
 
-    tstring _base_filename;
-    tstring _extension;
+    std::string _base_filename;
+    std::string _extension;
     int _rotation_h;
     int _rotation_m;
     std::chrono::system_clock::time_point _rotation_tp;
@@ -230,4 +229,4 @@ private:
 typedef daily_file_sink<std::mutex> daily_file_sink_mt;
 typedef daily_file_sink<details::null_mutex> daily_file_sink_st;
 }
-}
+}
\ No newline at end of file
diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index 61e9a8b3..aef04069 100644
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -76,14 +76,14 @@ 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 tstring& filename, 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 tstring& filename, size_t max_file_size, size_t max_files, bool force_flush = false);
+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 tstring& filename, int hour=0, int minute=0, bool force_flush = false);
-std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const tstring& filename, int hour=0, int minute=0, bool force_flush = false);
+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);
 
 
 //
diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h
index 7e0bb41b..b651658b 100644
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -72,9 +72,3 @@
 // Note that upon creating a logger the registry is modified by spdlog..
 // #define SPDLOG_NO_REGISTRY_MUTEX
 ///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable usage of wchar_t for file names on Windows.
-// #define SPDLOG_USE_WCHAR
-///////////////////////////////////////////////////////////////////////////////

From 77acf29c4db13a1dd1ae0f3a668bf8496e9ba97a Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 7 Aug 2015 14:06:22 +0300
Subject: [PATCH 56/61] Updated to latest cppformat lib

---
 include/spdlog/details/format.cc | 58 +++++++++++------------
 include/spdlog/details/format.h  | 79 +++++++++++++++++++-------------
 2 files changed, 74 insertions(+), 63 deletions(-)

diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc
index fb0ef9ea..828f0ee8 100644
--- a/include/spdlog/details/format.cc
+++ b/include/spdlog/details/format.cc
@@ -207,8 +207,8 @@ int safe_strerror(
         }
 
     public:
-        StrError(int error_code, char *&buffer, std::size_t buffer_size)
-            : error_code_(error_code), buffer_(buffer), buffer_size_(buffer_size) {}
+        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.
@@ -521,25 +521,25 @@ public:
         : BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}
 
     void visit_char(int value) {
-        const FormatSpec &spec = this->spec();
-        BasicWriter<Char> &writer = this->writer();
-        if (spec.type_ && spec.type_ != 'c')
-            writer.write_int(value, spec);
+        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 (spec.width_ > 1) {
+        if (fmt_spec.width_ > 1) {
             Char fill = ' ';
-            out = writer.grow_buffer(spec.width_);
-            if (spec.align_ != ALIGN_LEFT) {
-                std::fill_n(out, spec.width_ - 1, fill);
-                out += spec.width_ - 1;
+            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, spec.width_ - 1, fill);
+                std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
             }
         }
         else {
-            out = writer.grow_buffer(1);
+            out = w.grow_buffer(1);
         }
         *out = static_cast<Char>(value);
     }
@@ -959,10 +959,8 @@ unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
 
 template <typename Char>
 void fmt::internal::PrintfFormatter<Char>::format(
-    BasicWriter<Char> &writer, BasicCStringRef<Char> format_str,
-    const ArgList &args) {
+    BasicWriter<Char> &writer, BasicCStringRef<Char> format_str) {
     const Char *start = format_str.c_str();
-    set_args(args);
     const Char *s = start;
     while (*s) {
         Char c = *s++;
@@ -1227,7 +1225,6 @@ const Char *fmt::BasicFormatter<Char>::format(
 
     if (*s++ != '}')
         FMT_THROW(FormatError("missing '}' in format string"));
-    start_ = s;
 
     // Format argument.
     internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg);
@@ -1235,25 +1232,24 @@ const Char *fmt::BasicFormatter<Char>::format(
 }
 
 template <typename Char>
-void fmt::BasicFormatter<Char>::format(
-    BasicCStringRef<Char> format_str, const ArgList &args) {
-    const Char *s = start_ = format_str.c_str();
-    set_args(args);
+void fmt::BasicFormatter<Char>::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;
+            write(writer_, start, s);
+            start = ++s;
             continue;
         }
         if (c == '}')
             FMT_THROW(FormatError("unmatched '}' in format string"));
-        write(writer_, start_, s - 1);
+        write(writer_, start, s - 1);
         Arg arg = is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
-        s = format(s, arg);
+        start = s = format(s, arg);
     }
-    write(writer_, start_, s);
+    write(writer_, start, s);
 }
 
 FMT_FUNC void fmt::report_system_error(
@@ -1310,11 +1306,10 @@ template void fmt::internal::FixedBuffer<char>::grow(std::size_t);
 template const char *fmt::BasicFormatter<char>::format(
     const char *&format_str, const fmt::internal::Arg &arg);
 
-template void fmt::BasicFormatter<char>::format(
-    CStringRef format, const ArgList &args);
+template void fmt::BasicFormatter<char>::format(CStringRef format);
 
 template void fmt::internal::PrintfFormatter<char>::format(
-    BasicWriter<char> &writer, CStringRef format, const ArgList &args);
+    BasicWriter<char> &writer, CStringRef format);
 
 template int fmt::internal::CharTraits<char>::format_float(
     char *buffer, std::size_t size, const char *format,
@@ -1332,11 +1327,10 @@ template const wchar_t *fmt::BasicFormatter<wchar_t>::format(
     const wchar_t *&format_str, const fmt::internal::Arg &arg);
 
 template void fmt::BasicFormatter<wchar_t>::format(
-    BasicCStringRef<wchar_t> format, const ArgList &args);
+    BasicCStringRef<wchar_t> format);
 
 template void fmt::internal::PrintfFormatter<wchar_t>::format(
-    BasicWriter<wchar_t> &writer, WCStringRef format,
-    const ArgList &args);
+    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,
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index aaeb011d..bf02fc72 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -27,7 +27,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef FMT_FORMAT_H_
 #define FMT_FORMAT_H_
-
 #define FMT_HEADER_ONLY
 
 #include <stdint.h>
@@ -763,24 +762,23 @@ inline unsigned count_digits(uint32_t n) {
 // 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) {
-    --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 = (value % 100) * 2;
         value /= 100;
-        buffer[num_digits] = Data::DIGITS[index + 1];
-        buffer[num_digits - 1] = Data::DIGITS[index];
-        num_digits -= 2;
+        *--buffer = Data::DIGITS[index + 1];
+        *--buffer = Data::DIGITS[index];
     }
     if (value < 10) {
-        *buffer = static_cast<char>('0' + value);
+        *--buffer = static_cast<char>('0' + value);
         return;
     }
     unsigned index = static_cast<unsigned>(value * 2);
-    buffer[1] = Data::DIGITS[index + 1];
-    buffer[0] = Data::DIGITS[index];
+    *--buffer = Data::DIGITS[index + 1];
+    *--buffer = Data::DIGITS[index];
 }
 
 #ifndef _WIN32
@@ -924,11 +922,11 @@ private:
 
     static const T &get();
 
-    static yes &check(fmt::ULongLong);
-    static no &check(...);
+    static yes &convert(fmt::ULongLong);
+    static no &convert(...);
 
 public:
-    enum { value = (sizeof(check(get())) == sizeof(yes)) };
+    enum { value = (sizeof(convert(get())) == sizeof(yes)) };
 };
 
 #define FMT_CONVERTIBLE_TO_INT(Type) \
@@ -1127,8 +1125,8 @@ struct NamedArg : Arg {
     BasicStringRef<Char> name;
 
     template <typename T>
-    NamedArg(BasicStringRef<Char> name, const T &value)
-        : name(name), Arg(MakeValue<Char>(value)) {
+    NamedArg(BasicStringRef<Char> argname, const T &value)
+        : name(argname), Arg(MakeValue<Char>(value)) {
         type = static_cast<internal::Arg::Type>(MakeValue<Char>::type(value));
     }
 };
@@ -1363,7 +1361,7 @@ protected:
         return args_;
     }
 
-    void set_args(const ArgList &args) {
+    explicit FormatterBase(const ArgList &args) {
         args_ = args;
         next_arg_index_ = 0;
     }
@@ -1399,8 +1397,8 @@ private:
     unsigned parse_header(const Char *&s, FormatSpec &spec);
 
 public:
-    void format(BasicWriter<Char> &writer,
-                BasicCStringRef<Char> format_str, const ArgList &args);
+    explicit PrintfFormatter(const ArgList &args) : FormatterBase(args) {}
+    void format(BasicWriter<Char> &writer, BasicCStringRef<Char> format_str);
 };
 }  // namespace internal
 
@@ -1409,7 +1407,6 @@ template <typename Char>
 class BasicFormatter : private internal::FormatterBase {
 private:
     BasicWriter<Char> &writer_;
-    const Char *start_;
     internal::ArgMap<Char> map_;
 
     FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
@@ -1427,13 +1424,14 @@ private:
     internal::Arg parse_arg_name(const Char *&s);
 
 public:
-    explicit BasicFormatter(BasicWriter<Char> &w) : writer_(w) {}
+    BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
+        : FormatterBase(args), writer_(w) {}
 
     BasicWriter<Char> &writer() {
         return writer_;
     }
 
-    void format(BasicCStringRef<Char> format_str, const ArgList &args);
+    void format(BasicCStringRef<Char> format_str);
 
     const Char *format(const Char *&format_str, const internal::Arg &arg);
 };
@@ -1996,6 +1994,28 @@ private:
         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) {
+        typename internal::IntTraits<Int>::MainType abs_value = 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) {
@@ -2123,24 +2143,27 @@ public:
     \endrst
     */
     void write(BasicCStringRef<Char> format, ArgList args) {
-        BasicFormatter<Char>(*this).format(format, args);
+        BasicFormatter<Char>(args, *this).format(format);
     }
     FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
 
     BasicWriter &operator<<(int value) {
-        return *this << IntFormatSpec<int>(value);
+        write_decimal(value);
+        return *this;
     }
     BasicWriter &operator<<(unsigned value) {
         return *this << IntFormatSpec<unsigned>(value);
     }
     BasicWriter &operator<<(long value) {
-        return *this << IntFormatSpec<long>(value);
+        write_decimal(value);
+        return *this;
     }
     BasicWriter &operator<<(unsigned long value) {
         return *this << IntFormatSpec<unsigned long>(value);
     }
     BasicWriter &operator<<(LongLong value) {
-        return *this << IntFormatSpec<LongLong>(value);
+        write_decimal(value);
+        return *this;
     }
 
     /**
@@ -2638,12 +2661,6 @@ public:
 typedef BasicMemoryWriter<char> MemoryWriter;
 typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
 
-#if defined(WIN32) && defined(SPDLOG_USE_WCHAR)
-#define TMemoryWriter WMemoryWriter
-#else
-#define TMemoryWriter MemoryWriter
-#endif
-
 /**
 \rst
 This class template provides operations for formatting and writing data
@@ -2823,7 +2840,7 @@ void print(std::ostream &os, CStringRef format_str, ArgList args);
 
 template <typename Char>
 void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args) {
-    internal::PrintfFormatter<Char>().format(w, format, args);
+    internal::PrintfFormatter<Char>(args).format(w, format);
 }
 
 /**
@@ -3158,4 +3175,4 @@ FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
 # include "format.cc"
 #endif
 
-#endif  // FMT_FORMAT_H_
+#endif  // FMT_FORMAT_H_
\ No newline at end of file

From 1b78a661c75af27393330760c24718fe3f42a4ed Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Fri, 7 Aug 2015 14:38:44 +0300
Subject: [PATCH 57/61] Update .travis.yml

---
 .travis.yml | 34 ----------------------------------
 1 file changed, 34 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 6018b7f1..3557a2f9 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -33,40 +33,6 @@ matrix:
       addons: *clang35
     
 
-    # Test clang-3.7: C++11/C++14, Buidd=Debug/Release, ASAN=On/Off
-    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=On LIBCXX=On
-      os: linux
-      addons: &clang37
-        apt:
-          packages:
-            - clang-3.7
-            - valgrind
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise
-
-    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang37
-    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang37
-    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=On LIBCXX=On
-      os: linux
-      addons: *clang37
-    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang37
-    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=11 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang37
-    - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug CPP=14 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang37
-    - env: CLANG_VERSION=3.7 BUILD_TYPE=Release CPP=14 ASAN=Off LIBCXX=On
-      os: linux
-      addons: *clang37
-
 
 # Test gcc-4.8: C++11, Build=Debug/Release, ASAN=Off
     - env: GCC_VERSION=4.8 BUILD_TYPE=Debug CPP=11 ASAN=Off LIBCXX=Off

From ec4233f236298119a6473b8c0a1680fdc5473a72 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 14 Aug 2015 20:25:44 +0300
Subject: [PATCH 58/61] Fixed warnings conversion 'size_t' to 'int' on windows
 issue #119

---
 include/spdlog/details/format.cc | 1751 ++++++++-------
 include/spdlog/details/format.h  | 3440 ++++++++++++++----------------
 2 files changed, 2500 insertions(+), 2691 deletions(-)

diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc
index 828f0ee8..873d8274 100644
--- a/include/spdlog/details/format.cc
+++ b/include/spdlog/details/format.cc
@@ -1,29 +1,29 @@
 /*
-Formatting library for C++
+ Formatting library for C++
 
-Copyright (c) 2012 - 2015, Victor Zverovich
-All rights reserved.
+ 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:
+ 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.
+ 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.
-*/
+ 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"
 
@@ -96,10 +96,10 @@ using fmt::internal::Arg;
 // 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<>();
+  return fmt::internal::Null<>();
 }
 static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
-    return fmt::internal::Null<>();
+  return fmt::internal::Null<>();
 }
 
 namespace fmt {
@@ -109,11 +109,11 @@ namespace {
 # 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;
+  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
@@ -128,27 +128,25 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
 // 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 <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;
-    }
+  template <typename T>
+  static bool fits_in_int(T value) {
+    return value >= INT_MIN && value <= INT_MAX;
+  }
 };
 
 const char RESET_COLOR[] = "\x1b[0m";
 
-typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
+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.
@@ -160,248 +158,243 @@ typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
 //   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");
+    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_;
+  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 &) {}
+    // 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 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 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_));
-        }
+    // 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 ?
+    // 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;
-        }
+    // 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) {}
+   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();
+    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 ";
-    fmt::internal::IntTraits<int>::MainType ec_value = error_code;
-    // 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;
-    error_code_size += fmt::internal::count_digits(ec_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);
+                       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 ";
+  fmt::internal::IntTraits<int>::MainType ec_value = error_code;
+  // 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;
+  error_code_size += fmt::internal::count_digits(ec_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);
+    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;
-    }
+ public:
+  template <typename T>
+  bool visit_any_int(T value) { return value == 0; }
 };
 
 // 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>
 int 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 = UINT_MAX;
-            break;
-        }
-        value = new_value;
-    } while ('0' <= *s && *s <= '9');
-    if (value > INT_MAX)
-        FMT_THROW(fmt::FormatError("number is too big"));
-    return value;
+  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 = UINT_MAX;
+      break;
+    }
+    value = new_value;
+  } while ('0' <= *s && *s <= '9');
+  if (value > INT_MAX)
+    FMT_THROW(fmt::FormatError("number is too big"));
+  return value;
 }
 
 template <typename Char>
 inline bool is_name_start(Char c) {
-    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
+  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
 }
 
 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));
-    }
+  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(fmt::FormatError(fmt::format(
-                                       "format specifier '{}' requires signed argument", sign)));
-    }
-    ++s;
+  char sign = static_cast<char>(*s);
+  require_numeric_argument(arg, sign);
+  if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
+    FMT_THROW(fmt::FormatError(fmt::format(
+      "format specifier '{}' requires signed argument", sign)));
+  }
+  ++s;
 }
 
 // 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_;
+ private:
+  fmt::FormatSpec &spec_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
+  FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
 
-public:
-    explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}
+ 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 = 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);
+  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 = 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"));
-    }
+ 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>
+  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);
+  }
 };
 
 // Converts an integer argument to an integral type T for printf.
 template <typename T>
 class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
-private:
-    fmt::internal::Arg &arg_;
-    wchar_t type_;
+ private:
+  fmt::internal::Arg &arg_;
+  wchar_t type_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
+  FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
 
-public:
-    ArgConverter(fmt::internal::Arg &arg, wchar_t type)
-        : arg_(arg), type_(type) {}
+ public:
+  ArgConverter(fmt::internal::Arg &arg, wchar_t type)
+    : arg_(arg), type_(type) {}
 
-    template <typename U>
-    void visit_any_int(U value) {
-        bool is_signed = type_ == 'd' || type_ == 'i';
-        using fmt::internal::Arg;
-        if (sizeof(T) <= sizeof(int)) {
-            // Extra casts are used to silence warnings.
-            if (is_signed) {
-                arg_.type = Arg::INT;
-                arg_.int_value = static_cast<int>(static_cast<T>(value));
-            }
-            else {
-                arg_.type = Arg::UINT;
-                arg_.uint_value = static_cast<unsigned>(
-                                      static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));
-            }
-        }
-        else {
-            if (is_signed) {
-                arg_.type = Arg::LONG_LONG;
-                arg_.long_long_value =
-                    static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
-            }
-            else {
-                arg_.type = Arg::ULONG_LONG;
-                arg_.ulong_long_value =
-                    static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
-            }
-        }
+  template <typename U>
+  void visit_any_int(U value) {
+    bool is_signed = type_ == 'd' || type_ == 'i';
+    using fmt::internal::Arg;
+    if (sizeof(T) <= sizeof(int)) {
+      // Extra casts are used to silence warnings.
+      if (is_signed) {
+        arg_.type = Arg::INT;
+        arg_.int_value = static_cast<int>(static_cast<T>(value));
+      } else {
+        arg_.type = Arg::UINT;
+        arg_.uint_value = static_cast<unsigned>(
+            static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));
+      }
+    } else {
+      if (is_signed) {
+        arg_.type = Arg::LONG_LONG;
+        arg_.long_long_value =
+            static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(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_;
+ private:
+  fmt::internal::Arg &arg_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
+  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
 
-public:
-    explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}
+ 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);
-    }
+  template <typename T>
+  void visit_any_int(T value) {
+    arg_.type = Arg::CHAR;
+    arg_.int_value = static_cast<char>(value);
+  }
 };
 }  // namespace
 
@@ -409,179 +402,166 @@ namespace internal {
 
 template <typename Impl, typename Char>
 class BasicArgFormatter : public ArgVisitor<Impl, void> {
-private:
-    BasicWriter<Char> &writer_;
-    FormatSpec &spec_;
+ private:
+  BasicWriter<Char> &writer_;
+  FormatSpec &spec_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter);
+  FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter);
 
-protected:
-    BasicWriter<Char> &writer() {
-        return writer_;
+ protected:
+  BasicWriter<Char> &writer() { return writer_; }
+  const FormatSpec &spec() const { return spec_; }
+
+ public:
+  BasicArgFormatter(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_) {
+      writer_.write_int(value, spec_);
+      return;
     }
-    const FormatSpec &spec() const {
-        return spec_;
+    const char *str_value = value ? "true" : "false";
+    Arg::StringValue<char> str = { str_value, strlen(str_value) };
+    writer_.write_str(str, spec_);
+  }
+
+  void visit_char(int value) {
+    if (spec_.type_ && spec_.type_ != 'c') {
+      spec_.flags_ |= CHAR_FLAG;
+      writer_.write_int(value, spec_);
+      return;
     }
-
-public:
-    BasicArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
-        : writer_(w), spec_(s) {}
-
-    template <typename T>
-    void visit_any_int(T value) {
-        writer_.write_int(value, spec_);
+    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();
+    if (spec_.width_ > 1) {
+      out = writer_.grow_buffer(spec_.width_);
+      if (spec_.align_ == ALIGN_RIGHT) {
+        std::fill_n(out, spec_.width_ - 1, fill);
+        out += spec_.width_ - 1;
+      } else if (spec_.align_ == ALIGN_CENTER) {
+        out = writer_.fill_padding(out, spec_.width_, 1, fill);
+      } else {
+        std::fill_n(out + 1, spec_.width_ - 1, fill);
+      }
+    } else {
+      out = writer_.grow_buffer(1);
     }
+    *out = internal::CharTraits<Char>::cast(value);
+  }
 
-    template <typename T>
-    void visit_any_double(T value) {
-        writer_.write_double(value, spec_);
-    }
+  void visit_string(Arg::StringValue<char> value) {
+    writer_.write_str(value, spec_);
+  }
 
-    void visit_bool(bool value) {
-        if (spec_.type_) {
-            writer_.write_int(value, spec_);
-            return;
-        }
-        const char *str_value = value ? "true" : "false";
-        Arg::StringValue<char> str = { str_value, strlen(str_value) };
-        writer_.write_str(str, spec_);
-    }
+  using ArgVisitor<Impl, void>::visit_wstring;
 
-    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();
-        if (spec_.width_ > 1) {
-            out = writer_.grow_buffer(spec_.width_);
-            if (spec_.align_ == ALIGN_RIGHT) {
-                std::fill_n(out, spec_.width_ - 1, fill);
-                out += spec_.width_ - 1;
-            }
-            else if (spec_.align_ == ALIGN_CENTER) {
-                out = writer_.fill_padding(out, spec_.width_, 1, fill);
-            }
-            else {
-                std::fill_n(out + 1, spec_.width_ - 1, fill);
-            }
-        }
-        else {
-            out = writer_.grow_buffer(1);
-        }
-        *out = internal::CharTraits<Char>::cast(value);
-    }
+  void visit_wstring(Arg::StringValue<Char> value) {
+    writer_.write_str(value, spec_);
+  }
 
-    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");
-        spec_.flags_ = HASH_FLAG;
-        spec_.type_ = 'x';
-        writer_.write_int(reinterpret_cast<uintptr_t>(value), spec_);
-    }
+  void visit_pointer(const void *value) {
+    if (spec_.type_ && spec_.type_ != 'p')
+      report_unknown_type(spec_.type_, "pointer");
+    spec_.flags_ = HASH_FLAG;
+    spec_.type_ = 'x';
+    writer_.write_int(reinterpret_cast<uintptr_t>(value), spec_);
+  }
 };
 
 // An argument formatter.
 template <typename Char>
 class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char> {
-private:
-    BasicFormatter<Char> &formatter_;
-    const Char *format_;
+ private:
+  BasicFormatter<Char> &formatter_;
+  const Char *format_;
 
-public:
-    ArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)
-        : BasicArgFormatter<ArgFormatter<Char>, Char>(f.writer(), s),
-          formatter_(f), format_(fmt) {}
+ public:
+  ArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)
+  : BasicArgFormatter<ArgFormatter<Char>, Char>(f.writer(), s),
+    formatter_(f), format_(fmt) {}
 
-    void visit_custom(Arg::CustomValue c) {
-        c.format(&formatter_, c.value, &format_);
-    }
+  void visit_custom(Arg::CustomValue c) {
+    c.format(&formatter_, c.value, &format_);
+  }
 };
 
 template <typename Char>
 class PrintfArgFormatter :
     public BasicArgFormatter<PrintfArgFormatter<Char>, Char> {
-public:
-    PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
-        : BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}
+ public:
+  PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
+  : BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}
 
-    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_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);
+  }
 };
 }  // 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());
+  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);
-    }
+  if (width == 0) {
     return precision < 0 ?
-           FMT_SNPRINTF(buffer, size, format, width, value) :
-           FMT_SNPRINTF(buffer, size, format, width, precision, value);
+        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);
-    }
+  if (width == 0) {
     return precision < 0 ?
-           FMT_SWPRINTF(buffer, size, format, width, value) :
-           FMT_SWPRINTF(buffer, size, format, width, precision, value);
+        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>
@@ -605,694 +585,685 @@ const char fmt::internal::BasicData<T>::DIGITS[] =
 
 template <typename T>
 const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
-    0, FMT_POWERS_OF_10(1)
+  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
+  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)));
-    }
+  (void)type;
+  if (std::isprint(static_cast<unsigned char>(code))) {
     FMT_THROW(fmt::FormatError(
-                  fmt::format("unknown format code '\\x{:02x}' for {}",
-                              static_cast<unsigned>(code), type)));
+        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) {
-    int length = MultiByteToWideChar(
-                     CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s.size(), 0, 0);
-    static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
-    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;
+  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"));
-    }
+  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) {
-    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;
+  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());
+  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{
-    class String {
-    private:
-        LPWSTR str_;
+    fmt::StringRef message) FMT_NOEXCEPT {
+  class String {
+   private:
+    LPWSTR str_;
 
-    public:
-        String() : str_() {}
-        ~String() {
-            LocalFree(str_);
-        }
-        LPWSTR *ptr() {
-            return &str_;
-        }
-        LPCWSTR c_str() const { return str_; }
-    };
-    FMT_TRY{
-        String system_message;
-        if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+   public:
+    String() : str_() {}
+    ~String() { LocalFree(str_); }
+    LPWSTR *ptr() { return &str_; }
+    LPCWSTR c_str() const { return str_; }
+  };
+  FMT_TRY {
+    String system_message;
+    if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
         FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
         error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
         reinterpret_cast<LPWSTR>(system_message.ptr()), 0, 0)) {
-            UTF16ToUTF8 utf8_message;
-            if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) {
-                out << message << ": " << utf8_message;
-                return;
-            }
-        }
-    } FMT_CATCH(...) {}
-    format_error_code(out, error_code, message);
+      UTF16ToUTF8 utf8_message;
+      if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) {
+        out << message << ": " << utf8_message;
+        return;
+      }
+    }
+  } FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
 }
 
 #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(...) {}
-    format_error_code(out, error_code, message);
+    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(...) {}
+  format_error_code(out, error_code, message);
 }
 
 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_.insert(Pair(named_arg->name, *named_arg));
-                break;
-            default:
-                /*nothing*/
-                ;
-            }
-        }
+  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_.insert(Pair(named_arg->name, *named_arg));
+        break;
+      default:
+        /*nothing*/;
+      }
     }
-    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_.insert(Pair(named_arg->name, *named_arg));
-        }
+    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_.insert(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_.insert(Pair(named_arg->name, *named_arg));
-            break;
-        default:
-            /*nothing*/
-            ;
-        }
+  }
+  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_.insert(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_THROW(std::runtime_error("buffer overflow"));
 }
 
 template <typename Char>
 template <typename StrChar>
 void fmt::BasicWriter<Char>::write_str(
     const 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"));
-        if (*str_value)
-            str_size = std::char_traits<StrChar>::length(str_value);
-    }
-    std::size_t precision = spec.precision_;
-    if (spec.precision_ >= 0 && precision < str_size)
-        str_size = spec.precision_;
-    write_str(str_value, str_size, 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"));
+    if (*str_value)
+      str_size = std::char_traits<StrChar>::length(str_value);
+  }
+  std::size_t precision = spec.precision_;
+  if (spec.precision_ >= 0 && precision < str_size)
+    str_size = spec.precision_;
+  write_str(str_value, str_size, spec);
 }
 
 template <typename Char>
 inline Arg fmt::BasicFormatter<Char>::get_arg(
-    BasicStringRef<Char> arg_name, const char *&error) {
-    if (check_no_auto_index(error)) {
-        map_.init(args());
-        const Arg *arg = map_.find(arg_name);
-        if (arg)
-            return *arg;
-        error = "argument not found";
-    }
-    return Arg();
+  BasicStringRef<Char> arg_name, const char *&error) {
+  if (check_no_auto_index(error)) {
+    map_.init(args());
+    const Arg *arg = map_.find(arg_name);
+    if (arg)
+      return *arg;
+    error = "argument not found";
+  }
+  return Arg();
 }
 
 template <typename Char>
 inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
-    const char *error = 0;
-    Arg arg = *s < '0' || *s > '9' ?
-              next_arg(error) : get_arg(parse_nonnegative_int(s), error);
-    if (error) {
-        FMT_THROW(FormatError(
-                      *s != '}' && *s != ':' ? "invalid format string" : error));
-    }
-    return arg;
+  const char *error = 0;
+  Arg arg = *s < '0' || *s > '9' ?
+        next_arg(error) : get_arg(parse_nonnegative_int(s), error);
+  if (error) {
+    FMT_THROW(FormatError(
+                *s != '}' && *s != ':' ? "invalid format string" : error));
+  }
+  return arg;
 }
 
 template <typename Char>
 inline Arg fmt::BasicFormatter<Char>::parse_arg_name(const Char *&s) {
-    assert(is_name_start(*s));
-    const Char *start = s;
-    Char c;
-    do {
-        c = *++s;
-    } while (is_name_start(c) || ('0' <= c && c <= '9'));
-    const char *error = 0;
-    Arg arg = get_arg(fmt::BasicStringRef<Char>(start, s - start), error);
-    if (error)
-        FMT_THROW(fmt::FormatError(error));
-    return arg;
+  assert(is_name_start(*s));
+  const Char *start = s;
+  Char c;
+  do {
+    c = *++s;
+  } while (is_name_start(c) || ('0' <= c && c <= '9'));
+  const char *error = 0;
+  Arg arg = get_arg(fmt::BasicStringRef<Char>(start, s - start), error);
+  if (error)
+    FMT_THROW(fmt::FormatError(error));
+  return arg;
 }
 
 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);
-    default:
-        /*nothing*/
-        ;
-    }
-    return arg;
+  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);
+  default:
+    /*nothing*/;
+  }
+  return arg;
 }
 
 inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) {
-    if (next_arg_index_ >= 0)
-        return do_get_arg(next_arg_index_++, error);
-    error = "cannot switch from manual to automatic argument indexing";
-    return Arg();
+  if (next_arg_index_ >= 0)
+    return do_get_arg(next_arg_index_++, error);
+  error = "cannot switch from manual to automatic argument indexing";
+  return Arg();
 }
 
 inline bool fmt::internal::FormatterBase::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;
+  if (next_arg_index_ > 0) {
+    error = "cannot switch from automatic to manual argument indexing";
+    return false;
+  }
+  next_arg_index_ = -1;
+  return true;
 }
 
 inline Arg fmt::internal::FormatterBase::get_arg(
     unsigned arg_index, const char *&error) {
-    return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
+  return check_no_auto_index(error) ? do_get_arg(arg_index, error) : 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;
-        }
+  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;
+  (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;
-            }
-        }
+  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;
+  }
+  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_ = 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_ &= ~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<size_t>(arg, *s).visit(arg);
-            break;
-        case 't':
-            ArgConverter<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<int>(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);
+  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);
+    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_ = 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_ &= ~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<size_t>(arg, *s).visit(arg);
+      break;
+    case 't':
+      ArgConverter<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<int>(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);
 }
 
 template <typename Char>
 const Char *fmt::BasicFormatter<Char>::format(
     const Char *&format_str, const Arg &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;
+  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 '-':
-            check_sign(s, arg);
-            spec.flags_ |= MINUS_FLAG;
+          case '>':
+            spec.align_ = ALIGN_RIGHT;
             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');
+          case '=':
             spec.align_ = ALIGN_NUMERIC;
-            spec.fill_ = '0';
-            ++s;
+            break;
+          case '^':
+            spec.align_ = ALIGN_CENTER;
+            break;
         }
-
-        // Parse width.
-        if ('0' <= *s && *s <= '9') {
-            spec.width_ = parse_nonnegative_int(s);
+        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;
         }
-        else if (*s == '{') {
-            ++s;
-            Arg width_arg = 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 > 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_ = parse_nonnegative_int(s);
-            }
-            else if (*s == '{') {
-                ++s;
-                Arg precision_arg =
-                    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 > 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++);
+      } while (--p >= s);
     }
 
-    if (*s++ != '}')
-        FMT_THROW(FormatError("missing '}' in format string"));
+    // 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;
+    }
 
-    // Format argument.
-    internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg);
-    return s;
+    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_ = parse_nonnegative_int(s);
+    } else if (*s == '{') {
+      ++s;
+      Arg width_arg = 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 > 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_ = parse_nonnegative_int(s);
+      } else if (*s == '{') {
+        ++s;
+        Arg precision_arg =
+            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 > 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.
+  internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg);
+  return s;
 }
 
 template <typename Char>
 void fmt::BasicFormatter<Char>::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);
-        Arg arg = is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
-        start = s = format(s, arg);
+  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;
     }
-    write(writer_, start, s);
+    if (c == '}')
+      FMT_THROW(FormatError("unmatched '}' in format string"));
+    write(writer_, start, s - 1);
+    Arg arg = is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
+    start = s = format(s, arg);
+  }
+  write(writer_, start, s);
 }
 
 FMT_FUNC void fmt::report_system_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT{
-    report_error(internal::format_system_error, error_code, message);
+    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
+  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{
-    report_error(internal::format_windows_error, error_code, message);
+    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
+  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);
+  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);
+  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);
-    os.write(w.data(), w.size());
+  MemoryWriter w;
+  w.write(format_str, args);
+  os.write(w.data(), w.size());
 }
 
 FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
-    char escape[] = "\x1b[30m";
-    escape[3] = '0' + static_cast<char>(c);
-    std::fputs(escape, stdout);
-    print(format, args);
-    std::fputs(RESET_COLOR, stdout);
+  char escape[] = "\x1b[30m";
+  escape[3] = '0' + static_cast<char>(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);
+  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);
 }
 
 #ifndef FMT_HEADER_ONLY
@@ -1309,7 +1280,7 @@ template const char *fmt::BasicFormatter<char>::format(
 template void fmt::BasicFormatter<char>::format(CStringRef format);
 
 template void fmt::internal::PrintfFormatter<char>::format(
-    BasicWriter<char> &writer, CStringRef format);
+  BasicWriter<char> &writer, CStringRef format);
 
 template int fmt::internal::CharTraits<char>::format_float(
     char *buffer, std::size_t size, const char *format,
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index bf02fc72..8e55b29f 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -1,29 +1,29 @@
 /*
-Formatting library for C++
+ Formatting library for C++
 
-Copyright (c) 2012 - 2015, Victor Zverovich
-All rights reserved.
+ 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:
+ 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.
+ 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.
-*/
+ 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_
@@ -53,9 +53,9 @@ namespace fmt {
 namespace internal {
 # pragma intrinsic(_BitScanReverse)
 inline uint32_t clz(uint32_t x) {
-    unsigned long r = 0;
-    _BitScanReverse(&r, x);
-    return 31 - r;
+  unsigned long r = 0;
+  _BitScanReverse(&r, x);
+  return 31 - r;
 }
 # define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
 
@@ -64,18 +64,18 @@ inline uint32_t clz(uint32_t x) {
 # endif
 
 inline uint32_t clzll(uint64_t x) {
-    unsigned long r = 0;
+  unsigned long r = 0;
 # ifdef _WIN64
-    _BitScanReverse64(&r, x);
+  _BitScanReverse64(&r, x);
 # else
-    // Scan the high 32 bits.
-    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
-        return 63 - (r + 32);
+  // 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));
+  // Scan the low 32 bits.
+  _BitScanReverse(&r, static_cast<uint32_t>(x));
 # endif
-    return 63 - r;
+  return 63 - r;
 }
 # define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
 }
@@ -206,85 +206,81 @@ 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``.
+  \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:
 
-You can use one of the following typedefs for common character types:
+  +------------+-------------------------+
+  | Type       | Definition              |
+  +============+=========================+
+  | StringRef  | BasicStringRef<char>    |
+  +------------+-------------------------+
+  | WStringRef | BasicStringRef<wchar_t> |
+  +------------+-------------------------+
 
-+------------+-------------------------+
-| 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::
 
-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);
 
-template <typename... Args>
-std::string format(StringRef format_str, const Args & ... args);
-
-format("{}", 42);
-format(std::string("{}"), 42);
-\endrst
-*/
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
 template <typename Char>
 class BasicStringRef {
-private:
-    const Char *data_;
-    std::size_t size_;
+ 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) {}
+ 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)) {}
+   */
+  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()) {}
+   */
+  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_);
-    }
+   */
+  std::basic_string<Char> to_string() const {
+    return std::basic_string<Char>(data_, size_);
+  }
 
-    /** Returns the pointer to a C string. */
-    const Char *data() const {
-        return data_;
-    }
+  /** Returns the pointer to a C string. */
+  const Char *data() const { return data_; }
 
-    /** Returns the string size. */
-    std::size_t size() const {
-        return size_;
-    }
+  /** Returns the string size. */
+  std::size_t size() const { return size_; }
 
-    friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
-        return lhs.data_ == rhs.data_;
-    }
-    friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
-        return lhs.data_ != rhs.data_;
-    }
-    friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
-        return std::lexicographical_compare(
-                   lhs.data_, lhs.data_ + lhs.size_, rhs.data_, rhs.data_ + rhs.size_);
-    }
+  friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
+    return lhs.data_ == rhs.data_;
+  }
+  friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
+    return lhs.data_ != rhs.data_;
+  }
+  friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
+    return std::lexicographical_compare(
+          lhs.data_, lhs.data_ + lhs.size_, rhs.data_, rhs.data_ + rhs.size_);
+  }
 };
 
 typedef BasicStringRef<char> StringRef;
@@ -292,62 +288,60 @@ typedef BasicStringRef<wchar_t> WStringRef;
 
 
 /**
-\rst
-A reference to a null terminated string. It can be constructed from a C
-string or ``std::string``.
+  \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:
+  You can use one of the following typedefs for common character types:
 
-+-------------+--------------------------+
-| Type        | Definition               |
-+=============+==========================+
-| CStringRef  | BasicCStringRef<char>    |
-+-------------+--------------------------+
-| WCStringRef | BasicCStringRef<wchar_t> |
-+-------------+--------------------------+
+  +-------------+--------------------------+
+  | 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::
+  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);
+    template <typename... Args>
+    std::string format(CStringRef format_str, const Args & ... args);
 
-format("{}", 42);
-format(std::string("{}"), 42);
-\endrst
-*/
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
 template <typename Char>
 class BasicCStringRef {
-private:
-    const Char *data_;
+ private:
+  const Char *data_;
 
-public:
-    /** Constructs a string reference object from a C string. */
-    BasicCStringRef(const Char *s) : data_(s) {}
+ 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()) {}
+   */
+  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_;
-    }
+  /** 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.
+  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()) {}
+ public:
+  explicit FormatError(CStringRef message)
+  : std::runtime_error(message.c_str()) {}
 };
 
 namespace internal {
@@ -359,102 +353,92 @@ enum { INLINE_BUFFER_SIZE = 500 };
 // 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);
+  return stdext::checked_array_iterator<T*>(ptr, size);
 }
 #else
 template <typename T>
-inline T *make_ptr(T *ptr, std::size_t) {
-    return ptr;
-}
+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
-*/
+  \rst
+  A buffer supporting a subset of ``std::vector``'s operations.
+  \endrst
+ */
 template <typename T>
 class Buffer {
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
+ private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
 
-protected:
-    T *ptr_;
-    std::size_t size_;
-    std::size_t capacity_;
+ 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) {}
+  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;
+   */
+  virtual void grow(std::size_t size) = 0;
 
-public:
-    virtual ~Buffer() {}
+ public:
+  virtual ~Buffer() {}
 
-    /** Returns the size of this buffer. */
-    std::size_t size() const {
-        return size_;
-    }
+  /** 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_;
-    }
+  /** 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;
-    }
+   */
+  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 reserve(std::size_t capacity) {
+    if (capacity > capacity_)
+      grow(capacity);
+  }
 
-    void clear() FMT_NOEXCEPT{ size_ = 0; }
+  void clear() FMT_NOEXCEPT { size_ = 0; }
 
-    void push_back(const T &value) {
-        if (size_ == capacity_)
-            grow(size_ + 1);
-        ptr_[size_++] = value;
-    }
+  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);
+  /** 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];
-    }
+  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::ptrdiff_t num_elements = end - begin;
-    if (size_ + num_elements > capacity_)
-        grow(size_ + num_elements);
-    std::copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_);
-    size_ += num_elements;
+  std::ptrdiff_t num_elements = end - begin;
+  if (size_ + num_elements > capacity_)
+    grow(size_ + num_elements);
+  std::copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_);
+  size_ += num_elements;
 }
 
 namespace internal {
@@ -463,149 +447,132 @@ namespace internal {
 // 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];
+ private:
+  T data_[SIZE];
 
-    // Free memory allocated by the buffer.
-    void free() {
-        if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_);
-    }
+  // Free memory allocated by the buffer.
+  void free() {
+    if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_);
+  }
 
-protected:
-    void grow(std::size_t size);
+ protected:
+  void grow(std::size_t size);
 
-public:
-    explicit MemoryBuffer(const Allocator &alloc = Allocator())
-        : Allocator(alloc), Buffer<T>(data_, SIZE) {}
-    ~MemoryBuffer() {
-        free();
-    }
+ public:
+  explicit MemoryBuffer(const Allocator &alloc = Allocator())
+      : Allocator(alloc), Buffer<T>(data_, SIZE) {}
+  ~MemoryBuffer() { free(); }
 
 #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::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 freeing.
-            other.ptr_ = other.data_;
-        }
+ 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::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 freeing.
+      other.ptr_ = other.data_;
     }
+  }
 
-public:
-    MemoryBuffer(MemoryBuffer &&other) {
-        move(other);
-    }
+ public:
+  MemoryBuffer(MemoryBuffer &&other) {
+    move(other);
+  }
 
-    MemoryBuffer &operator=(MemoryBuffer &&other) {
-        assert(this != &other);
-        free();
-        move(other);
-        return *this;
-    }
+  MemoryBuffer &operator=(MemoryBuffer &&other) {
+    assert(this != &other);
+    free();
+    move(other);
+    return *this;
+  }
 #endif
 
-    // Returns a copy of the allocator associated with this buffer.
-    Allocator get_allocator() const {
-        return *this;
-    }
+  // 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 =
-        (std::max)(size, this->capacity_ + this->capacity_ / 2);
-    T *new_ptr = this->allocate(new_capacity);
-    // The following code doesn't throw, so the raw pointer above doesn't leak.
-    std::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_)
-        this->deallocate(old_ptr, old_capacity);
+  std::size_t new_capacity =
+      (std::max)(size, this->capacity_ + this->capacity_ / 2);
+  T *new_ptr = this->allocate(new_capacity);
+  // The following code doesn't throw, so the raw pointer above doesn't leak.
+  std::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_)
+    this->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) {}
+ public:
+  FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
 
-protected:
-    void grow(std::size_t size);
+ protected:
+  void grow(std::size_t size);
 };
 
 #ifndef _MSC_VER
 // Portable version of signbit.
 inline int getsign(double x) {
-    // When compiled in C++11 mode signbit is no longer a macro but a function
-    // defined in namespace std and the macro is undefined.
+  // When compiled in C++11 mode signbit is no longer a macro but a function
+  // defined in namespace std and the macro is undefined.
 # ifdef signbit
-    return signbit(x);
+  return signbit(x);
 # else
-    return std::signbit(x);
+  return std::signbit(x);
 # endif
 }
 
 // Portable version of isinf.
 # ifdef isinf
-inline int isinfinity(double x) {
-    return isinf(x);
-}
-inline int isinfinity(long double x) {
-    return isinf(x);
-}
+inline int isinfinity(double x) { return isinf(x); }
+inline int isinfinity(long double x) { return isinf(x); }
 # else
-inline int isinfinity(double x) {
-    return std::isinf(x);
-}
-inline int isinfinity(long double x) {
-    return std::isinf(x);
-}
+inline int isinfinity(double x) { return std::isinf(x); }
+inline int isinfinity(long double x) { return std::isinf(x); }
 # endif
 #else
 inline int getsign(double value) {
-    if (value < 0) return 1;
-    if (value == value) return 0;
-    int dec = 0, sign = 0;
-    char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
-    _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign);
-    return sign;
-}
-inline int isinfinity(double x) {
-    return !_finite(x);
+  if (value < 0) return 1;
+  if (value == value) return 0;
+  int dec = 0, sign = 0;
+  char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
+  _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign);
+  return sign;
 }
+inline int isinfinity(double x) { return !_finite(x); }
 inline int isinfinity(long double x) {
-    return !_finite(static_cast<double>(x));
+  return !_finite(static_cast<double>(x));
 }
 #endif
 
 template <typename Char>
 class BasicCharTraits {
-public:
+ public:
 #if _SECURE_SCL
-    typedef stdext::checked_array_iterator<Char*> CharPtr;
+  typedef stdext::checked_array_iterator<Char*> CharPtr;
 #else
-    typedef Char *CharPtr;
+  typedef Char *CharPtr;
 #endif
-    static Char cast(wchar_t value) {
-        return static_cast<Char>(value);
-    }
+  static Char cast(wchar_t value) { return static_cast<Char>(value); }
 };
 
 template <typename Char>
@@ -613,84 +580,68 @@ class CharTraits;
 
 template <>
 class CharTraits<char> : public BasicCharTraits<char> {
-private:
-    // Conversion from wchar_t to char is not allowed.
-    static char convert(wchar_t);
+ private:
+  // Conversion from wchar_t to char is not allowed.
+  static char convert(wchar_t);
 
-public:
-    static char convert(char value) {
-        return value;
-    }
+ public:
+  static char convert(char value) { return value; }
 
-    // Formats a floating-point number.
-    template <typename T>
-    static int format_float(char *buffer, std::size_t size,
-                            const char *format, unsigned width, int precision, T value);
+  // Formats a floating-point number.
+  template <typename T>
+  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;
-    }
+ public:
+  static wchar_t convert(char value) { return value; }
+  static wchar_t convert(wchar_t value) { return value; }
 
-    template <typename T>
-    static int format_float(wchar_t *buffer, std::size_t size,
-                            const wchar_t *format, unsigned width, int precision, T value);
+  template <typename T>
+  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 <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;
-    }
+  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);
+  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;
-};
+struct TypeSelector { typedef uint32_t Type; };
 
 template <>
-struct TypeSelector<false> {
-    typedef uint64_t Type;
-};
+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
+  // 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;
 };
 
 // MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
 template <typename T>
-struct MakeUnsigned {
-    typedef T Type;
-};
+struct MakeUnsigned { typedef T Type; };
 
 #define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
   template <> \
@@ -709,9 +660,9 @@ void report_unknown_type(char code, const char *type);
 // configuration.
 template <typename T = void>
 struct BasicData {
-    static const uint32_t POWERS_OF_10_32[];
-    static const uint64_t POWERS_OF_10_64[];
-    static const char DIGITS[];
+  static const uint32_t POWERS_OF_10_32[];
+  static const uint64_t POWERS_OF_10_64[];
+  static const char DIGITS[];
 };
 
 typedef BasicData<> Data;
@@ -728,57 +679,57 @@ typedef BasicData<> Data;
 // 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.
-    unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-    return t - (n < Data::POWERS_OF_10_64[t]) + 1;
+  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
+  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
+  unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
+  return 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;
-    }
+  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) {
-    uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
-    return t - (n < Data::POWERS_OF_10_32[t]) + 1;
+  uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
+  return 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 = (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 += 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 = (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
@@ -793,51 +744,35 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
 // 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_;
+ private:
+  MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
 
-public:
-    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());
-    }
+ public:
+  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_;
+ private:
+  MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
 
-public:
-    UTF16ToUTF8() {}
-    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());
-    }
+ public:
+  UTF16ToUTF8() {}
+  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.
-    int convert(WStringRef s);
+  // 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.
+  int convert(WStringRef s);
 };
 
 void format_windows_error(fmt::Writer &out, int error_code,
@@ -849,49 +784,49 @@ void format_system_error(fmt::Writer &out, int error_code,
 
 // A formatting argument value.
 struct Value {
-    template <typename Char>
-    struct StringValue {
-        const Char *value;
-        std::size_t size;
-    };
+  template <typename Char>
+  struct StringValue {
+    const Char *value;
+    std::size_t size;
+  };
 
-    typedef void(*FormatFunc)(
-        void *formatter, const void *arg, void *format_str_ptr);
+  typedef void (*FormatFunc)(
+      void *formatter, const void *arg, void *format_str_ptr);
 
-    struct CustomValue {
-        const void *value;
-        FormatFunc format;
-    };
+  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;
-    };
+  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
-    };
+  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 POD type to allow storage in
 // internal::MemoryBuffer.
 struct Arg : Value {
-    Type type;
+  Type type;
 };
 
 template <typename Char>
@@ -904,29 +839,29 @@ struct Null {};
 // characters and strings in MakeValue.
 template <typename T, typename Char>
 struct WCharHelper {
-    typedef Null<T> Supported;
-    typedef T Unsupported;
+  typedef Null<T> Supported;
+  typedef T Unsupported;
 };
 
 template <typename T>
 struct WCharHelper<T, wchar_t> {
-    typedef T Supported;
-    typedef Null<T> Unsupported;
+  typedef T Supported;
+  typedef Null<T> Unsupported;
 };
 
 template <typename T>
 class IsConvertibleToInt {
-private:
-    typedef char yes[1];
-    typedef char no[2];
+ private:
+  typedef char yes[1];
+  typedef char no[2];
 
-    static const T &get();
+  static const T &get();
 
-    static yes &convert(fmt::ULongLong);
-    static no &convert(...);
-
-public:
-    enum { value = (sizeof(convert(get())) == sizeof(yes)) };
+  static yes &convert(fmt::ULongLong);
+  static no &convert(...);
+  
+ public:
+  enum { value = (sizeof(convert(get())) == sizeof(yes)) };
 };
 
 #define FMT_CONVERTIBLE_TO_INT(Type) \
@@ -934,7 +869,7 @@ public:
   class IsConvertibleToInt<Type> { \
    public: \
     enum { value = 1 }; \
-          }
+  }
 
 // Silence warnings about convering float to int.
 FMT_CONVERTIBLE_TO_INT(float);
@@ -945,71 +880,63 @@ template<bool B, class T = void>
 struct EnableIf {};
 
 template<class T>
-struct EnableIf<true, T> {
-    typedef T type;
-};
+struct EnableIf<true, T> { typedef T type; };
 
 template<bool B, class T, class F>
-struct Conditional {
-    typedef T type;
-};
+struct Conditional { typedef T type; };
 
 template<class T, class F>
-struct Conditional<false, T, F> {
-    typedef F type;
-};
+struct Conditional<false, T, F> { typedef F type; };
 
 // A helper function to suppress bogus "conditional expression is constant"
 // warnings.
-inline bool check(bool value) {
-    return value;
-}
+inline bool check(bool value) { return value; }
 
 // Makes an Arg object from any type.
 template <typename Char>
 class MakeValue : public Arg {
-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);
+ 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").
-    MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
-    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);
+  // 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").
+  MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
+  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(StringRef str) {
+    string.value = str.data();
+    string.size = str.size();
+  }
 
-    void set_string(WStringRef str) {
-        wstring.value = str.data();
-        wstring.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<BasicFormatter<Char>*>(formatter),
-               *static_cast<const Char**>(format_str_ptr),
-               *static_cast<const T*>(arg));
-    }
+  // 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<BasicFormatter<Char>*>(formatter),
+           *static_cast<const Char**>(format_str_ptr),
+           *static_cast<const T*>(arg));
+  }
 
-public:
-    MakeValue() {}
+ public:
+  MakeValue() {}
 
 #define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
   MakeValue(Type value) { field = rhs; } \
@@ -1018,117 +945,111 @@ public:
 #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)
+  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(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;
-    }
+  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, CHAR)
-    FMT_MAKE_VALUE(unsigned char, int_value, CHAR)
-    FMT_MAKE_VALUE(char, int_value, CHAR)
+  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, CHAR)
+  FMT_MAKE_VALUE(unsigned char, int_value, CHAR)
+  FMT_MAKE_VALUE(char, int_value, CHAR)
 
-    MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
-        int_value = value;
-    }
-    static uint64_t type(wchar_t) {
-        return Arg::CHAR;
-    }
+  MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
+    int_value = value;
+  }
+  static uint64_t type(wchar_t) { return Arg::CHAR; }
 
 #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())
+  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_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)
+  FMT_MAKE_VALUE(void *, pointer, POINTER)
+  FMT_MAKE_VALUE(const void *, pointer, POINTER)
 
-    template <typename T>
-    MakeValue(const T &value,
-              typename EnableIf<!IsConvertibleToInt<T>::value, int>::type = 0) {
-        custom.value = &value;
-        custom.format = &format_custom_arg<T>;
-    }
+  template <typename T>
+  MakeValue(const T &value,
+            typename EnableIf<!IsConvertibleToInt<T>::value, int>::type = 0) {
+    custom.value = &value;
+    custom.format = &format_custom_arg<T>;
+  }
 
-    template <typename T>
-    MakeValue(const T &value,
-              typename EnableIf<IsConvertibleToInt<T>::value, int>::type = 0) {
-        int_value = value;
-    }
+  template <typename T>
+  MakeValue(const T &value,
+            typename EnableIf<IsConvertibleToInt<T>::value, int>::type = 0) {
+    int_value = value;
+  }
 
-    template <typename T>
-    static uint64_t type(const T &) {
-        return IsConvertibleToInt<T>::value ? Arg::INT : Arg::CUSTOM;
-    }
+  template <typename T>
+  static uint64_t type(const T &) {
+    return IsConvertibleToInt<T>::value ? Arg::INT : Arg::CUSTOM;
+  }
 
-    // Additional template param `Char_` is needed here because make_type always
-    // uses MakeValue<char>.
-    template <typename Char_>
-    MakeValue(const NamedArg<Char_> &value) {
-        pointer = &value;
-    }
+  // Additional template param `Char_` is needed here because make_type always
+  // uses MakeValue<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 Char_>
+  static uint64_t type(const NamedArg<Char_> &) { return Arg::NAMED_ARG; }
 };
 
 template <typename Char>
 struct NamedArg : Arg {
-    BasicStringRef<Char> name;
+  BasicStringRef<Char> name;
 
-    template <typename T>
-    NamedArg(BasicStringRef<Char> argname, const T &value)
-        : name(argname), Arg(MakeValue<Char>(value)) {
-        type = static_cast<internal::Arg::Type>(MakeValue<Char>::type(value));
-    }
+  template <typename T>
+  NamedArg(BasicStringRef<Char> argname, const T &value)
+  : name(argname), Arg(MakeValue<Char>(value)) {
+    type = static_cast<internal::Arg::Type>(MakeValue<Char>::type(value));
+  }
 };
 
 #define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
@@ -1155,102 +1076,102 @@ struct NamedArg : Arg {
 // http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
 template <typename Impl, typename Result>
 class ArgVisitor {
-public:
-    void report_unhandled_arg() {}
+ public:
+  void report_unhandled_arg() {}
 
-    Result visit_unhandled_arg() {
-        FMT_DISPATCH(report_unhandled_arg());
-        return Result();
-    }
+  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_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_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_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_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: {
-            Arg::StringValue<char> str = arg.string;
-            str.size = 0;
-            return FMT_DISPATCH(visit_string(str));
-        }
-        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));
-        }
+  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: {
+      Arg::StringValue<char> str = arg.string;
+      str.size = 0;
+      return FMT_DISPATCH(visit_string(str));
     }
+    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("") {}
+ protected:
+  RuntimeError() : std::runtime_error("") {}
 };
 
 template <typename Impl, typename Char>
@@ -1265,66 +1186,66 @@ class ArgMap;
 
 /** 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_;
-    };
+ 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);
+  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;
     }
-
-    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];
+    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];
+  }
 };
 
 struct FormatSpec;
@@ -1333,117 +1254,113 @@ namespace internal {
 
 template <typename Char>
 class ArgMap {
-private:
-    typedef std::map<fmt::BasicStringRef<Char>, internal::Arg> MapType;
-    typedef typename MapType::value_type Pair;
+ private:
+  typedef std::map<fmt::BasicStringRef<Char>, internal::Arg> MapType;
+  typedef typename MapType::value_type Pair;
 
-    MapType map_;
+  MapType map_;
 
-public:
-    void init(const ArgList &args);
+ public:
+  void init(const ArgList &args);
 
-    const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const {
-        typename MapType::const_iterator it = map_.find(name);
-        return it != map_.end() ? &it->second : 0;
-    }
+  const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const {
+    typename MapType::const_iterator it = map_.find(name);
+    return it != map_.end() ? &it->second : 0;
+  }
 };
 
 class FormatterBase {
-private:
-    ArgList args_;
-    int next_arg_index_;
+ private:
+  ArgList args_;
+  int next_arg_index_;
 
-    // Returns the argument with specified index.
-    Arg do_get_arg(unsigned arg_index, const char *&error);
+  // Returns the argument with specified index.
+  Arg do_get_arg(unsigned arg_index, const char *&error);
 
-protected:
-    const ArgList &args() const {
-        return args_;
-    }
+ protected:
+  const ArgList &args() const { return args_; }
 
-    explicit FormatterBase(const ArgList &args) {
-        args_ = args;
-        next_arg_index_ = 0;
-    }
+  explicit FormatterBase(const ArgList &args) {
+    args_ = args;
+    next_arg_index_ = 0;
+  }
 
-    // Returns the next argument.
-    Arg next_arg(const char *&error);
+  // Returns the next argument.
+  Arg next_arg(const char *&error);
 
-    // Checks if manual indexing is used and returns the argument with
-    // specified index.
-    Arg get_arg(unsigned arg_index, const char *&error);
+  // Checks if manual indexing is used and returns the argument with
+  // specified index.
+  Arg get_arg(unsigned arg_index, const char *&error);
 
-    bool check_no_auto_index(const char *&error);
+  bool check_no_auto_index(const char *&error);
 
-    template <typename Char>
-    void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
-        if (start != end)
-            w << BasicStringRef<Char>(start, end - start);
-    }
+  template <typename Char>
+  void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
+    if (start != end)
+      w << BasicStringRef<Char>(start, end - start);
+  }
 };
 
 // A printf formatter.
 template <typename Char>
 class PrintfFormatter : private FormatterBase {
-private:
-    void parse_flags(FormatSpec &spec, const Char *&s);
+ 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)());
+  // 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);
+  // 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) {}
-    void format(BasicWriter<Char> &writer, BasicCStringRef<Char> format_str);
+ public:
+  explicit PrintfFormatter(const ArgList &args) : FormatterBase(args) {}
+  void format(BasicWriter<Char> &writer, BasicCStringRef<Char> format_str);
 };
 }  // namespace internal
 
 // A formatter.
 template <typename Char>
 class BasicFormatter : private internal::FormatterBase {
-private:
-    BasicWriter<Char> &writer_;
-    internal::ArgMap<Char> map_;
+ private:
+  BasicWriter<Char> &writer_;
+  internal::ArgMap<Char> map_;
+  
+  FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
+  using FormatterBase::get_arg;
 
-    using 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);
 
-    // 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 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);
 
-    // Parses argument name and returns corresponding argument.
-    internal::Arg parse_arg_name(const Char *&s);
+ public:
+  BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
+    : FormatterBase(args), writer_(w) {}
 
-public:
-    BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
-        : FormatterBase(args), writer_(w) {}
+  BasicWriter<Char> &writer() { return writer_; }
 
-    BasicWriter<Char> &writer() {
-        return writer_;
-    }
+  void format(BasicCStringRef<Char> format_str);
 
-    void format(BasicCStringRef<Char> format_str);
-
-    const Char *format(const Char *&format_str, const internal::Arg &arg);
+  const Char *format(const Char *&format_str, const internal::Arg &arg);
 };
 
 enum Alignment {
-    ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
+  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.
+  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.
@@ -1452,162 +1369,128 @@ 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 ' ';
-    }
+  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_;
+  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) {}
+  WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
 
-    unsigned width() const {
-        return width_;
-    }
-    wchar_t fill() const {
-        return fill_;
-    }
+  unsigned width() const { return width_; }
+  wchar_t fill() const { return fill_; }
 };
 
 // An alignment specifier.
 struct AlignSpec : WidthSpec {
-    Alignment align_;
+  Alignment align_;
 
-    AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
-        : WidthSpec(width, fill), align_(align) {}
+  AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
+  : WidthSpec(width, fill), align_(align) {}
 
-    Alignment align() const {
-        return align_;
-    }
+  Alignment align() const { return align_; }
 
-    int precision() const {
-        return -1;
-    }
+  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) {}
+  AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
 
-    bool flag(unsigned) const {
-        return false;
-    }
-    char type() const {
-        return TYPE;
-    }
+  bool flag(unsigned) const { return false; }
+  char type() const { return TYPE; }
 };
 
 // A full format specifier.
 struct FormatSpec : AlignSpec {
-    unsigned flags_;
-    int precision_;
-    char type_;
+  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) {}
+  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_;
-    }
+  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_;
+ private:
+  T value_;
 
-public:
-    IntFormatSpec(T val, const SpecT &spec = SpecT())
-        : SpecT(spec), value_(val) {}
+ public:
+  IntFormatSpec(T val, const SpecT &spec = SpecT())
+  : SpecT(spec), value_(val) {}
 
-    T value() const {
-        return value_;
-    }
+  T value() const { return value_; }
 };
 
 // A string format specifier.
 template <typename Char>
 class StrFormatSpec : public AlignSpec {
-private:
-    const Char *str_;
+ 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());
-    }
+ 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_;
-    }
+  const Char *str() const { return str_; }
 };
 
 /**
-Returns an integer format specifier to format the value in base 2.
-*/
+  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.
-*/
+  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.
-*/
+  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.
-*/
+  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.
+  \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**::
+  **Example**::
 
-MemoryWriter out;
-out << pad(hex(0xcafe), 8, '0');
-// out.str() == "0000cafe"
+    MemoryWriter out;
+    out << pad(hex(0xcafe), 8, '0');
+    // out.str() == "0000cafe"
 
-\endrst
-*/
+  \endrst
+ */
 template <char TYPE_CODE, typename Char>
 IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
     int value, unsigned width, Char fill = ' ');
@@ -1615,26 +1498,26 @@ IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
 #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 */ \
@@ -1646,20 +1529,20 @@ inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
     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)
@@ -1669,26 +1552,26 @@ 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.
+  \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**::
+  **Example**::
 
-std::string s = str(MemoryWriter() << pad("abc", 8));
-// s == "abc     "
+    std::string s = str(MemoryWriter() << pad("abc", 8));
+    // s == "abc     "
 
-\endrst
-*/
+  \endrst
+ */
 template <typename Char>
 inline StrFormatSpec<Char> pad(
     const Char *str, unsigned width, Char fill = ' ') {
-    return StrFormatSpec<Char>(str, width, 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);
+  return StrFormatSpec<wchar_t>(str, width, fill);
 }
 
 // Generates a comma-separated list with results of applying f to
@@ -1711,51 +1594,47 @@ inline StrFormatSpec<wchar_t> pad(
 # define FMT_GEN15(f) FMT_GEN14(f), f(14)
 
 namespace internal {
-inline uint64_t make_type() {
-    return 0;
-}
+inline uint64_t make_type() { return 0; }
 
 template <typename T>
-inline uint64_t make_type(const T &arg) {
-    return MakeValue<char>::type(arg);
-}
+inline uint64_t make_type(const T &arg) { return MakeValue<char>::type(arg); }
 
 template <unsigned N>
 struct ArgArray {
-    // Computes the argument array size by adding 1 to N, which is the number of
-    // arguments, if N is zero, because array of zero size is invalid, or if N
-    // is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra
-    // argument that marks the end of the list.
-    enum { SIZE = N + (N == 0 || N >= ArgList::MAX_PACKED_ARGS ? 1 : 0) };
+  // Computes the argument array size by adding 1 to N, which is the number of
+  // arguments, if N is zero, because array of zero size is invalid, or if N
+  // is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra
+  // argument that marks the end of the list.
+  enum { SIZE = N + (N == 0 || N >= ArgList::MAX_PACKED_ARGS ? 1 : 0) };
 
-    typedef typename Conditional<
+  typedef typename Conditional<
     (N < ArgList::MAX_PACKED_ARGS), Value, Arg>::type Type[SIZE];
 };
 
 #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);
+  return make_type(first) | (make_type(tail...) << 4);
 }
 
 inline void do_set_types(Arg *) {}
 
 template <typename T, typename... Args>
 inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) {
-    args->type = static_cast<Arg::Type>(MakeValue<T>::type(arg));
-    do_set_types(args + 1, tail...);
+  args->type = static_cast<Arg::Type>(MakeValue<T>::type(arg));
+  do_set_types(args + 1, tail...);
 }
 
 template <typename... Args>
 inline void set_types(Arg *array, const Args & ... args) {
-    if (check(sizeof...(Args) > ArgList::MAX_PACKED_ARGS))
-        do_set_types(array, args...);
-    array[sizeof...(Args)].type = Arg::NONE;
+  if (check(sizeof...(Args) > ArgList::MAX_PACKED_ARGS))
+    do_set_types(array, args...);
+  array[sizeof...(Args)].type = Arg::NONE;
 }
 
 template <typename... Args>
 inline void set_types(Value *, const Args & ...) {
-    // Do nothing as types are passed separately from values.
+  // Do nothing as types are passed separately from values.
 }
 
 template <typename Char, typename Value>
@@ -1763,39 +1642,39 @@ inline void store_args(Value *) {}
 
 template <typename Char, typename Arg, typename T, typename... Args>
 inline void store_args(Arg *args, const T &arg, const Args & ... tail) {
-    // Assign only the Value subobject of Arg and don't overwrite type (if any)
-    // that is assigned by set_types.
-    Value &value = *args;
-    value = MakeValue<Char>(arg);
-    store_args<Char>(args + 1, tail...);
+  // Assign only the Value subobject of Arg and don't overwrite type (if any)
+  // that is assigned by set_types.
+  Value &value = *args;
+  value = MakeValue<Char>(arg);
+  store_args<Char>(args + 1, tail...);
 }
 
 template <typename Char, typename... Args>
 ArgList make_arg_list(typename ArgArray<sizeof...(Args)>::Type array,
                       const Args & ... args) {
-    if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS))
-        set_types(array, args...);
-    store_args<Char>(array, args...);
-    return ArgList(make_type(args...), array);
+  if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS))
+    set_types(array, args...);
+  store_args<Char>(array, args...);
+  return ArgList(make_type(args...), array);
 }
 #else
 
 struct ArgType {
-    uint64_t type;
+  uint64_t type;
 
-    ArgType() : type(0) {}
+  ArgType() : type(0) {}
 
-    template <typename T>
-    ArgType(const T &arg) : type(make_type(arg)) {}
+  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);
+  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
 }  // namespace internal
@@ -1813,7 +1692,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
   void func(arg_type arg0, const Args & ... args) { \
     typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
     func(arg0, fmt::internal::make_arg_list<Char>(array, args...)); \
-      }
+  }
 
 // Defines a variadic constructor.
 # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
@@ -1821,7 +1700,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
   ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
     typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
     func(arg0, arg1, fmt::internal::make_arg_list<Char>(array, args...)); \
-      }
+  }
 
 #else
 
@@ -1836,7 +1715,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
     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) \
@@ -1853,7 +1732,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
     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) \
@@ -1892,769 +1771,740 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
   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.
+ 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);
+ private:
+  void init(int err_code, CStringRef format_str, ArgList args);
 
-protected:
-    int error_code_;
+ protected:
+  int error_code_;
 
-    typedef char Char;  // For FMT_VARIADIC_CTOR.
+  typedef char Char;  // For FMT_VARIADIC_CTOR.
 
-    SystemError() {}
+  SystemError() {}
 
-public:
-    /**
-    \rst
-    Constructs a :class:`fmt::SystemError` object with the description
-    of the form
+ public:
+  /**
+   \rst
+   Constructs a :class:`fmt::SystemError` object with the description
+   of the form
 
-    .. parsed-literal::
-    *<message>*: *<system-message>*
+   .. 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.
+   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**::
 
-    **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)
 
-    // 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_;
-    }
+  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`.
+  \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:
+  You can use one of the following typedefs for common character types:
 
-+---------+----------------------+
-| Type    | Definition           |
-+=========+======================+
-| Writer  | BasicWriter<char>    |
-+---------+----------------------+
-| WWriter | BasicWriter<wchar_t> |
-+---------+----------------------+
+  +---------+----------------------+
+  | Type    | Definition           |
+  +=========+======================+
+  | Writer  | BasicWriter<char>    |
+  +---------+----------------------+
+  | WWriter | BasicWriter<wchar_t> |
+  +---------+----------------------+
 
-\endrst
-*/
+  \endrst
+ */
 template <typename Char>
 class BasicWriter {
-private:
-    // Output buffer.
-    Buffer<Char> &buffer_;
+ private:
+  // Output buffer.
+  Buffer<Char> &buffer_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
+  FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
 
-    typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
+  typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
 
 #if _SECURE_SCL
-    // Returns pointer value.
-    static Char *get(CharPtr p) {
-        return p.base();
-    }
+  // Returns pointer value.
+  static Char *get(CharPtr p) { return p.base(); }
 #else
-    static Char *get(Char *p) {
-        return p;
-    }
+  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);
+  // 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);
+  // 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) {
+    typename internal::IntTraits<Int>::MainType abs_value = value;
+    if (internal::is_negative(value)) {
+      abs_value = 0 - abs_value;
+      *write_unsigned_decimal(abs_value, 1) = '-';
+    } else {
+      write_unsigned_decimal(abs_value, 0);
     }
+  }
 
-    // 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;
-    }
+  // 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::copy(prefix, prefix + prefix_size, p);
+    return p + size - 1;
+  }
 
-    // Writes a decimal integer.
-    template <typename Int>
-    void write_decimal(Int value) {
-        typename internal::IntTraits<Int>::MainType abs_value = value;
-        if (internal::is_negative(value)) {
-            abs_value = 0 - abs_value;
-            *write_unsigned_decimal(abs_value, 1) = '-';
-        }
-        else {
-            write_unsigned_decimal(abs_value, 0);
-        }
-    }
+  template <typename Spec>
+  CharPtr prepare_int_buffer(unsigned num_digits,
+    const Spec &spec, const char *prefix, unsigned prefix_size);
 
-    // 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::copy(prefix, prefix + prefix_size, p);
-        return p + size - 1;
-    }
+  // Formats an integer.
+  template <typename T, typename Spec>
+  void write_int(T value, Spec spec);
 
-    template <typename Spec>
-    CharPtr prepare_int_buffer(unsigned num_digits,
-                               const Spec &spec, const char *prefix, unsigned prefix_size);
+  // Formats a floating-point number (double or long double).
+  template <typename T>
+  void write_double(T value, const FormatSpec &spec);
 
-    // Formats an integer.
-    template <typename T, typename Spec>
-    void write_int(T value, Spec spec);
+  // Writes a formatted string.
+  template <typename StrChar>
+  CharPtr write_str(
+      const StrChar *s, std::size_t size, const AlignSpec &spec);
 
-    // Formats a floating-point number (double or long double).
-    template <typename T>
-    void write_double(T value, const FormatSpec &spec);
+  template <typename StrChar>
+  void write_str(
+      const internal::Arg::StringValue<StrChar> &str, const FormatSpec &spec);
 
-    // Writes a formatted string.
-    template <typename StrChar>
-    CharPtr write_str(
-        const StrChar *s, std::size_t size, const AlignSpec &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);
 
-    template <typename StrChar>
-    void write_str(
-        const internal::Arg::StringValue<StrChar> &str, const FormatSpec &spec);
+  // 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';
+  }
 
-    // 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);
+  template<typename T>
+  void append_float_length(Char *&, T) {}
 
-    // 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 Impl, typename Char_>
+  friend class internal::BasicArgFormatter;
 
-    template<typename T>
-    void append_float_length(Char *&, T) {}
+  friend class internal::PrintfArgFormatter<Char>;
 
-    template <typename Impl, typename Char_>
-    friend class internal::BasicArgFormatter;
-
-    friend class internal::PrintfArgFormatter<Char>;
-
-protected:
-    /**
+ protected:
+  /**
     Constructs a ``BasicWriter`` object.
-    */
-    explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
+   */
+  explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
 
-public:
-    /**
+ public:
+  /**
     \rst
     Destroys a ``BasicWriter`` object.
     \endrst
-    */
-    virtual ~BasicWriter() {}
+   */
+  virtual ~BasicWriter() {}
 
-    /**
+  /**
     Returns the total number of characters written.
-    */
-    std::size_t size() const {
-        return buffer_.size();
-    }
+   */
+  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];
-    }
+   */
+  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];
-    }
+   */
+  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());
-    }
+   */
+  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);
+       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)
+       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>)
+   */
+  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;
-    }
+  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<<(ULongLong value) {
+    return *this << IntFormatSpec<ULongLong>(value);
+  }
 
-    BasicWriter &operator<<(double value) {
-        write_double(value, FormatSpec());
-        return *this;
-    }
+  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;
-    }
+   */
+  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<<(char value) {
+    buffer_.push_back(value);
+    return *this;
+  }
 
-    BasicWriter &operator<<(
-        typename internal::WCharHelper<wchar_t, Char>::Supported 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<<(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;
-    }
+  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 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;
-    }
+  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(); }
+  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::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::fill_n(out + size, spec.width() - size, fill);
-        }
+      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::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::fill_n(out + size, spec.width() - size, fill);
     }
-    else {
-        out = grow_buffer(size);
-    }
-    std::copy(s, s + size, out);
-    return out;
+  } else {
+    out = grow_buffer(size);
+  }
+  std::copy(s, s + size, out);
+  return out;
 }
 
 template <typename Char>
 typename BasicWriter<Char>::CharPtr
-BasicWriter<Char>::fill_padding(
+  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::fill_n(buffer, left_padding, fill_char);
-    buffer += left_padding;
-    CharPtr content = buffer;
-    std::fill_n(buffer + content_size, padding - left_padding, fill_char);
-    return content;
+  std::size_t padding = total_size - content_size;
+  std::size_t left_padding = padding / 2;
+  Char fill_char = internal::CharTraits<Char>::cast(fill);
+  std::fill_n(buffer, left_padding, fill_char);
+  buffer += left_padding;
+  CharPtr content = buffer;
+  std::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(
+  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 + 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::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::fill(p, p + fill_size, fill);
-        }
-        return result;
+  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 + 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::fill(p, p + fill_size, fill);
     }
-    unsigned size = prefix_size + num_digits;
-    if (width <= size) {
-        CharPtr p = grow_buffer(size);
-        std::copy(prefix, prefix + prefix_size, p);
-        return p + size - 1;
-    }
-    CharPtr p = grow_buffer(width);
-    CharPtr end = p + width;
+    CharPtr result = prepare_int_buffer(
+        num_digits, subspec, prefix, prefix_size);
     if (align == ALIGN_LEFT) {
-        std::copy(prefix, prefix + prefix_size, p);
-        p += size;
-        std::fill(p, end, fill);
+      CharPtr p = grow_buffer(fill_size);
+      std::fill(p, p + fill_size, fill);
     }
-    else if (align == ALIGN_CENTER) {
-        p = fill_padding(p, width, size, fill);
-        std::copy(prefix, prefix + prefix_size, p);
-        p += size;
+    return result;
+  }
+  unsigned size = prefix_size + num_digits;
+  if (width <= size) {
+    CharPtr p = grow_buffer(size);
+    std::copy(prefix, prefix + prefix_size, p);
+    return p + size - 1;
+  }
+  CharPtr p = grow_buffer(width);
+  CharPtr end = p + width;
+  if (align == ALIGN_LEFT) {
+    std::copy(prefix, prefix + prefix_size, p);
+    p += size;
+    std::fill(p, end, fill);
+  } else if (align == ALIGN_CENTER) {
+    p = fill_padding(p, width, size, fill);
+    std::copy(prefix, prefix + prefix_size, p);
+    p += size;
+  } else {
+    if (align == ALIGN_NUMERIC) {
+      if (prefix_size != 0) {
+        p = std::copy(prefix, prefix + prefix_size, p);
+        size -= prefix_size;
+      }
+    } else {
+      std::copy(prefix, prefix + prefix_size, end - size);
     }
-    else {
-        if (align == ALIGN_NUMERIC) {
-            if (prefix_size != 0) {
-                p = std::copy(prefix, prefix + prefix_size, p);
-                size -= prefix_size;
-            }
-        }
-        else {
-            std::copy(prefix, prefix + prefix_size, end - size);
-        }
-        std::fill(p, end - size, fill);
-        p = end;
-    }
-    return p - 1;
+    std::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 = value;
-    char prefix[4] = "";
-    if (internal::is_negative(value)) {
-        prefix[0] = '-';
-        ++prefix_size;
-        abs_value = 0 - abs_value;
+  unsigned prefix_size = 0;
+  typedef typename internal::IntTraits<T>::MainType UnsignedType;
+  UnsignedType abs_value = 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();
     }
-    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-- = '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-- = '0' + (n & 7);
-        } while ((n >>= 3) != 0);
-        break;
-    }
-    default:
-        internal::report_unknown_type(
-            spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
-        break;
+    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-- = '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-- = '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':
+  // 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';
+    // 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;
-    }
+  case 'E': case 'G': case 'A':
+    upper = true;
+    break;
+  default:
+    internal::report_unknown_type(type, "double");
+    break;
+  }
 
-    char sign = 0;
-    // Use getsign instead of value < 0 because the latter is always
-    // false for NaN.
-    if (internal::getsign(static_cast<double>(value))) {
-        sign = '-';
-        value = -value;
-    }
-    else if (spec.flag(SIGN_FLAG)) {
-        sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
-    }
+  char sign = 0;
+  // Use getsign instead of value < 0 because the latter is always
+  // false for NaN.
+  if (internal::getsign(static_cast<double>(value))) {
+    sign = '-';
+    value = -value;
+  } else if (spec.flag(SIGN_FLAG)) {
+    sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
+  }
 
-    if (value != 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 (value != 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::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;
+  if (internal::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() + (std::max)(width, 1u));
-        if (width > 0)
-            --width;
-        ++offset;
-    }
+  std::size_t offset = buffer_.size();
+  unsigned width = spec.width();
+  if (sign) {
+    buffer_.reserve(buffer_.size() + (std::max)(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++ = '*';
-    }
+  // 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';
+  append_float_length(format_ptr, value);
+  *format_ptr++ = type;
+  *format_ptr = '\0';
 
-    // Format using snprintf.
-    Char fill = internal::CharTraits<Char>::cast(spec.fill());
-    for (;;) {
-        std::size_t buffer_size = buffer_.capacity() - offset;
+  // Format using snprintf.
+  Char fill = internal::CharTraits<Char>::cast(spec.fill());
+  for (;;) {
+    std::size_t buffer_size = buffer_.capacity() - offset;
 #if _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
-        Char *start = &buffer_[offset];
-        int n = internal::CharTraits<Char>::format_float(
-                    start, buffer_size, format, width_for_sprintf, spec.precision(), value);
-        if (n >= 0 && offset + n < buffer_.capacity()) {
-            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() > static_cast<unsigned>(n)) {
-                width = spec.width();
-                CharPtr p = grow_buffer(width);
-                std::copy(p, p + n, p + (width - n) / 2);
-                fill_padding(p, spec.width(), n, fill);
-                return;
-            }
-            if (spec.fill() != ' ' || sign) {
-                while (*start == ' ')
-                    *start++ = fill;
-                if (sign)
-                    *(start - 1) = sign;
-            }
-            grow_buffer(n);
-            return;
-        }
-        // If n is negative we ask to increase the capacity by at least 1,
-        // but as std::vector, the buffer grows exponentially.
-        buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
+    // 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
+    Char *start = &buffer_[offset];
+    int n = internal::CharTraits<Char>::format_float(
+        start, buffer_size, format, width_for_sprintf, spec.precision(), value);
+    if (n >= 0 && offset + n < buffer_.capacity()) {
+      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() > static_cast<unsigned>(n)) {
+        width = spec.width();
+        CharPtr p = grow_buffer(width);
+        std::copy(p, p + n, p + (width - n) / 2);
+        fill_padding(p, spec.width(), n, fill);
+        return;
+      }
+      if (spec.fill() != ' ' || sign) {
+        while (*start == ' ')
+          *start++ = fill;
+        if (sign)
+          *(start - 1) = sign;
+      }
+      grow_buffer(n);
+      return;
+    }
+    // If n is negative we ask to increase the capacity by at least 1,
+    // but as std::vector, the buffer grows exponentially.
+    buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
+  }
 }
 
 /**
-\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.
+  \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:
+  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>> |
-+---------------+-----------------------------------------------------+
+  +---------------+-----------------------------------------------------+
+  | Type          | Definition                                          |
+  +===============+=====================================================+
+  | MemoryWriter  | BasicMemoryWriter<char, std::allocator<char>>       |
+  +---------------+-----------------------------------------------------+
+  | WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
+  +---------------+-----------------------------------------------------+
 
-**Example**::
+  **Example**::
 
-MemoryWriter out;
-out << "The answer is " << 42 << "\n";
-out.write("({:+f}, {:+f})", -3.14, 3.14);
+     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:
+  This will write the following output to the ``out`` object:
 
-.. code-block:: none
+  .. code-block:: none
 
-The answer is 42
-(-3.140000, +3.140000)
+     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
-*/
+  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_;
+ private:
+  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
 
-public:
-    explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
-        : BasicWriter<Char>(buffer_), buffer_(alloc) {}
+ 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_)) {
-    }
+   */
+  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;
-    }
+   */
+  BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
+    buffer_ = std::move(other.buffer_);
+    return *this;
+  }
 #endif
 };
 
@@ -2662,49 +2512,49 @@ 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`.
+  \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.
 
-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:
 
-You can use one of the following typedefs for common character types:
-
-+--------------+---------------------------+
-| Type         | Definition                |
-+==============+===========================+
-| ArrayWriter  | BasicArrayWriter<char>    |
-+--------------+---------------------------+
-| WArrayWriter | BasicArrayWriter<wchar_t> |
-+--------------+---------------------------+
-\endrst
-*/
+  +--------------+---------------------------+
+  | Type         | Definition                |
+  +==============+===========================+
+  | ArrayWriter  | BasicArrayWriter<char>    |
+  +--------------+---------------------------+
+  | WArrayWriter | BasicArrayWriter<wchar_t> |
+  +--------------+---------------------------+
+  \endrst
+ */
 template <typename Char>
 class BasicArrayWriter : public BasicWriter<Char> {
-private:
-    internal::FixedBuffer<Char> buffer_;
+ 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) {}
+ 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) {}
+  /**
+   \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;
@@ -2713,13 +2563,13 @@ 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) {
-    std::basic_ostringstream<Char> os;
-    os << value;
-    std::basic_string<Char> str = os.str();
-    internal::Arg arg = internal::MakeValue<Char>(str);
-    arg.type = static_cast<internal::Arg::Type>(
-                   internal::MakeValue<Char>::type(str));
-    format_str = f.format(format_str, arg);
+  std::basic_ostringstream<Char> os;
+  os << value;
+  std::basic_string<Char> str = os.str();
+  internal::Arg arg = internal::MakeValue<Char>(str);
+  arg.type = static_cast<internal::Arg::Type>(
+        internal::MakeValue<Char>::type(str));
+  format_str = f.format(format_str, arg);
 }
 
 // Reports a system error without throwing an exception.
@@ -2730,42 +2580,42 @@ void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT;
 
 /** A Windows error. */
 class WindowsError : public SystemError {
-private:
-    void init(int error_code, CStringRef format_str, ArgList args);
+ private:
+  void init(int error_code, CStringRef format_str, ArgList args);
 
-public:
-    /**
-    \rst
-    Constructs a :class:`fmt::WindowsError` object with the description
-    of the form
+ public:
+  /**
+   \rst
+   Constructs a :class:`fmt::WindowsError` object with the description
+   of the form
 
-    .. parsed-literal::
-    *<message>*: *<system-message>*
+   .. 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".
+   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**::
+   **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)
+     // 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.
@@ -2777,200 +2627,188 @@ void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT;
 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:
-PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23;
-*/
+  Formats a string and prints it to stdout using ANSI escape sequences
+  to specify color (experimental).
+  Example:
+    PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23;
+ */
 void print_colored(Color c, CStringRef format, ArgList args);
 
 /**
-\rst
-Formats arguments and returns the result as a string.
+  \rst
+  Formats arguments and returns the result as a string.
 
-**Example**::
+  **Example**::
 
-std::string message = format("The answer is {}", 42);
-\endrst
+    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();
+  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();
+  WMemoryWriter w;
+  w.write(format_str, args);
+  return w.str();
 }
 
 /**
-\rst
-Prints formatted data to the file *f*.
+  \rst
+  Prints formatted data to the file *f*.
 
-**Example**::
+  **Example**::
 
-print(stderr, "Don't {}!", "panic");
-\endrst
-*/
+    print(stderr, "Don't {}!", "panic");
+  \endrst
+ */
 void print(std::FILE *f, CStringRef format_str, ArgList args);
 
 /**
-\rst
-Prints formatted data to ``stdout``.
+  \rst
+  Prints formatted data to ``stdout``.
 
-**Example**::
+  **Example**::
 
-print("Elapsed time: {0:.2f} seconds", 1.23);
-\endrst
-*/
+    print("Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
 void print(CStringRef format_str, ArgList args);
 
 /**
-\rst
-Prints formatted data to the stream *os*.
+  \rst
+  Prints formatted data to the stream *os*.
 
-**Example**::
+  **Example**::
 
-print(cerr, "Don't {}!", "panic");
-\endrst
-*/
+    print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
 void print(std::ostream &os, 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);
+  internal::PrintfFormatter<Char>(args).format(w, format);
 }
 
 /**
-\rst
-Formats arguments and returns the result as a string.
+  \rst
+  Formats arguments and returns the result as a string.
 
-**Example**::
+  **Example**::
 
-std::string message = fmt::sprintf("The answer is %d", 42);
-\endrst
+    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();
+  MemoryWriter w;
+  printf(w, format, args);
+  return w.str();
 }
 
 /**
-\rst
-Prints formatted data to the file *f*.
+  \rst
+  Prints formatted data to the file *f*.
 
-**Example**::
+  **Example**::
 
-fmt::fprintf(stderr, "Don't %s!", "panic");
-\endrst
-*/
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
+ */
 int fprintf(std::FILE *f, CStringRef format, ArgList args);
 
 /**
-\rst
-Prints formatted data to ``stdout``.
+  \rst
+  Prints formatted data to ``stdout``.
 
-**Example**::
+  **Example**::
 
-fmt::printf("Elapsed time: %.2f seconds", 1.23);
-\endrst
-*/
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
+ */
 inline int printf(CStringRef format, ArgList args) {
-    return fprintf(stdout, format, args);
+  return fprintf(stdout, format, args);
 }
 
 /**
-Fast integer formatter.
-*/
+  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_;
+ 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 = (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;
+  // 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 = (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_ = '-';
-    }
+  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)) {}
+ 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 buffer_ - str_ + BUFFER_SIZE - 1;
-    }
+   */
+  std::size_t size() const { return 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_;
-    }
+   */
+  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_;
-    }
+   */
+  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());
-    }
+   */
+  std::string str() const { return std::string(str_, size()); }
 };
 
 // Formats a decimal integer value writing into buffer and returns
@@ -2978,44 +2816,44 @@ public:
 // write a terminating null character.
 template <typename T>
 inline void format_decimal(char *&buffer, T value) {
-    typename internal::IntTraits<T>::MainType abs_value = value;
-    if (internal::is_negative(value)) {
-        *buffer++ = '-';
-        abs_value = 0 - abs_value;
+  typename internal::IntTraits<T>::MainType abs_value = 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;
     }
-    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;
+    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.
+  \rst
+  Returns a named argument for formatting functions.
 
-**Example**::
+  **Example**::
 
-print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
+    print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
 
-\endrst
-*/
+  \endrst
+ */
 template <typename T>
 inline internal::NamedArg<char> arg(StringRef name, const T &arg) {
-    return internal::NamedArg<char>(name, 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);
+  return internal::NamedArg<wchar_t>(name, arg);
 }
 
 // The following two functions are deleted intentionally to disable
@@ -3096,32 +2934,32 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
 #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.
+  \rst
+  Defines a variadic function with the specified return type, function name
+  and argument types passed as variable arguments to this macro.
 
-**Example**::
+  **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 *)
+    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::
+  ``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
-*/
+    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__)
 
@@ -3133,19 +2971,19 @@ fmt::print(format, args...);
 #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)``.
+  \rst
+  Convenient macro to capture the arguments' names and values into several
+  ``fmt::arg(name, value)``.
 
-**Example**::
+  **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));
+    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
-*/
+  \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__)

From f8b728ea8a5ea5b10148b69737f88e8c11909673 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 14 Aug 2015 20:26:33 +0300
Subject: [PATCH 59/61] Fixed warnings conversion 'size_t' to 'int' on windows
 - issue #119

---
 tests/tests.sln     |  6 +++++
 tests/tests.vcxproj | 55 ++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 60 insertions(+), 1 deletion(-)

diff --git a/tests/tests.sln b/tests/tests.sln
index 8423a780..a8a31def 100644
--- a/tests/tests.sln
+++ b/tests/tests.sln
@@ -8,13 +8,19 @@ EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
 		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Debug|Win32.ActiveCfg = Debug|Win32
 		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Debug|Win32.Build.0 = Debug|Win32
+		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Debug|x64.ActiveCfg = Debug|x64
+		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Debug|x64.Build.0 = Debug|x64
 		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Release|Win32.ActiveCfg = Release|Win32
 		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Release|Win32.Build.0 = Release|Win32
+		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Release|x64.ActiveCfg = Release|x64
+		{59A07559-5F38-4DD6-A7FA-DB4153690B42}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/tests/tests.vcxproj b/tests/tests.vcxproj
index 6bf3a3d9..58cfd522 100644
--- a/tests/tests.vcxproj
+++ b/tests/tests.vcxproj
@@ -5,10 +5,18 @@
       <Configuration>Debug</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
     <ProjectConfiguration Include="Release|Win32">
       <Configuration>Release</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{59A07559-5F38-4DD6-A7FA-DB4153690B42}</ProjectGuid>
@@ -21,6 +29,12 @@
     <PlatformToolset>v120</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
@@ -28,15 +42,28 @@
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup />
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@@ -50,9 +77,35 @@
       <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>

From ea1a92769b270f520d335087606c5cb8944ae776 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Fri, 14 Aug 2015 21:16:08 +0300
Subject: [PATCH 60/61] Fixed rotating_logger_mt does not rotate properly if
 app restarts #116

---
 include/spdlog/details/file_helper.h | 25 +++++++++++++++++++++++++
 include/spdlog/sinks/file_sinks.h    |  1 +
 2 files changed, 26 insertions(+)

diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h
index 5062e977..4ba556ac 100644
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -113,6 +113,29 @@ public:
 
     }
 
+    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 size = ftell(_fd);
+
+        if(fseek(_fd, pos, SEEK_SET) !=0)
+            throw spdlog_ex("fseek failed on file " + _filename);
+
+        if (size == -1)
+            throw spdlog_ex("ftell failed on file " + _filename);
+
+
+        return size;
+
+
+    }
+
     const std::string& filename() const
     {
         return _filename;
@@ -132,6 +155,8 @@ public:
         }
     }
 
+
+
 private:
     FILE* _fd;
     std::string _filename;
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 8d36f316..6c8f2df0 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -82,6 +82,7 @@ public:
         _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

From ac0d5be676643a1572831d90e054a95db517d0f5 Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Wed, 26 Aug 2015 13:20:20 +0300
Subject: [PATCH 61/61] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a29d04df..3d161cf6 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ Just copy the files to your build tree and use a C++11 compiler
 * Feature rich [call style](#usage-example) using the excellent [cppformat](http://cppformat.github.io/) library.
 * ostream call style is supported too.
 * Extremely fast asynchronous mode (optional) - using lockfree queues and other tricks to reach millions of calls/sec.
-* [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting.
+* [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
 * Multi/Single threaded loggers.
 * Various log targets:
     * Rotating log files.