diff --git a/README.md b/README.md
index 94594faecb09916d004adce2de758e11b448e681..b3d8eaf01cdfe05021827ec204dcc1815bf04f26 100644
--- a/README.md
+++ b/README.md
@@ -129,6 +129,23 @@ Wolf uses YAML files for configuration and for saving and loading workspaces. To
We are shipping the CMAKE file `FindYamlCpp.cmake` together with Wolf. Find it at `[wolf]/cmake_modules/FindYamlCpp.cmake`
+#### spdlog
+
+Wolf used spdlog macros. To install it:
+
+- Git clone the source:
+
+ $ git clone https://github.com/gabime/spdlog.git
+
+- Build and install with:
+
+ $ cd spdlog
+ $ mkdir build
+ $ cd build
+ $ cmake -DCMAKE_CXX_FLAGS="${CMAKE_CXX_FLAGS} -fPIC" ..
+ $Â make
+ $ sudo make installÂ
+
#### Optional: Laser Scan Utils (Install only if you want to use IRI's laser scan utils)
**(1)** Git clone the source:
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 27dac1cdc3a287e710c31aeb54f213efdfa3cf05..e8f9453826d5108b77f5b0e834a0fc05c37aff33 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -112,8 +112,8 @@ include_directories("${PROJECT_BINARY_DIR}/conf")
INCLUDE_DIRECTORIES(.)
# include spdlog (logging) third_party
-INCLUDE_DIRECTORIES(../third_party/spdlog/include)
-set(SPDLOG_INCLUDE_DIRS "../third_party/spdlog/include/")
+set(SPDLOG_INCLUDE_DIRS "/usr/local/include/spdlog")
+INCLUDE_DIRECTORIES(${SPDLOG_INCLUDE_DIRS})
INCLUDE_DIRECTORIES(${EIGEN_INCLUDE_DIRS})
diff --git a/third_party/spdlog/include/spdlog/async_logger.h b/third_party/spdlog/include/spdlog/async_logger.h
deleted file mode 100644
index 1c42fd9ce6c4d0e0c175cf815ca6a1f425864183..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/async_logger.h
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Very fast asynchronous logger (millions of logs per second on an average desktop)
-// Uses pre allocated lockfree queue for maximum throughput even under large number of threads.
-// Creates a single back thread to pop messages from the queue and log them.
-//
-// Upon each log write the logger:
-// 1. Checks if its log level is enough to log the message
-// 2. Push a new copy of the message to a queue (or block the caller until space is available in the queue)
-// 3. will throw spdlog_ex upon log exceptions
-// Upon destruction, logs all remaining messages in the queue before destructing..
-
-#include <spdlog/common.h>
-#include <spdlog/logger.h>
-
-#include <chrono>
-#include <functional>
-#include <string>
-#include <memory>
-
-namespace spdlog
-{
-
-namespace details
-{
-class async_log_helper;
-}
-
-class async_logger :public logger
-{
-public:
- template<class It>
- async_logger(const std::string& name,
- const It& begin,
- const It& end,
- size_t queue_size,
- const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
- const std::function<void()>& worker_warmup_cb = nullptr,
- const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
- const std::function<void()>& worker_teardown_cb = nullptr);
-
- async_logger(const std::string& logger_name,
- sinks_init_list sinks,
- size_t queue_size,
- const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
- const std::function<void()>& worker_warmup_cb = nullptr,
- const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
- const std::function<void()>& worker_teardown_cb = nullptr);
-
- async_logger(const std::string& logger_name,
- sink_ptr single_sink,
- size_t queue_size,
- const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
- const std::function<void()>& worker_warmup_cb = nullptr,
- const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
- const std::function<void()>& worker_teardown_cb = nullptr);
-
- //Wait for the queue to be empty, and flush synchronously
- //Warning: this can potentialy last forever as we wait it to complete
- void flush() override;
-protected:
- void _sink_it(details::log_msg& msg) override;
- void _set_formatter(spdlog::formatter_ptr msg_formatter) override;
- void _set_pattern(const std::string& pattern) override;
-
-private:
- std::unique_ptr<details::async_log_helper> _async_log_helper;
-};
-}
-
-
-#include <spdlog/details/async_logger_impl.h>
diff --git a/third_party/spdlog/include/spdlog/common.h b/third_party/spdlog/include/spdlog/common.h
deleted file mode 100644
index 1a7ce761cf2cd77ed9cc4d7d14056eb44f1aa243..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/common.h
+++ /dev/null
@@ -1,143 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <string>
-#include <initializer_list>
-#include <chrono>
-#include <memory>
-#include <atomic>
-#include <exception>
-#include<functional>
-
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-#include <codecvt>
-#include <locale>
-#endif
-
-#include <spdlog/details/null_mutex.h>
-
-//visual studio upto 2013 does not support noexcept nor constexpr
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-#define SPDLOG_NOEXCEPT throw()
-#define SPDLOG_CONSTEXPR
-#else
-#define SPDLOG_NOEXCEPT noexcept
-#define SPDLOG_CONSTEXPR constexpr
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-#define DEPRECATED __attribute__((deprecated))
-#elif defined(_MSC_VER)
-#define DEPRECATED __declspec(deprecated)
-#else
-#define DEPRECATED
-#endif
-
-
-#include <spdlog/fmt/fmt.h>
-
-namespace spdlog
-{
-
-class formatter;
-
-namespace sinks
-{
-class sink;
-}
-
-using log_clock = std::chrono::system_clock;
-using sink_ptr = std::shared_ptr < sinks::sink >;
-using sinks_init_list = std::initializer_list < sink_ptr >;
-using formatter_ptr = std::shared_ptr<spdlog::formatter>;
-#if defined(SPDLOG_NO_ATOMIC_LEVELS)
-using level_t = details::null_atomic_int;
-#else
-using level_t = std::atomic<int>;
-#endif
-
-using log_err_handler = std::function<void(const std::string &err_msg)>;
-
-//Log level enum
-namespace level
-{
-typedef enum
-{
- trace = 0,
- debug = 1,
- info = 2,
- warn = 3,
- err = 4,
- critical = 5,
- off = 6
-} level_enum;
-
-static const char* level_names[] { "trace", "debug", "info", "warning", "error", "critical", "off" };
-
-static const char* short_level_names[] { "T", "D", "I", "W", "E", "C", "O" };
-
-inline const char* to_str(spdlog::level::level_enum l)
-{
- return level_names[l];
-}
-
-inline const char* to_short_str(spdlog::level::level_enum l)
-{
- return short_level_names[l];
-}
-} //level
-
-
-//
-// Async overflow policy - block by default.
-//
-enum class async_overflow_policy
-{
- block_retry, // Block / yield / sleep until message can be enqueued
- discard_log_msg // Discard the message it enqueue fails
-};
-
-
-//
-// Log exception
-//
-namespace details
-{
-namespace os
-{
-std::string errno_str(int err_num);
-}
-}
-class spdlog_ex: public std::exception
-{
-public:
- spdlog_ex(const std::string& msg):_msg(msg)
- {}
- spdlog_ex(const std::string& msg, int last_errno)
- {
- _msg = msg + ": " + details::os::errno_str(last_errno);
- }
- const char* what() const SPDLOG_NOEXCEPT override
- {
- return _msg.c_str();
- }
-private:
- std::string _msg;
-
-};
-
-//
-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
-//
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-using filename_t = std::wstring;
-#else
-using filename_t = std::string;
-#endif
-
-
-} //spdlog
diff --git a/third_party/spdlog/include/spdlog/details/async_log_helper.h b/third_party/spdlog/include/spdlog/details/async_log_helper.h
deleted file mode 100644
index 14539e75218aa79a4f00673a82f760dfa856050d..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/async_log_helper.h
+++ /dev/null
@@ -1,390 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-// async log helper :
-// Process logs asynchronously using a back thread.
-//
-// If the internal queue of log messages reaches its max size,
-// then the client call will block until there is more room.
-//
-// If the back thread throws during logging, a spdlog::spdlog_ex exception
-// will be thrown in client's thread when tries to log the next message
-
-#pragma once
-
-#include <spdlog/common.h>
-#include <spdlog/sinks/sink.h>
-#include <spdlog/details/mpmc_bounded_q.h>
-#include <spdlog/details/log_msg.h>
-#include <spdlog/details/os.h>
-#include <spdlog/formatter.h>
-
-#include <chrono>
-#include <exception>
-#include <functional>
-#include <memory>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace spdlog
-{
-namespace details
-{
-
-class async_log_helper
-{
- // Async msg to move to/from the queue
- // Movable only. should never be copied
- enum class async_msg_type
- {
- log,
- flush,
- terminate
- };
- struct async_msg
- {
- std::string logger_name;
- level::level_enum level;
- log_clock::time_point time;
- size_t thread_id;
- std::string txt;
- async_msg_type msg_type;
-
- async_msg() = default;
- ~async_msg() = default;
-
-
-async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
- logger_name(std::move(other.logger_name)),
- level(std::move(other.level)),
- time(std::move(other.time)),
- txt(std::move(other.txt)),
- msg_type(std::move(other.msg_type))
- {}
-
- async_msg(async_msg_type m_type) :msg_type(m_type)
- {}
-
- async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT
- {
- logger_name = std::move(other.logger_name);
- level = other.level;
- time = std::move(other.time);
- thread_id = other.thread_id;
- txt = std::move(other.txt);
- msg_type = other.msg_type;
- return *this;
- }
-
- // never copy or assign. should only be moved..
- async_msg(const async_msg&) = delete;
- async_msg& operator=(async_msg& other) = delete;
-
- // construct from log_msg
- async_msg(const details::log_msg& m) :
- level(m.level),
- time(m.time),
- thread_id(m.thread_id),
- txt(m.raw.data(), m.raw.size()),
- msg_type(async_msg_type::log)
- {
-#ifndef SPDLOG_NO_NAME
- logger_name = *m.logger_name;
-#endif
- }
-
-
- // copy into log_msg
- void fill_log_msg(log_msg &msg)
- {
- msg.logger_name = &logger_name;
- msg.level = level;
- msg.time = time;
- msg.thread_id = thread_id;
- msg.raw << txt;
- }
- };
-
-public:
-
- using item_type = async_msg;
- using q_type = details::mpmc_bounded_queue<item_type>;
-
- using clock = std::chrono::steady_clock;
-
-
- async_log_helper(formatter_ptr formatter,
- const std::vector<sink_ptr>& sinks,
- size_t queue_size,
- const log_err_handler err_handler,
- const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
- const std::function<void()>& worker_warmup_cb = nullptr,
- const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
- const std::function<void()>& worker_teardown_cb = nullptr);
-
- void log(const details::log_msg& msg);
-
- // stop logging and join the back thread
- ~async_log_helper();
-
- void set_formatter(formatter_ptr);
-
- void flush(bool wait_for_q);
-
-
-private:
- formatter_ptr _formatter;
- std::vector<std::shared_ptr<sinks::sink>> _sinks;
-
- // queue of messages to log
- q_type _q;
-
- log_err_handler _err_handler;
-
- bool _flush_requested;
-
- bool _terminate_requested;
-
-
- // overflow policy
- const async_overflow_policy _overflow_policy;
-
- // worker thread warmup callback - one can set thread priority, affinity, etc
- const std::function<void()> _worker_warmup_cb;
-
- // auto periodic sink flush parameter
- const std::chrono::milliseconds _flush_interval_ms;
-
- // worker thread teardown callback
- const std::function<void()> _worker_teardown_cb;
-
- // worker thread
- std::thread _worker_thread;
-
- void push_msg(async_msg&& new_msg);
-
- // worker thread main loop
- void worker_loop();
-
- // pop next message from the queue and process it. will set the last_pop to the pop time
- // return false if termination of the queue is required
- bool process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush);
-
- void handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush);
-
- // sleep,yield or return immediatly using the time passed since last message as a hint
- static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time);
-
- // wait until the queue is empty
- void wait_empty_q();
-
-};
-}
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// 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,
- log_err_handler err_handler,
- const async_overflow_policy overflow_policy,
- const std::function<void()>& worker_warmup_cb,
- const std::chrono::milliseconds& flush_interval_ms,
- const std::function<void()>& worker_teardown_cb):
- _formatter(formatter),
- _sinks(sinks),
- _q(queue_size),
- _err_handler(err_handler),
- _flush_requested(false),
- _terminate_requested(false),
- _overflow_policy(overflow_policy),
- _worker_warmup_cb(worker_warmup_cb),
- _flush_interval_ms(flush_interval_ms),
- _worker_teardown_cb(worker_teardown_cb),
- _worker_thread(&async_log_helper::worker_loop, this)
-{}
-
-// Send to the worker thread termination message(level=off)
-// and wait for it to finish gracefully
-inline spdlog::details::async_log_helper::~async_log_helper()
-{
- try
- {
- push_msg(async_msg(async_msg_type::terminate));
- _worker_thread.join();
- }
- catch (...) // don't crash in destructor
- {}
-}
-
-
-//Try to push and block until succeeded (if the policy is not to discard when the queue is full)
-inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)
-{
- push_msg(async_msg(msg));
-
-
-}
-
-inline void spdlog::details::async_log_helper::push_msg(details::async_log_helper::async_msg&& new_msg)
-{
- if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)
- {
- auto last_op_time = details::os::now();
- auto now = last_op_time;
- do
- {
- now = details::os::now();
- sleep_or_yield(now, last_op_time);
- }
- while (!_q.enqueue(std::move(new_msg)));
- }
-
-}
-
-// optionally wait for the queue be empty and request flush from the sinks
-inline void spdlog::details::async_log_helper::flush(bool wait_for_q)
-{
- push_msg(async_msg(async_msg_type::flush));
- if(wait_for_q)
- wait_empty_q(); //return only make after the above flush message was processed
-}
-
-inline void spdlog::details::async_log_helper::worker_loop()
-{
- try
- {
- if (_worker_warmup_cb) _worker_warmup_cb();
- auto last_pop = details::os::now();
- auto last_flush = last_pop;
- while(process_next_msg(last_pop, last_flush));
- if (_worker_teardown_cb) _worker_teardown_cb();
- }
- catch (const std::exception &ex)
- {
- _err_handler(ex.what());
- }
- catch (...)
- {
- _err_handler("Unknown exception");
- }
-}
-
-// process next message in the queue
-// return true if this thread should still be active (while no terminate msg was received)
-inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush)
-{
-
- async_msg incoming_async_msg;
-
-
- if (_q.dequeue(incoming_async_msg))
- {
- last_pop = details::os::now();
- switch (incoming_async_msg.msg_type)
- {
- case async_msg_type::flush:
- _flush_requested = true;
- break;
-
- case async_msg_type::terminate:
- _flush_requested = true;
- _terminate_requested = true;
- break;
-
- default:
- log_msg incoming_log_msg;
- incoming_async_msg.fill_log_msg(incoming_log_msg);
- _formatter->format(incoming_log_msg);
- for (auto &s : _sinks)
- {
- if(s->should_log( incoming_log_msg.level))
- {
- s->log(incoming_log_msg);
- }
- }
- }
- return true;
- }
-
- // Handle empty queue..
- // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue
- else
- {
- auto now = details::os::now();
- handle_flush_interval(now, last_flush);
- sleep_or_yield(now, last_pop);
- return !_terminate_requested;
- }
-}
-
-// flush all sinks if _flush_interval_ms has expired
-inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush)
-{
- auto should_flush = _flush_requested || (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms);
- if (should_flush)
- {
- for (auto &s : _sinks)
- s->flush();
- now = last_flush = details::os::now();
- _flush_requested = false;
- }
-}
-
-inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)
-{
- _formatter = msg_formatter;
-}
-
-
-// spin, yield or sleep. use the time passed since last message as a hint
-inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_clock::time_point& now, const spdlog::log_clock::time_point& last_op_time)
-{
- using namespace std::this_thread;
- using std::chrono::milliseconds;
- using std::chrono::microseconds;
-
- auto time_since_op = now - last_op_time;
-
- // spin upto 50 micros
- if (time_since_op <= microseconds(50))
- return;
-
- // yield upto 150 micros
- if (time_since_op <= microseconds(100))
- return yield();
-
-
- // sleep for 20 ms upto 200 ms
- if (time_since_op <= milliseconds(200))
- return sleep_for(milliseconds(20));
-
- // sleep for 200 ms
- return sleep_for(milliseconds(200));
-}
-
-// wait for the queue to be empty
-inline void spdlog::details::async_log_helper::wait_empty_q()
-{
- auto last_op = details::os::now();
- while (_q.approx_size() > 0)
- {
- sleep_or_yield(details::os::now(), last_op);
- }
-
-}
-
-
-
-
-
-
-
-
diff --git a/third_party/spdlog/include/spdlog/details/async_logger_impl.h b/third_party/spdlog/include/spdlog/details/async_logger_impl.h
deleted file mode 100644
index 2092f06cfa81def0b96a7ed795266f6b0d098dbc..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/async_logger_impl.h
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Async Logger implementation
-// Use an async_sink (queue per logger) to perform the logging in a worker thread
-
-#include <spdlog/details/async_log_helper.h>
-#include <spdlog/async_logger.h>
-
-#include <string>
-#include <functional>
-#include <chrono>
-#include <memory>
-
-template<class It>
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
- const It& begin,
- const It& end,
- size_t queue_size,
- const async_overflow_policy overflow_policy,
- const std::function<void()>& worker_warmup_cb,
- const std::chrono::milliseconds& flush_interval_ms,
- const std::function<void()>& worker_teardown_cb) :
- logger(logger_name, begin, end),
- _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
-{
-}
-
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
- sinks_init_list sinks_list,
- size_t queue_size,
- const async_overflow_policy overflow_policy,
- const std::function<void()>& worker_warmup_cb,
- const std::chrono::milliseconds& flush_interval_ms,
- const std::function<void()>& worker_teardown_cb) :
- async_logger(logger_name, sinks_list.begin(), sinks_list.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
-
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
- sink_ptr single_sink,
- size_t queue_size,
- const async_overflow_policy overflow_policy,
- const std::function<void()>& worker_warmup_cb,
- const std::chrono::milliseconds& flush_interval_ms,
- const std::function<void()>& worker_teardown_cb) :
- async_logger(logger_name,
-{
- single_sink
-}, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
-
-
-inline void spdlog::async_logger::flush()
-{
- _async_log_helper->flush(true);
-}
-
-inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter)
-{
- _formatter = msg_formatter;
- _async_log_helper->set_formatter(_formatter);
-}
-
-inline void spdlog::async_logger::_set_pattern(const std::string& pattern)
-{
- _formatter = std::make_shared<pattern_formatter>(pattern);
- _async_log_helper->set_formatter(_formatter);
-}
-
-
-inline void spdlog::async_logger::_sink_it(details::log_msg& msg)
-{
- try
- {
- _async_log_helper->log(msg);
- if (_should_flush_on(msg))
- _async_log_helper->flush(false); // do async flush
- }
- catch (const std::exception &ex)
- {
- _err_handler(ex.what());
- }
- catch (...)
- {
- _err_handler("Unknown exception");
- }
-}
diff --git a/third_party/spdlog/include/spdlog/details/file_helper.h b/third_party/spdlog/include/spdlog/details/file_helper.h
deleted file mode 100644
index 074d9b8356061316c99b60983608bfaab0221218..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/file_helper.h
+++ /dev/null
@@ -1,118 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Helper class for file sink
-// When failing to open a file, retry several times(5) with small delay between the tries(10 ms)
-// Can be set to auto flush on every line
-// Throw spdlog_ex exception on errors
-
-#include <spdlog/details/os.h>
-#include <spdlog/details/log_msg.h>
-
-#include <chrono>
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <cerrno>
-
-namespace spdlog
-{
-namespace details
-{
-
-class file_helper
-{
-
-public:
- const int open_tries = 5;
- const int open_interval = 10;
-
- explicit file_helper() :
- _fd(nullptr)
- {}
-
- file_helper(const file_helper&) = delete;
- file_helper& operator=(const file_helper&) = delete;
-
- ~file_helper()
- {
- close();
- }
-
-
- void open(const filename_t& fname, bool truncate = false)
- {
-
- close();
- auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
- _filename = fname;
- for (int tries = 0; tries < open_tries; ++tries)
- {
- if (!os::fopen_s(&_fd, fname, mode))
- return;
-
- std::this_thread::sleep_for(std::chrono::milliseconds(open_interval));
- }
-
- throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno);
- }
-
- void reopen(bool truncate)
- {
- if (_filename.empty())
- throw spdlog_ex("Failed re opening file - was not opened before");
- open(_filename, truncate);
-
- }
-
- void flush()
- {
- std::fflush(_fd);
- }
-
- void close()
- {
- if (_fd)
- {
- std::fclose(_fd);
- _fd = nullptr;
- }
- }
-
- void write(const log_msg& msg)
- {
-
- size_t msg_size = msg.formatted.size();
- auto data = msg.formatted.data();
- if (std::fwrite(data, 1, msg_size, _fd) != msg_size)
- throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);
- }
-
- size_t size()
- {
- if (!_fd)
- throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
- return os::filesize(_fd);
- }
-
- const filename_t& filename() const
- {
- return _filename;
- }
-
- static bool file_exists(const filename_t& name)
- {
-
- return os::file_exists(name);
- }
-
-private:
- FILE* _fd;
- filename_t _filename;
-};
-}
-}
diff --git a/third_party/spdlog/include/spdlog/details/log_msg.h b/third_party/spdlog/include/spdlog/details/log_msg.h
deleted file mode 100644
index ecdc73d7c77780ce80831e54a4e2151e238e5504..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/log_msg.h
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/common.h>
-#include <spdlog/details/os.h>
-
-
-#include <string>
-#include <utility>
-
-namespace spdlog
-{
-namespace details
-{
-struct log_msg
-{
- log_msg() = default;
- log_msg(const std::string *loggers_name, level::level_enum lvl) : logger_name(loggers_name), level(lvl)
- {
-#ifndef SPDLOG_NO_DATETIME
- time = os::now();
-#endif
-
-#ifndef SPDLOG_NO_THREAD_ID
- thread_id = os::thread_id();
-#endif
- }
-
- log_msg(const log_msg& other) = delete;
- log_msg& operator=(log_msg&& other) = delete;
- log_msg(log_msg&& other) = delete;
-
-
- const std::string *logger_name;
- level::level_enum level;
- log_clock::time_point time;
- size_t thread_id;
- fmt::MemoryWriter raw;
- fmt::MemoryWriter formatted;
-};
-}
-}
diff --git a/third_party/spdlog/include/spdlog/details/logger_impl.h b/third_party/spdlog/include/spdlog/details/logger_impl.h
deleted file mode 100644
index 2b27f1053722ea28b8b273174f06e900ab5590a0..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/logger_impl.h
+++ /dev/null
@@ -1,298 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/logger.h>
-#include <spdlog/sinks/stdout_sinks.h>
-
-#include <memory>
-#include <string>
-
-
-// create logger with given name, sinks and the default pattern formatter
-// all other ctors will call this one
-template<class It>
-inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end):
- _name(logger_name),
- _sinks(begin, end),
- _formatter(std::make_shared<pattern_formatter>("%+"))
-{
- _level = level::info;
- _flush_level = level::off;
- _last_err_time = 0;
- _err_handler = [this](const std::string &msg)
- {
- this->_default_err_handler(msg);
- };
-}
-
-// ctor with sinks as init list
-inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list):
- logger(logger_name, sinks_list.begin(), sinks_list.end())
-{}
-
-
-// ctor with single sink
-inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink):
- logger(logger_name,
-{
- single_sink
-})
-{}
-
-
-inline spdlog::logger::~logger() = default;
-
-
-inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
-{
- _set_formatter(msg_formatter);
-}
-
-inline void spdlog::logger::set_pattern(const std::string& pattern)
-{
- _set_pattern(pattern);
-}
-
-
-template <typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const char* fmt, const Args&... args)
-{
- if (!should_log(lvl)) return;
-
- try
- {
- details::log_msg log_msg(&_name, lvl);
- log_msg.raw.write(fmt, args...);
- _sink_it(log_msg);
- }
- catch (const std::exception &ex)
- {
- _err_handler(ex.what());
- }
- catch (...)
- {
- _err_handler("Unknown exception");
- }
-}
-
-template <typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const char* msg)
-{
- if (!should_log(lvl)) return;
- try
- {
- details::log_msg log_msg(&_name, lvl);
- log_msg.raw << msg;
- _sink_it(log_msg);
- }
- catch (const std::exception &ex)
- {
- _err_handler(ex.what());
- }
- catch (...)
- {
- _err_handler("Unknown exception");
- }
-
-}
-
-template<typename T>
-inline void spdlog::logger::log(level::level_enum lvl, const T& msg)
-{
- if (!should_log(lvl)) return;
- try
- {
- details::log_msg log_msg(&_name, lvl);
- log_msg.raw << msg;
- _sink_it(log_msg);
- }
- catch (const std::exception &ex)
- {
- _err_handler(ex.what());
- }
- catch (...)
- {
- _err_handler("Unknown exception");
- }
-}
-
-
-template <typename... Args>
-inline void spdlog::logger::trace(const char* fmt, const Args&... args)
-{
- log(level::trace, fmt, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::debug(const char* fmt, const Args&... args)
-{
- log(level::debug, fmt, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::info(const char* fmt, const Args&... args)
-{
- log(level::info, fmt, args...);
-}
-
-
-template <typename... Args>
-inline void spdlog::logger::warn(const char* fmt, const Args&... args)
-{
- log(level::warn, fmt, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::error(const char* fmt, const Args&... args)
-{
- log(level::err, fmt, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::critical(const char* fmt, const Args&... args)
-{
- log(level::critical, fmt, args...);
-}
-
-
-template<typename T>
-inline void spdlog::logger::trace(const T& msg)
-{
- log(level::trace, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::debug(const T& msg)
-{
- log(level::debug, msg);
-}
-
-
-template<typename T>
-inline void spdlog::logger::info(const T& msg)
-{
- log(level::info, msg);
-}
-
-
-template<typename T>
-inline void spdlog::logger::warn(const T& msg)
-{
- log(level::warn, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::error(const T& msg)
-{
- log(level::err, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::critical(const T& msg)
-{
- log(level::critical, msg);
-}
-
-
-
-
-//
-// name and level
-//
-inline const std::string& spdlog::logger::name() const
-{
- return _name;
-}
-
-inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
-{
- _level.store(log_level);
-}
-
-inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
-{
- _err_handler = err_handler;
-}
-
-inline spdlog::log_err_handler spdlog::logger::error_handler()
-{
- return _err_handler;
-}
-
-
-inline void spdlog::logger::flush_on(level::level_enum log_level)
-{
- _flush_level.store(log_level);
-}
-
-inline spdlog::level::level_enum spdlog::logger::level() const
-{
- return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
-}
-
-inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
-{
- return msg_level >= _level.load(std::memory_order_relaxed);
-}
-
-//
-// protected virtual called at end of each user log call (if enabled) by the line_logger
-//
-inline void spdlog::logger::_sink_it(details::log_msg& msg)
-{
- _formatter->format(msg);
- for (auto &sink : _sinks)
- {
- if( sink->should_log( msg.level))
- {
- sink->log(msg);
- }
- }
-
- if(_should_flush_on(msg))
- flush();
-}
-
-inline void spdlog::logger::_set_pattern(const std::string& pattern)
-{
- _formatter = std::make_shared<pattern_formatter>(pattern);
-}
-inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
-{
- _formatter = msg_formatter;
-}
-
-inline void spdlog::logger::flush()
-{
- for (auto& sink : _sinks)
- sink->flush();
-}
-
-inline void spdlog::logger::_default_err_handler(const std::string &msg)
-{
- auto now = time(nullptr);
- if (now - _last_err_time < 60)
- return;
- auto tm_time = details::os::localtime(now);
- char date_buf[100];
- std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
- details::log_msg err_msg;
- err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::eol);
- sinks::stderr_sink_mt::instance()->log(err_msg);
- _last_err_time = now;
-}
-
-inline bool spdlog::logger::_should_flush_on(const details::log_msg &msg)
-{
- const auto flush_level = _flush_level.load(std::memory_order_relaxed);
- return (msg.level >= flush_level) && (msg.level != level::off);
-}
-
-inline const std::vector<spdlog::sink_ptr>& spdlog::logger::sinks() const
-{
- return _sinks;
-}
diff --git a/third_party/spdlog/include/spdlog/details/mpmc_bounded_q.h b/third_party/spdlog/include/spdlog/details/mpmc_bounded_q.h
deleted file mode 100644
index 3a46e8ebd52b6f6be991bad7df7f54e9b2445142..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/mpmc_bounded_q.h
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-A modified version of Bounded MPMC queue by Dmitry Vyukov.
-
-Original code from:
-http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
-
-licensed by Dmitry Vyukov under the terms below:
-
-Simplified BSD license
-
-Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved.
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice, this list of
-conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list
-of conditions and the following disclaimer in the documentation and/or other materials
-provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
-SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-The views and conclusions contained in the software and documentation are those of the authors and
-should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov.
-*/
-
-/*
-The code in its current form adds the license below:
-
-Copyright(c) 2015 Gabi Melman.
-Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-*/
-
-#pragma once
-
-#include <spdlog/common.h>
-
-#include <atomic>
-#include <utility>
-
-namespace spdlog
-{
-namespace details
-{
-
-template<typename T>
-class mpmc_bounded_queue
-{
-public:
-
- using item_type = T;
- mpmc_bounded_queue(size_t buffer_size)
- :max_size_(buffer_size),
- buffer_(new cell_t [buffer_size]),
- buffer_mask_(buffer_size - 1)
- {
- //queue size must be power of two
- if(!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
- throw spdlog_ex("async logger queue size must be power of two");
-
- for (size_t i = 0; i != buffer_size; i += 1)
- buffer_[i].sequence_.store(i, std::memory_order_relaxed);
- enqueue_pos_.store(0, std::memory_order_relaxed);
- dequeue_pos_.store(0, std::memory_order_relaxed);
- }
-
- ~mpmc_bounded_queue()
- {
- delete [] buffer_;
- }
-
-
- bool enqueue(T&& data)
- {
- cell_t* cell;
- size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
- for (;;)
- {
- cell = &buffer_[pos & buffer_mask_];
- size_t seq = cell->sequence_.load(std::memory_order_acquire);
- intptr_t dif = (intptr_t)seq - (intptr_t)pos;
- if (dif == 0)
- {
- if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
- break;
- }
- else if (dif < 0)
- {
- return false;
- }
- else
- {
- pos = enqueue_pos_.load(std::memory_order_relaxed);
- }
- }
- cell->data_ = std::move(data);
- cell->sequence_.store(pos + 1, std::memory_order_release);
- return true;
- }
-
- bool dequeue(T& data)
- {
- cell_t* cell;
- size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
- for (;;)
- {
- cell = &buffer_[pos & buffer_mask_];
- size_t seq =
- cell->sequence_.load(std::memory_order_acquire);
- intptr_t dif = (intptr_t)seq - (intptr_t)(pos + 1);
- if (dif == 0)
- {
- if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
- break;
- }
- else if (dif < 0)
- return false;
- else
- pos = dequeue_pos_.load(std::memory_order_relaxed);
- }
- data = std::move(cell->data_);
- cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
- return true;
- }
-
- size_t approx_size()
- {
- size_t first_pos = dequeue_pos_.load(std::memory_order_relaxed);
- size_t last_pos = enqueue_pos_.load(std::memory_order_relaxed);
- if (last_pos <= first_pos)
- return 0;
- auto size = last_pos - first_pos;
- return size < max_size_ ? size : max_size_;
- }
-
-private:
- struct cell_t
- {
- std::atomic<size_t> sequence_;
- T data_;
- };
-
- size_t const max_size_;
-
- static size_t const cacheline_size = 64;
- typedef char cacheline_pad_t [cacheline_size];
-
- cacheline_pad_t pad0_;
- cell_t* const buffer_;
- size_t const buffer_mask_;
- cacheline_pad_t pad1_;
- std::atomic<size_t> enqueue_pos_;
- cacheline_pad_t pad2_;
- std::atomic<size_t> dequeue_pos_;
- cacheline_pad_t pad3_;
-
- mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
- void operator= (mpmc_bounded_queue const&) = delete;
-};
-
-} // ns details
-} // ns spdlog
diff --git a/third_party/spdlog/include/spdlog/details/null_mutex.h b/third_party/spdlog/include/spdlog/details/null_mutex.h
deleted file mode 100644
index 67b0aeee004c3120d33d54e546a18854ac4d0ecc..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/null_mutex.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <atomic>
-// null, no cost dummy "mutex" and dummy "atomic" int
-
-namespace spdlog
-{
-namespace details
-{
-struct null_mutex
-{
- void lock() {}
- void unlock() {}
- bool try_lock()
- {
- return true;
- }
-};
-
-struct null_atomic_int
-{
- int value;
- null_atomic_int() = default;
-
- null_atomic_int(int val):value(val)
- {}
-
- int load(std::memory_order) const
- {
- return value;
- }
-
- void store(int val)
- {
- value = val;
- }
-};
-
-}
-}
diff --git a/third_party/spdlog/include/spdlog/details/os.h b/third_party/spdlog/include/spdlog/details/os.h
deleted file mode 100644
index 86efa0dcdd50f27b2232dfe2036896ed3f64c3c4..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/os.h
+++ /dev/null
@@ -1,361 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-#pragma once
-
-#include <spdlog/common.h>
-
-#include <cstdio>
-#include <ctime>
-#include <functional>
-#include <string>
-#include <stdio.h>
-#include <string.h>
-#include <sys/stat.h>
-
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX //prevent windows redefining min/max
-#endif
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-
-#ifdef __MINGW32__
-#include <share.h>
-#endif
-
-#include <sys/types.h>
-#include <io.h>
-
-#elif __linux__
-
-#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
-#include <unistd.h>
-#include <chrono>
-
-#elif __FreeBSD__
-#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
-
-#else
-#include <thread>
-
-#endif
-
-namespace spdlog
-{
-namespace details
-{
-namespace os
-{
-
-inline spdlog::log_clock::time_point now()
-{
-
-#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
- timespec ts;
- ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
- return std::chrono::time_point<log_clock, typename log_clock::duration>(
- std::chrono::duration_cast<typename log_clock::duration>(
- std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
-
-
-#else
- return log_clock::now();
-#endif
-
-}
-inline std::tm localtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
- std::tm tm;
- localtime_s(&tm, &time_tt);
-#else
- std::tm tm;
- localtime_r(&time_tt, &tm);
-#endif
- return tm;
-}
-
-inline std::tm localtime()
-{
- std::time_t now_t = time(nullptr);
- return localtime(now_t);
-}
-
-
-inline std::tm gmtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
- std::tm tm;
- gmtime_s(&tm, &time_tt);
-#else
- std::tm tm;
- gmtime_r(&time_tt, &tm);
-#endif
- return tm;
-}
-
-inline std::tm gmtime()
-{
- std::time_t now_t = time(nullptr);
- return gmtime(now_t);
-}
-inline bool operator==(const std::tm& tm1, const std::tm& tm2)
-{
- return (tm1.tm_sec == tm2.tm_sec &&
- tm1.tm_min == tm2.tm_min &&
- tm1.tm_hour == tm2.tm_hour &&
- tm1.tm_mday == tm2.tm_mday &&
- tm1.tm_mon == tm2.tm_mon &&
- tm1.tm_year == tm2.tm_year &&
- tm1.tm_isdst == tm2.tm_isdst);
-}
-
-inline bool operator!=(const std::tm& tm1, const std::tm& tm2)
-{
- return !(tm1 == tm2);
-}
-
-// eol definition
-#if !defined (SPDLOG_EOL)
-#ifdef _WIN32
-#define SPDLOG_EOL "\r\n"
-#else
-#define SPDLOG_EOL "\n"
-#endif
-#endif
-
-SPDLOG_CONSTEXPR static const char* eol = SPDLOG_EOL;
-SPDLOG_CONSTEXPR static int eol_size = sizeof(SPDLOG_EOL) - 1;
-
-
-
-//fopen_s on non windows for writing
-inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
- *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
-#else
- *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
-#endif
- return *fp == nullptr;
-#else
- *fp = fopen((filename.c_str()), mode.c_str());
- return *fp == nullptr;
-#endif
-}
-
-inline int remove(const filename_t &filename)
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
- return _wremove(filename.c_str());
-#else
- return std::remove(filename.c_str());
-#endif
-}
-
-inline int rename(const filename_t& filename1, const filename_t& filename2)
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
- return _wrename(filename1.c_str(), filename2.c_str());
-#else
- return std::rename(filename1.c_str(), filename2.c_str());
-#endif
-}
-
-
-//Return if file exists
-inline bool file_exists(const filename_t& filename)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
- auto attribs = GetFileAttributesW(filename.c_str());
-#else
- auto attribs = GetFileAttributesA(filename.c_str());
-#endif
- return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
-#else //common linux/unix all have the stat system call
- struct stat buffer;
- return (stat (filename.c_str(), &buffer) == 0);
-#endif
-}
-
-
-
-
-//Return file size according to open FILE* object
-inline size_t filesize(FILE *f)
-{
- if (f == nullptr)
- throw spdlog_ex("Failed getting file size. fd is null");
-#ifdef _WIN32
- int fd = _fileno(f);
-#if _WIN64 //64 bits
- struct _stat64 st;
- if (_fstat64(fd, &st) == 0)
- return st.st_size;
-
-#else //windows 32 bits
- long ret = _filelength(fd);
- if (ret >= 0)
- return static_cast<size_t>(ret);
-#endif
-
-#else // unix
- int fd = fileno(f);
- //64 bits(but not in osx, where fstat64 is deprecated)
-#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__))
- struct stat64 st;
- if (fstat64(fd, &st) == 0)
- return static_cast<size_t>(st.st_size);
-#else // unix 32 bits or osx
- struct stat st;
- if (fstat(fd, &st) == 0)
- return static_cast<size_t>(st.st_size);
-#endif
-#endif
- throw spdlog_ex("Failed getting file size from fd", errno);
-}
-
-
-
-
-//Return utc offset in minutes or throw spdlog_ex on failure
-inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
-{
-
-#ifdef _WIN32
-#if _WIN32_WINNT < _WIN32_WINNT_WS08
- TIME_ZONE_INFORMATION tzinfo;
- auto rv = GetTimeZoneInformation(&tzinfo);
-#else
- DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
- auto rv = GetDynamicTimeZoneInformation(&tzinfo);
-#endif
- if (rv == TIME_ZONE_ID_INVALID)
- throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
-
- int offset = -tzinfo.Bias;
- if (tm.tm_isdst)
- offset -= tzinfo.DaylightBias;
- else
- offset -= tzinfo.StandardBias;
- return offset;
-#else
-
-#if defined(sun) || defined(__sun)
- // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
- struct helper
- {
- static long int calculate_gmt_offset(const std::tm & localtm = details::os::localtime(), const std::tm & gmtm = details::os::gmtime())
- {
- int local_year = localtm.tm_year + (1900 - 1);
- int gmt_year = gmtm.tm_year + (1900 - 1);
-
- long int days = (
- // difference in day of year
- localtm.tm_yday - gmtm.tm_yday
-
- // + intervening leap days
- + ((local_year >> 2) - (gmt_year >> 2))
- - (local_year / 100 - gmt_year / 100)
- + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
-
- // + difference in years * 365 */
- + (long int)(local_year - gmt_year) * 365
- );
-
- long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
- long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
- long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
-
- return secs;
- }
- };
-
- long int offset_seconds = helper::calculate_gmt_offset(tm);
-#else
- long int offset_seconds = tm.tm_gmtoff;
-#endif
-
- return static_cast<int>(offset_seconds / 60);
-#endif
-}
-
-//Return current thread id as size_t
-//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013)
-inline size_t thread_id()
-{
-#ifdef _WIN32
- return static_cast<size_t>(::GetCurrentThreadId());
-#elif __linux__
-# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-# define SYS_gettid __NR_gettid
-# endif
- return static_cast<size_t>(syscall(SYS_gettid));
-#elif __FreeBSD__
- long tid;
- thr_self(&tid);
- return static_cast<size_t>(tid);
-#else //Default to standard C++11 (OSX and other Unix)
- return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
-#endif
-
-
-}
-
-
-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-#define SPDLOG_FILENAME_T(s) L ## s
-inline std::string filename_to_str(const filename_t& filename)
-{
- std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
- return c.to_bytes(filename);
-}
-#else
-#define SPDLOG_FILENAME_T(s) s
-inline std::string filename_to_str(const filename_t& filename)
-{
- return filename;
-}
-#endif
-
-
-// Return errno string (thread safe)
-inline std::string errno_str(int err_num)
-{
- char buf[256];
- SPDLOG_CONSTEXPR auto buf_size = sizeof(buf);
-
-#ifdef _WIN32
- if(strerror_s(buf, buf_size, err_num) == 0)
- return std::string(buf);
- else
- return "Unkown error";
-
-#elif defined(__FreeBSD__) || defined(__APPLE__) || defined(ANDROID) || \
- ((_POSIX_C_SOURCE >= 200112L) && ! _GNU_SOURCE) // posix version
-
- if (strerror_r(err_num, buf, buf_size) == 0)
- return std::string(buf);
- else
- return "Unkown error";
-
-#else // gnu version (might not use the given buf, so its retval pointer must be used)
- return std::string(strerror_r(err_num, buf, buf_size));
-#endif
-}
-
-} //os
-} //details
-} //spdlog
diff --git a/third_party/spdlog/include/spdlog/details/pattern_formatter_impl.h b/third_party/spdlog/include/spdlog/details/pattern_formatter_impl.h
deleted file mode 100644
index 73c0db3b9ed2f5cdb9de03fe2b7bfb91a7a820eb..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/pattern_formatter_impl.h
+++ /dev/null
@@ -1,636 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/formatter.h>
-#include <spdlog/details/log_msg.h>
-#include <spdlog/details/os.h>
-#include <spdlog/fmt/fmt.h>
-
-#include <chrono>
-#include <ctime>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace spdlog
-{
-namespace details
-{
-class flag_formatter
-{
-public:
- virtual ~flag_formatter()
- {}
- virtual void format(details::log_msg& msg, const std::tm& tm_time) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////
-// name & level pattern appenders
-///////////////////////////////////////////////////////////////////////
-namespace
-{
-class name_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm&) override
- {
- msg.formatted << *msg.logger_name;
- }
-};
-}
-
-// log level appender
-class level_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm&) override
- {
- msg.formatted << level::to_str(msg.level);
- }
-};
-
-// short log level appender
-class short_level_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm&) override
- {
- msg.formatted << level::to_short_str(msg.level);
- }
-};
-
-///////////////////////////////////////////////////////////////////////
-// Date time pattern appenders
-///////////////////////////////////////////////////////////////////////
-
-static const char* ampm(const tm& t)
-{
- return t.tm_hour >= 12 ? "PM" : "AM";
-}
-
-static int to12h(const tm& t)
-{
- return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
-}
-
-//Abbreviated weekday name
-static const std::string days[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-class a_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << days[tm_time.tm_wday];
- }
-};
-
-//Full weekday name
-static const std::string full_days[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
-class A_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << full_days[tm_time.tm_wday];
- }
-};
-
-//Abbreviated month
-static const std::string months[] { "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sept", "Oct", "Nov", "Dec" };
-class b_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << months[tm_time.tm_mon];
- }
-};
-
-//Full month name
-static const std::string full_months[] { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
-class B_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << full_months[tm_time.tm_mon];
- }
-};
-
-
-//write 2 ints seperated by sep with padding of 2
-static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, char sep)
-{
- w << fmt::pad(v1, 2, '0') << sep << fmt::pad(v2, 2, '0');
- return w;
-}
-
-//write 3 ints seperated by sep with padding of 2
-static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, int v3, char sep)
-{
- w << fmt::pad(v1, 2, '0') << sep << fmt::pad(v2, 2, '0') << sep << fmt::pad(v3, 2, '0');
- return w;
-}
-
-
-//Date and time representation (Thu Aug 23 15:35:46 2014)
-class c_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << days[tm_time.tm_wday] << ' ' << months[tm_time.tm_mon] << ' ' << tm_time.tm_mday << ' ';
- pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << tm_time.tm_year + 1900;
- }
-};
-
-
-// year - 2 digit
-class C_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << fmt::pad(tm_time.tm_year % 100, 2, '0');
- }
-};
-
-
-
-// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
-class D_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- pad_n_join(msg.formatted, tm_time.tm_mon + 1, tm_time.tm_mday, tm_time.tm_year % 100, '/');
- }
-};
-
-
-// year - 4 digit
-class Y_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << tm_time.tm_year + 1900;
- }
-};
-
-// month 1-12
-class m_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << fmt::pad(tm_time.tm_mon + 1, 2, '0');
- }
-};
-
-// day of month 1-31
-class d_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << fmt::pad(tm_time.tm_mday, 2, '0');
- }
-};
-
-// hours in 24 format 0-23
-class H_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << fmt::pad(tm_time.tm_hour, 2, '0');
- }
-};
-
-// hours in 12 format 1-12
-class I_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << fmt::pad(to12h(tm_time), 2, '0');
- }
-};
-
-// minutes 0-59
-class M_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << fmt::pad(tm_time.tm_min, 2, '0');
- }
-};
-
-// seconds 0-59
-class S_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << fmt::pad(tm_time.tm_sec, 2, '0');
- }
-};
-
-// milliseconds
-class e_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm&) override
- {
- auto duration = msg.time.time_since_epoch();
- auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
- msg.formatted << fmt::pad(static_cast<int>(millis), 3, '0');
- }
-};
-
-// microseconds
-class f_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm&) override
- {
- auto duration = msg.time.time_since_epoch();
- auto micros = std::chrono::duration_cast<std::chrono::microseconds>(duration).count() % 1000000;
- msg.formatted << fmt::pad(static_cast<int>(micros), 6, '0');
- }
-};
-
-// nanoseconds
-class F_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm&) override
- {
- auto duration = msg.time.time_since_epoch();
- auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count() % 1000000000;
- msg.formatted << fmt::pad(static_cast<int>(ns), 9, '0');
- }
-};
-
-// AM/PM
-class p_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- msg.formatted << ampm(tm_time);
- }
-};
-
-
-// 12 hour clock 02:55:02 pm
-class r_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- pad_n_join(msg.formatted, to12h(tm_time), tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << ampm(tm_time);
- }
-};
-
-// 24-hour HH:MM time, equivalent to %H:%M
-class R_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, ':');
- }
-};
-
-// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
-class T_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
- pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':');
- }
-};
-
-
-// ISO 8601 offset from UTC in timezone (+-HH:MM)
-class z_formatter:public flag_formatter
-{
-public:
- const std::chrono::seconds cache_refresh = std::chrono::seconds(5);
-
- z_formatter():_last_update(std::chrono::seconds(0))
- {}
- z_formatter(const z_formatter&) = delete;
- z_formatter& operator=(const z_formatter&) = delete;
-
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
-#ifdef _WIN32
- int total_minutes = get_cached_offset(msg, tm_time);
-#else
- // No need to chache under gcc,
- // it is very fast (already stored in tm.tm_gmtoff)
- int total_minutes = os::utc_minutes_offset(tm_time);
-#endif
- bool is_negative = total_minutes < 0;
- char sign;
- if (is_negative)
- {
- total_minutes = -total_minutes;
- sign = '-';
- }
- else
- {
- sign = '+';
- }
-
- int h = total_minutes / 60;
- int m = total_minutes % 60;
- msg.formatted << sign;
- pad_n_join(msg.formatted, h, m, ':');
- }
-private:
- log_clock::time_point _last_update;
- int _offset_minutes;
- std::mutex _mutex;
-
- int get_cached_offset(const log_msg& msg, const std::tm& tm_time)
- {
- using namespace std::chrono;
- std::lock_guard<std::mutex> l(_mutex);
- if (msg.time - _last_update >= cache_refresh)
- {
- _offset_minutes = os::utc_minutes_offset(tm_time);
- _last_update = msg.time;
- }
- return _offset_minutes;
- }
-};
-
-
-
-//Thread id
-class t_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm&) override
- {
- msg.formatted << msg.thread_id;
- }
-};
-
-
-class v_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm&) override
- {
- msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());
- }
-};
-
-class ch_formatter:public flag_formatter
-{
-public:
- explicit ch_formatter(char ch): _ch(ch)
- {}
- void format(details::log_msg& msg, const std::tm&) override
- {
- msg.formatted << _ch;
- }
-private:
- char _ch;
-};
-
-
-//aggregate user chars to display as is
-class aggregate_formatter:public flag_formatter
-{
-public:
- aggregate_formatter()
- {}
- void add_ch(char ch)
- {
- _str += ch;
- }
- void format(details::log_msg& msg, const std::tm&) override
- {
- msg.formatted << _str;
- }
-private:
- std::string _str;
-};
-
-// Full info formatter
-// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
-class full_formatter:public flag_formatter
-{
- void format(details::log_msg& msg, const std::tm& tm_time) override
- {
-#ifndef SPDLOG_NO_DATETIME
- auto duration = msg.time.time_since_epoch();
- auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
-
- /* Slower version(while still very fast - about 3.2 million lines/sec under 10 threads),
- msg.formatted.write("[{:d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}.{:03d}] [{}] [{}] {} ",
- tm_time.tm_year + 1900,
- tm_time.tm_mon + 1,
- tm_time.tm_mday,
- tm_time.tm_hour,
- tm_time.tm_min,
- tm_time.tm_sec,
- static_cast<int>(millis),
- msg.logger_name,
- level::to_str(msg.level),
- msg.raw.str());*/
-
-
- // Faster (albeit uglier) way to format the line (5.6 million lines/sec under 10 threads)
- msg.formatted << '[' << static_cast<unsigned int>(tm_time.tm_year + 1900) << '-'
- << fmt::pad(static_cast<unsigned int>(tm_time.tm_mon + 1), 2, '0') << '-'
- << fmt::pad(static_cast<unsigned int>(tm_time.tm_mday), 2, '0') << ' '
- << fmt::pad(static_cast<unsigned int>(tm_time.tm_hour), 2, '0') << ':'
- << fmt::pad(static_cast<unsigned int>(tm_time.tm_min), 2, '0') << ':'
- << fmt::pad(static_cast<unsigned int>(tm_time.tm_sec), 2, '0') << '.'
- << fmt::pad(static_cast<unsigned int>(millis), 3, '0') << "] ";
-
- //no datetime needed
-#else
- (void)tm_time;
-#endif
-
-#ifndef SPDLOG_NO_NAME
- msg.formatted << '[' << *msg.logger_name << "] ";
-#endif
-
- msg.formatted << '[' << level::to_str(msg.level) << "] ";
- msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());
- }
-};
-
-}
-}
-///////////////////////////////////////////////////////////////////////////////
-// pattern_formatter inline impl
-///////////////////////////////////////////////////////////////////////////////
-inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern)
-{
- compile_pattern(pattern);
-}
-
-inline void spdlog::pattern_formatter::compile_pattern(const std::string& pattern)
-{
- auto end = pattern.end();
- std::unique_ptr<details::aggregate_formatter> user_chars;
- for (auto it = pattern.begin(); it != end; ++it)
- {
- if (*it == '%')
- {
- if (user_chars) //append user chars found so far
- _formatters.push_back(std::move(user_chars));
-
- if (++it != end)
- handle_flag(*it);
- else
- break;
- }
- else // chars not following the % sign should be displayed as is
- {
- if (!user_chars)
- user_chars = std::unique_ptr<details::aggregate_formatter>(new details::aggregate_formatter());
- user_chars->add_ch(*it);
- }
- }
- if (user_chars) //append raw chars found so far
- {
- _formatters.push_back(std::move(user_chars));
- }
-
-}
-inline void spdlog::pattern_formatter::handle_flag(char flag)
-{
- switch (flag)
- {
- // logger name
- case 'n':
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::name_formatter()));
- break;
-
- case 'l':
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::level_formatter()));
- break;
-
- case 'L':
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::short_level_formatter()));
- break;
-
- case('t'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::t_formatter()));
- break;
-
- case('v'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::v_formatter()));
- break;
-
- case('a'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::a_formatter()));
- break;
-
- case('A'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::A_formatter()));
- break;
-
- case('b'):
- case('h'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::b_formatter()));
- break;
-
- case('B'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::B_formatter()));
- break;
- case('c'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::c_formatter()));
- break;
-
- case('C'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::C_formatter()));
- break;
-
- case('Y'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::Y_formatter()));
- break;
-
- case('D'):
- case('x'):
-
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::D_formatter()));
- break;
-
- case('m'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::m_formatter()));
- break;
-
- case('d'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::d_formatter()));
- break;
-
- case('H'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::H_formatter()));
- break;
-
- case('I'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::I_formatter()));
- break;
-
- case('M'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::M_formatter()));
- break;
-
- case('S'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::S_formatter()));
- break;
-
- case('e'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::e_formatter()));
- break;
-
- case('f'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::f_formatter()));
- break;
- case('F'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::F_formatter()));
- break;
-
- case('p'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::p_formatter()));
- break;
-
- case('r'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::r_formatter()));
- break;
-
- case('R'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::R_formatter()));
- break;
-
- case('T'):
- case('X'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::T_formatter()));
- break;
-
- case('z'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::z_formatter()));
- break;
-
- case ('+'):
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::full_formatter()));
- break;
-
- default: //Unkown flag appears as is
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter('%')));
- _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter(flag)));
- break;
- }
-}
-
-
-inline void spdlog::pattern_formatter::format(details::log_msg& msg)
-{
-
-#ifndef SPDLOG_NO_DATETIME
- auto tm_time = details::os::localtime(log_clock::to_time_t(msg.time));
-#else
- std::tm tm_time;
-#endif
- for (auto &f : _formatters)
- {
- f->format(msg, tm_time);
- }
- //write eol
- msg.formatted.write(details::os::eol, details::os::eol_size);
-}
diff --git a/third_party/spdlog/include/spdlog/details/registry.h b/third_party/spdlog/include/spdlog/details/registry.h
deleted file mode 100644
index ee14adfdb106dc1d094c35c162ec45689460df6d..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/registry.h
+++ /dev/null
@@ -1,185 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Loggers registy of unique name->logger pointer
-// An attempt to create a logger with an already existing name will be ignored
-// If user requests a non existing logger, nullptr will be returned
-// This class is thread safe
-
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/logger.h>
-#include <spdlog/async_logger.h>
-#include <spdlog/common.h>
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <unordered_map>
-
-namespace spdlog
-{
-namespace details
-{
-template <class Mutex> class registry_t
-{
-public:
-
- void register_logger(std::shared_ptr<logger> logger)
- {
- std::lock_guard<Mutex> lock(_mutex);
- auto logger_name = logger->name();
- throw_if_exists(logger_name);
- _loggers[logger_name] = logger;
- }
-
-
- std::shared_ptr<logger> get(const std::string& logger_name)
- {
- std::lock_guard<Mutex> lock(_mutex);
- auto found = _loggers.find(logger_name);
- return found == _loggers.end() ? nullptr : found->second;
- }
-
- template<class It>
- std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
- {
- std::lock_guard<Mutex> lock(_mutex);
- throw_if_exists(logger_name);
- std::shared_ptr<logger> new_logger;
- if (_async_mode)
- new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb, _flush_interval_ms, _worker_teardown_cb);
- else
- new_logger = std::make_shared<logger>(logger_name, sinks_begin, sinks_end);
-
- if (_formatter)
- new_logger->set_formatter(_formatter);
-
- if (_err_handler)
- new_logger->set_error_handler(_err_handler);
-
- new_logger->set_level(_level);
-
-
- //Add to registry
- _loggers[logger_name] = new_logger;
- return new_logger;
- }
-
- void apply_all(std::function<void(std::shared_ptr<logger>)> fun)
- {
- std::lock_guard<Mutex> lock(_mutex);
- for (auto &l : _loggers)
- fun(l.second);
- }
-
- void drop(const std::string& logger_name)
- {
- std::lock_guard<Mutex> lock(_mutex);
- _loggers.erase(logger_name);
- }
-
- void drop_all()
- {
- std::lock_guard<Mutex> lock(_mutex);
- _loggers.clear();
- }
- std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks)
- {
- return create(logger_name, sinks.begin(), sinks.end());
- }
-
- std::shared_ptr<logger> create(const std::string& logger_name, sink_ptr sink)
- {
- return create(logger_name, { sink });
- }
-
-
- void formatter(formatter_ptr f)
- {
- std::lock_guard<Mutex> lock(_mutex);
- _formatter = f;
- for (auto& l : _loggers)
- l.second->set_formatter(_formatter);
- }
-
- void set_pattern(const std::string& pattern)
- {
- std::lock_guard<Mutex> lock(_mutex);
- _formatter = std::make_shared<pattern_formatter>(pattern);
- for (auto& l : _loggers)
- l.second->set_formatter(_formatter);
- }
-
- void set_level(level::level_enum log_level)
- {
- std::lock_guard<Mutex> lock(_mutex);
- for (auto& l : _loggers)
- l.second->set_level(log_level);
- _level = log_level;
- }
-
- void set_error_handler(log_err_handler handler)
- {
- for (auto& l : _loggers)
- l.second->set_error_handler(handler);
- _err_handler = handler;
- }
-
- 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, const std::function<void()>& worker_teardown_cb)
- {
- std::lock_guard<Mutex> lock(_mutex);
- _async_mode = true;
- _async_q_size = q_size;
- _overflow_policy = overflow_policy;
- _worker_warmup_cb = worker_warmup_cb;
- _flush_interval_ms = flush_interval_ms;
- _worker_teardown_cb = worker_teardown_cb;
- }
-
- void set_sync_mode()
- {
- std::lock_guard<Mutex> lock(_mutex);
- _async_mode = false;
- }
-
- static registry_t<Mutex>& instance()
- {
- static registry_t<Mutex> s_instance;
- return s_instance;
- }
-
-private:
- registry_t<Mutex>() {}
- registry_t<Mutex>(const registry_t<Mutex>&) = delete;
- registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
-
- void throw_if_exists(const std::string &logger_name)
- {
- if (_loggers.find(logger_name) != _loggers.end())
- throw spdlog_ex("logger with name '" + logger_name + "' already exists");
- }
- Mutex _mutex;
- std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
- formatter_ptr _formatter;
- level::level_enum _level = level::info;
- log_err_handler _err_handler;
- bool _async_mode = false;
- size_t _async_q_size = 0;
- async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;
- std::function<void()> _worker_warmup_cb = nullptr;
- std::chrono::milliseconds _flush_interval_ms;
- std::function<void()> _worker_teardown_cb = nullptr;
-};
-#ifdef SPDLOG_NO_REGISTRY_MUTEX
-typedef registry_t<spdlog::details::null_mutex> registry;
-#else
-typedef registry_t<std::mutex> registry;
-#endif
-}
-}
diff --git a/third_party/spdlog/include/spdlog/details/spdlog_impl.h b/third_party/spdlog/include/spdlog/details/spdlog_impl.h
deleted file mode 100644
index a8011db44ad492d2832c676ad61b857c2d7d8687..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/details/spdlog_impl.h
+++ /dev/null
@@ -1,245 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-//
-// Global registry functions
-//
-#include <spdlog/spdlog.h>
-#include <spdlog/details/registry.h>
-#include <spdlog/sinks/file_sinks.h>
-#include <spdlog/sinks/stdout_sinks.h>
-#ifdef SPDLOG_ENABLE_SYSLOG
-#include <spdlog/sinks/syslog_sink.h>
-#endif
-
-#ifdef _WIN32
-#include <spdlog/sinks/wincolor_sink.h>
-#else
-#include <spdlog/sinks/ansicolor_sink.h>
-#endif
-
-
-#ifdef __ANDROID__
-#include <spdlog/sinks/android_sink.h>
-#endif
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <string>
-
-inline void spdlog::register_logger(std::shared_ptr<logger> logger)
-{
- return details::registry::instance().register_logger(logger);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::get(const std::string& name)
-{
- return details::registry::instance().get(name);
-}
-
-inline void spdlog::drop(const std::string &name)
-{
- details::registry::instance().drop(name);
-}
-
-// Create multi/single threaded simple file logger
-inline std::shared_ptr<spdlog::logger> spdlog::basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate)
-{
- return create<spdlog::sinks::simple_file_sink_mt>(logger_name, filename, truncate);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::basic_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate)
-{
- return create<spdlog::sinks::simple_file_sink_st>(logger_name, filename, truncate);
-}
-
-// Create multi/single threaded rotating file logger
-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files)
-{
- return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files)
-{
- return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files);
-}
-
-// 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 filename_t& filename, int hour, int minute)
-{
- return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour, int minute)
-{
- return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute);
-}
-
-
-//
-// stdout/stderr loggers
-//
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt(const std::string& logger_name)
-{
- return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_mt::instance());
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st(const std::string& logger_name)
-{
- return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_st::instance());
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt(const std::string& logger_name)
-{
- return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_mt::instance());
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::string& logger_name)
-{
- return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_st::instance());
-}
-
-//
-// stdout/stderr color loggers
-//
-#ifdef _WIN32
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt(const std::string& logger_name)
-{
- auto sink = std::make_shared<spdlog::sinks::wincolor_stdout_sink_mt>();
- return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_st(const std::string& logger_name)
-{
- auto sink = std::make_shared<spdlog::sinks::wincolor_stdout_sink_st>();
- return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt(const std::string& logger_name)
-{
- auto sink = std::make_shared<spdlog::sinks::wincolor_stderr_sink_mt>();
- return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string& logger_name)
-{
- auto sink = std::make_shared<spdlog::sinks::wincolor_stderr_sink_st>();
- return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-#else //ansi terminal colors
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt(const std::string& logger_name)
-{
- auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stdout_sink_mt::instance());
- return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_st(const std::string& logger_name)
-{
- auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stdout_sink_st::instance());
- return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt(const std::string& logger_name)
-{
- auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stderr_sink_mt::instance());
- return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string& logger_name)
-{
- auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stderr_sink_st::instance());
- return spdlog::details::registry::instance().create(logger_name, sink);
-}
-#endif
-
-#ifdef SPDLOG_ENABLE_SYSLOG
-// Create syslog logger
-inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string& logger_name, const std::string& syslog_ident, int syslog_option)
-{
- return create<spdlog::sinks::syslog_sink>(logger_name, syslog_ident, syslog_option);
-}
-#endif
-
-#ifdef __ANDROID__
-inline std::shared_ptr<spdlog::logger> spdlog::android_logger(const std::string& logger_name, const std::string& tag)
-{
- return create<spdlog::sinks::android_sink>(logger_name, tag);
-}
-#endif
-
-// Create and register a logger a single sink
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const spdlog::sink_ptr& sink)
-{
- return details::registry::instance().create(logger_name, sink);
-}
-
-//Create logger with multiple sinks
-
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, spdlog::sinks_init_list sinks)
-{
- return details::registry::instance().create(logger_name, sinks);
-}
-
-
-template <typename Sink, typename... Args>
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, Args... args)
-{
- sink_ptr sink = std::make_shared<Sink>(args...);
- return details::registry::instance().create(logger_name, { sink });
-}
-
-
-template<class It>
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
-{
- return details::registry::instance().create(logger_name, sinks_begin, sinks_end);
-}
-
-inline void spdlog::set_formatter(spdlog::formatter_ptr f)
-{
- details::registry::instance().formatter(f);
-}
-
-inline void spdlog::set_pattern(const std::string& format_string)
-{
- return details::registry::instance().set_pattern(format_string);
-}
-
-inline void spdlog::set_level(level::level_enum log_level)
-{
- return details::registry::instance().set_level(log_level);
-}
-
-inline void spdlog::set_error_handler(log_err_handler handler)
-{
- return details::registry::instance().set_error_handler(handler);
-}
-
-
-inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
-{
- details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb);
-}
-
-inline void spdlog::set_sync_mode()
-{
- details::registry::instance().set_sync_mode();
-}
-
-inline void spdlog::apply_all(std::function<void(std::shared_ptr<logger>)> fun)
-{
- details::registry::instance().apply_all(fun);
-}
-
-inline void spdlog::drop_all()
-{
- details::registry::instance().drop_all();
-}
diff --git a/third_party/spdlog/include/spdlog/fmt/bundled/format.cc b/third_party/spdlog/include/spdlog/fmt/bundled/format.cc
deleted file mode 100644
index dbe0c1ec57b7d86601529c30f2e3935d1a9c8891..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/fmt/bundled/format.cc
+++ /dev/null
@@ -1,560 +0,0 @@
-/*
-Formatting library for C++
-
-Copyright (c) 2012 - 2016, Victor Zverovich
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-this list of conditions and the following disclaimer in the documentation
-and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-// commented out by spdlog
-// #include "format.h"
-// #include "printf.h"
-
-#include <string.h>
-
-#include <cctype>
-#include <cerrno>
-#include <climits>
-#include <cmath>
-#include <cstdarg>
-#include <cstddef> // for std::ptrdiff_t
-
-#if defined(_WIN32) && defined(__MINGW32__)
-# include <cstring>
-#endif
-
-#if FMT_USE_WINDOWS_H
-# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-# include <windows.h>
-# else
-# define NOMINMAX
-# include <windows.h>
-# undef NOMINMAX
-# endif
-#endif
-
-using fmt::internal::Arg;
-
-#if FMT_EXCEPTIONS
-# define FMT_TRY try
-# define FMT_CATCH(x) catch (x)
-#else
-# define FMT_TRY if (true)
-# define FMT_CATCH(x) if (false)
-#endif
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-# pragma warning(disable: 4702) // unreachable code
-// Disable deprecation warning for strerror. The latter is not called but
-// MSVC fails to detect it.
-# pragma warning(disable: 4996)
-#endif
-
-// Dummy implementations of strerror_r and strerror_s called if corresponding
-// system functions are not available.
-static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
- return fmt::internal::Null<>();
-}
-static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
- return fmt::internal::Null<>();
-}
-
-namespace fmt {
-
-FMT_FUNC internal::RuntimeError::~RuntimeError() throw() {}
-FMT_FUNC FormatError::~FormatError() throw() {}
-FMT_FUNC SystemError::~SystemError() throw() {}
-
-namespace {
-
-#ifndef _MSC_VER
-# define FMT_SNPRINTF snprintf
-#else // _MSC_VER
-inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
- va_list args;
- va_start(args, format);
- int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
- va_end(args);
- return result;
-}
-# define FMT_SNPRINTF fmt_snprintf
-#endif // _MSC_VER
-
-#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-# define FMT_SWPRINTF snwprintf
-#else
-# define FMT_SWPRINTF swprintf
-#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-
-const char RESET_COLOR[] = "\x1b[0m";
-
-typedef void(*FormatFunc)(Writer &, int, StringRef);
-
-// Portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-// 0 - success
-// ERANGE - buffer is not large enough to store the error message
-// other - failure
-// Buffer should be at least of size 1.
-int safe_strerror(
- int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT{
- FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");
-
- class StrError {
- private:
- int error_code_;
- char *&buffer_;
- std::size_t buffer_size_;
-
- // A noop assignment operator to avoid bogus warnings.
- void operator=(const StrError &) {}
-
- // Handle the result of XSI-compliant version of strerror_r.
- int handle(int result) {
- // glibc versions before 2.13 return result in errno.
- return result == -1 ? errno : result;
- }
-
- // Handle the result of GNU-specific version of strerror_r.
- int handle(char *message) {
- // If the buffer is full then the message is probably truncated.
- if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
- return ERANGE;
- buffer_ = message;
- return 0;
- }
-
- // Handle the case when strerror_r is not available.
- int handle(internal::Null<>) {
- return fallback(strerror_s(buffer_, buffer_size_, error_code_));
- }
-
- // Fallback to strerror_s when strerror_r is not available.
- int fallback(int result) {
- // If the buffer is full then the message is probably truncated.
- return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
- ERANGE : result;
- }
-
- // Fallback to strerror if strerror_r and strerror_s are not available.
- int fallback(internal::Null<>) {
- errno = 0;
- buffer_ = strerror(error_code_);
- return errno;
- }
-
- public:
- StrError(int err_code, char *&buf, std::size_t buf_size)
- : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-
- int run() {
- strerror_r(0, 0, ""); // Suppress a warning about unused strerror_r.
- return handle(strerror_r(error_code_, buffer_, buffer_size_));
- }
- };
- return StrError(error_code, buffer, buffer_size).run();
-}
-
-void format_error_code(Writer &out, int error_code,
- StringRef message) FMT_NOEXCEPT{
- // Report error code making sure that the output fits into
- // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
- // bad_alloc.
- out.clear();
- static const char SEP[] = ": ";
- static const char ERROR_STR[] = "error ";
- // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
- std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
- typedef internal::IntTraits<int>::MainType MainType;
- MainType abs_value = static_cast<MainType>(error_code);
- if (internal::is_negative(error_code)) {
- abs_value = 0 - abs_value;
- ++error_code_size;
- }
- error_code_size += internal::count_digits(abs_value);
- if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size)
- out << message << SEP;
- out << ERROR_STR << error_code;
- assert(out.size() <= internal::INLINE_BUFFER_SIZE);
-}
-
-void report_error(FormatFunc func, int error_code,
- StringRef message) FMT_NOEXCEPT{
- 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);
-}
-} // namespace
-
-namespace internal {
-
-// This method is used to preserve binary compatibility with fmt 3.0.
-// It can be removed in 4.0.
-FMT_FUNC void format_system_error(
- Writer &out, int error_code, StringRef message) FMT_NOEXCEPT{
- fmt::format_system_error(out, error_code, message);
-}
-} // namespace internal
-
-FMT_FUNC void SystemError::init(
- int err_code, CStringRef format_str, ArgList args) {
- error_code_ = err_code;
- MemoryWriter w;
- 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 internal::CharTraits<char>::format_float(
- char *buffer, std::size_t size, const char *format,
- unsigned width, int precision, T value) {
- if (width == 0) {
- return precision < 0 ?
- FMT_SNPRINTF(buffer, size, format, value) :
- FMT_SNPRINTF(buffer, size, format, precision, value);
- }
- return precision < 0 ?
- FMT_SNPRINTF(buffer, size, format, width, value) :
- FMT_SNPRINTF(buffer, size, format, width, precision, value);
-}
-
-template <typename T>
-int internal::CharTraits<wchar_t>::format_float(
- wchar_t *buffer, std::size_t size, const wchar_t *format,
- unsigned width, int precision, T value) {
- if (width == 0) {
- return precision < 0 ?
- FMT_SWPRINTF(buffer, size, format, value) :
- FMT_SWPRINTF(buffer, size, format, precision, value);
- }
- return precision < 0 ?
- FMT_SWPRINTF(buffer, size, format, width, value) :
- FMT_SWPRINTF(buffer, size, format, width, precision, value);
-}
-
-template <typename T>
-const char internal::BasicData<T>::DIGITS[] =
- "0001020304050607080910111213141516171819"
- "2021222324252627282930313233343536373839"
- "4041424344454647484950515253545556575859"
- "6061626364656667686970717273747576777879"
- "8081828384858687888990919293949596979899";
-
-#define FMT_POWERS_OF_10(factor) \
- factor * 10, \
- factor * 100, \
- factor * 1000, \
- factor * 10000, \
- factor * 100000, \
- factor * 1000000, \
- factor * 10000000, \
- factor * 100000000, \
- factor * 1000000000
-
-template <typename T>
-const uint32_t internal::BasicData<T>::POWERS_OF_10_32[] = {
- 0, FMT_POWERS_OF_10(1)
-};
-
-template <typename T>
-const uint64_t internal::BasicData<T>::POWERS_OF_10_64[] = {
- 0,
- FMT_POWERS_OF_10(1),
- FMT_POWERS_OF_10(ULongLong(1000000000)),
- // Multiply several constants instead of using a single long long constant
- // to avoid warnings about C++98 not supporting long long.
- ULongLong(1000000000) * ULongLong(1000000000) * 10
-};
-
-FMT_FUNC void internal::report_unknown_type(char code, const char *type) {
- (void)type;
- if (std::isprint(static_cast<unsigned char>(code))) {
- FMT_THROW(FormatError(
- format("unknown format code '{}' for {}", code, type)));
- }
- FMT_THROW(FormatError(
- format("unknown format code '\\x{:02x}' for {}",
- static_cast<unsigned>(code), type)));
-}
-
-#if FMT_USE_WINDOWS_H
-
-FMT_FUNC internal::UTF8ToUTF16::UTF8ToUTF16(StringRef s) {
- static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
- if (s.size() > INT_MAX)
- FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
- int s_size = static_cast<int>(s.size());
- int length = MultiByteToWideChar(
- CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);
- if (length == 0)
- FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
- buffer_.resize(length + 1);
- length = MultiByteToWideChar(
- CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
- if (length == 0)
- FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
- buffer_[length] = 0;
-}
-
-FMT_FUNC internal::UTF16ToUTF8::UTF16ToUTF8(WStringRef s) {
- if (int error_code = convert(s)) {
- FMT_THROW(WindowsError(error_code,
- "cannot convert string from UTF-16 to UTF-8"));
- }
-}
-
-FMT_FUNC int internal::UTF16ToUTF8::convert(WStringRef s) {
- if (s.size() > INT_MAX)
- return ERROR_INVALID_PARAMETER;
- int s_size = static_cast<int>(s.size());
- int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);
- if (length == 0)
- return GetLastError();
- buffer_.resize(length + 1);
- length = WideCharToMultiByte(
- CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);
- if (length == 0)
- return GetLastError();
- buffer_[length] = 0;
- return 0;
-}
-
-FMT_FUNC void WindowsError::init(
- int err_code, CStringRef format_str, ArgList args) {
- error_code_ = err_code;
- MemoryWriter w;
- internal::format_windows_error(w, err_code, format(format_str, args));
- std::runtime_error &base = *this;
- base = std::runtime_error(w.str());
-}
-
-FMT_FUNC void internal::format_windows_error(
- Writer &out, int error_code, StringRef message) FMT_NOEXCEPT{
- FMT_TRY{
- MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;
- buffer.resize(INLINE_BUFFER_SIZE);
- for (;;) {
- wchar_t *system_message = &buffer[0];
- int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
- 0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
- system_message, static_cast<uint32_t>(buffer.size()), 0);
- if (result != 0) {
- UTF16ToUTF8 utf8_message;
- if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
- out << message << ": " << utf8_message;
- return;
- }
- break;
- }
- if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
- break; // Can't get error message, report error code instead.
- buffer.resize(buffer.size() * 2);
- }
- } FMT_CATCH(...) {}
- fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32.
-}
-
-#endif // FMT_USE_WINDOWS_H
-
-FMT_FUNC void format_system_error(
- Writer &out, int error_code, StringRef message) FMT_NOEXCEPT{
- FMT_TRY{
- internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer;
- buffer.resize(internal::INLINE_BUFFER_SIZE);
- for (;;) {
- char *system_message = &buffer[0];
- int result = safe_strerror(error_code, system_message, buffer.size());
- if (result == 0) {
- out << message << ": " << system_message;
- return;
- }
- if (result != ERANGE)
- break; // Can't get error message, report error code instead.
- buffer.resize(buffer.size() * 2);
- }
- } FMT_CATCH(...) {}
- fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32.
-}
-
-template <typename Char>
-void internal::ArgMap<Char>::init(const ArgList &args) {
- if (!map_.empty())
- return;
- typedef internal::NamedArg<Char> NamedArg;
- const NamedArg *named_arg = 0;
- bool use_values =
- args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
- if (use_values) {
- for (unsigned i = 0;/*nothing*/; ++i) {
- internal::Arg::Type arg_type = args.type(i);
- switch (arg_type) {
- case internal::Arg::NONE:
- return;
- case internal::Arg::NAMED_ARG:
- named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
- map_.push_back(Pair(named_arg->name, *named_arg));
- break;
- default:
- /*nothing*/
- ;
- }
- }
- return;
- }
- for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
- internal::Arg::Type arg_type = args.type(i);
- if (arg_type == internal::Arg::NAMED_ARG) {
- named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
- map_.push_back(Pair(named_arg->name, *named_arg));
- }
- }
- for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
- switch (args.args_[i].type) {
- case internal::Arg::NONE:
- return;
- case internal::Arg::NAMED_ARG:
- named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
- map_.push_back(Pair(named_arg->name, *named_arg));
- break;
- default:
- /*nothing*/
- ;
- }
- }
-}
-
-template <typename Char>
-void internal::FixedBuffer<Char>::grow(std::size_t) {
- FMT_THROW(std::runtime_error("buffer overflow"));
-}
-
-FMT_FUNC Arg internal::FormatterBase::do_get_arg(
- unsigned arg_index, const char *&error) {
- Arg arg = args_[arg_index];
- switch (arg.type) {
- case Arg::NONE:
- error = "argument index out of range";
- break;
- case Arg::NAMED_ARG:
- arg = *static_cast<const internal::Arg*>(arg.pointer);
- break;
- default:
- /*nothing*/
- ;
- }
- return arg;
-}
-
-FMT_FUNC void report_system_error(
- int error_code, fmt::StringRef message) FMT_NOEXCEPT{
- // 'fmt::' is for bcc32.
- report_error(format_system_error, error_code, message);
-}
-
-#if FMT_USE_WINDOWS_H
-FMT_FUNC void report_windows_error(
- int error_code, fmt::StringRef message) FMT_NOEXCEPT{
- // 'fmt::' is for bcc32.
- report_error(internal::format_windows_error, error_code, message);
-}
-#endif
-
-FMT_FUNC void 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 print(CStringRef format_str, ArgList args) {
- print(stdout, format_str, args);
-}
-
-FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args) {
- char escape[] = "\x1b[30m";
- escape[3] = static_cast<char>('0' + c);
- std::fputs(escape, stdout);
- print(format, args);
- std::fputs(RESET_COLOR, stdout);
-}
-
-template <typename Char>
-void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args);
-
-FMT_FUNC int 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 internal::BasicData<void>;
-
-// Explicit instantiations for char.
-
-template void internal::FixedBuffer<char>::grow(std::size_t);
-
-template void internal::ArgMap<char>::init(const ArgList &args);
-
-template void PrintfFormatter<char>::format(CStringRef format);
-
-template int internal::CharTraits<char>::format_float(
- char *buffer, std::size_t size, const char *format,
- unsigned width, int precision, double value);
-
-template int internal::CharTraits<char>::format_float(
- char *buffer, std::size_t size, const char *format,
- unsigned width, int precision, long double value);
-
-// Explicit instantiations for wchar_t.
-
-template void internal::FixedBuffer<wchar_t>::grow(std::size_t);
-
-template void internal::ArgMap<wchar_t>::init(const ArgList &args);
-
-template void PrintfFormatter<wchar_t>::format(WCStringRef format);
-
-template int internal::CharTraits<wchar_t>::format_float(
- wchar_t *buffer, std::size_t size, const wchar_t *format,
- unsigned width, int precision, double value);
-
-template int internal::CharTraits<wchar_t>::format_float(
- wchar_t *buffer, std::size_t size, const wchar_t *format,
- unsigned width, int precision, long double value);
-
-#endif // FMT_HEADER_ONLY
-
-} // namespace fmt
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
\ No newline at end of file
diff --git a/third_party/spdlog/include/spdlog/fmt/bundled/format.h b/third_party/spdlog/include/spdlog/fmt/bundled/format.h
deleted file mode 100644
index ad8320099fe5b087292596775a242c2050c5a61e..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/fmt/bundled/format.h
+++ /dev/null
@@ -1,4495 +0,0 @@
-/*
-Formatting library for C++
-
-Copyright (c) 2012 - 2016, Victor Zverovich
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-this list of conditions and the following disclaimer in the documentation
-and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef FMT_FORMAT_H_
-#define FMT_FORMAT_H_
-
-#include <cassert>
-#include <clocale>
-#include <cmath>
-#include <cstdio>
-#include <cstring>
-#include <limits>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <vector>
-#include <utility>
-
-#ifdef _SECURE_SCL
-# define FMT_SECURE_SCL _SECURE_SCL
-#else
-# define FMT_SECURE_SCL 0
-#endif
-
-#if FMT_SECURE_SCL
-# include <iterator>
-#endif
-
-#ifdef _MSC_VER
-# define FMT_MSC_VER _MSC_VER
-#else
-# define FMT_MSC_VER 0
-#endif
-
-#if FMT_MSC_VER && FMT_MSC_VER <= 1500
-typedef unsigned __int32 uint32_t;
-typedef unsigned __int64 uint64_t;
-typedef __int64 intmax_t;
-#else
-#include <stdint.h>
-#endif
-
-#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-# ifdef FMT_EXPORT
-# define FMT_API __declspec(dllexport)
-# elif defined(FMT_SHARED)
-# define FMT_API __declspec(dllimport)
-# endif
-#endif
-#ifndef FMT_API
-# define FMT_API
-#endif
-
-#ifdef __GNUC__
-# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-# define FMT_GCC_EXTENSION __extension__
-# if FMT_GCC_VERSION >= 406
-# pragma GCC diagnostic push
-// Disable the warning about "long long" which is sometimes reported even
-// when using __extension__.
-# pragma GCC diagnostic ignored "-Wlong-long"
-// Disable the warning about declaration shadowing because it affects too
-// many valid cases.
-# pragma GCC diagnostic ignored "-Wshadow"
-// Disable the warning about implicit conversions that may change the sign of
-// an integer; silencing it otherwise would require many explicit casts.
-# pragma GCC diagnostic ignored "-Wsign-conversion"
-# endif
-# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
-# define FMT_HAS_GXX_CXX11 1
-# endif
-#else
-# define FMT_GCC_EXTENSION
-#endif
-
-#if defined(__INTEL_COMPILER)
-# define FMT_ICC_VERSION __INTEL_COMPILER
-#elif defined(__ICL)
-# define FMT_ICC_VERSION __ICL
-#endif
-
-#if defined(__clang__) && !defined(FMT_ICC_VERSION)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
-# pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-#ifdef __GNUC_LIBSTD__
-# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
-#endif
-
-#ifdef __has_feature
-# define FMT_HAS_FEATURE(x) __has_feature(x)
-#else
-# define FMT_HAS_FEATURE(x) 0
-#endif
-
-#ifdef __has_builtin
-# define FMT_HAS_BUILTIN(x) __has_builtin(x)
-#else
-# define FMT_HAS_BUILTIN(x) 0
-#endif
-
-#ifdef __has_cpp_attribute
-# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-# define FMT_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-#ifndef FMT_USE_VARIADIC_TEMPLATES
-// Variadic templates are available in GCC since version 4.4
-// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++
-// since version 2013.
-# define FMT_USE_VARIADIC_TEMPLATES \
- (FMT_HAS_FEATURE(cxx_variadic_templates) || \
- (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800)
-#endif
-
-#ifndef FMT_USE_RVALUE_REFERENCES
-// Don't use rvalue references when compiling with clang and an old libstdc++
-// as the latter doesn't provide std::move.
-# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402
-# define FMT_USE_RVALUE_REFERENCES 0
-# else
-# define FMT_USE_RVALUE_REFERENCES \
- (FMT_HAS_FEATURE(cxx_rvalue_references) || \
- (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600)
-# endif
-#endif
-
-#if FMT_USE_RVALUE_REFERENCES
-# include <utility> // for std::move
-#endif
-
-// Check if exceptions are disabled.
-#if defined(__GNUC__) && !defined(__EXCEPTIONS)
-# define FMT_EXCEPTIONS 0
-#endif
-#if FMT_MSC_VER && !_HAS_EXCEPTIONS
-# define FMT_EXCEPTIONS 0
-#endif
-#ifndef FMT_EXCEPTIONS
-# define FMT_EXCEPTIONS 1
-#endif
-
-#ifndef FMT_THROW
-# if FMT_EXCEPTIONS
-# define FMT_THROW(x) throw x
-# else
-# define FMT_THROW(x) assert(false)
-# endif
-#endif
-
-// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
-#ifndef FMT_USE_NOEXCEPT
-# define FMT_USE_NOEXCEPT 0
-#endif
-
-#ifndef FMT_NOEXCEPT
-# if FMT_EXCEPTIONS
-# if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
- (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
- FMT_MSC_VER >= 1900
-# define FMT_NOEXCEPT noexcept
-# else
-# define FMT_NOEXCEPT throw()
-# endif
-# else
-# define FMT_NOEXCEPT
-# endif
-#endif
-
-#ifndef FMT_OVERRIDE
-# if FMT_USE_OVERRIDE || FMT_HAS_FEATURE(cxx_override) || \
- (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
- FMT_MSC_VER >= 1900
-# define FMT_OVERRIDE override
-# else
-# define FMT_OVERRIDE
-# endif
-#endif
-
-
-// A macro to disallow the copy constructor and operator= functions
-// This should be used in the private: declarations for a class
-#ifndef FMT_USE_DELETED_FUNCTIONS
-# define FMT_USE_DELETED_FUNCTIONS 0
-#endif
-
-#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \
- (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800
-# define FMT_DELETED_OR_UNDEFINED = delete
-# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
- TypeName(const TypeName&) = delete; \
- TypeName& operator=(const TypeName&) = delete
-#else
-# define FMT_DELETED_OR_UNDEFINED
-# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
- TypeName(const TypeName&); \
- TypeName& operator=(const TypeName&)
-#endif
-
-#ifndef FMT_USE_USER_DEFINED_LITERALS
-// All compilers which support UDLs also support variadic templates. This
-// makes the fmt::literals implementation easier. However, an explicit check
-// for variadic templates is added here just in case.
-// For Intel's compiler both it and the system gcc/msc must support UDLs.
-# define FMT_USE_USER_DEFINED_LITERALS \
- FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
- (FMT_HAS_FEATURE(cxx_user_literals) || \
- (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \
- (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500)
-#endif
-
-#ifndef FMT_ASSERT
-# define FMT_ASSERT(condition, message) assert((condition) && message)
-#endif
-
-#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
-# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
-#endif
-
-#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
-# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
-#endif
-
-// Some compilers masquerade as both MSVC and GCC-likes or
-// otherwise support __builtin_clz and __builtin_clzll, so
-// only define FMT_BUILTIN_CLZ using the MSVC intrinsics
-// if the clz and clzll builtins are not available.
-#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL)
-# include <intrin.h> // _BitScanReverse, _BitScanReverse64
-
-namespace fmt
-{
-namespace internal
-{
-# pragma intrinsic(_BitScanReverse)
-inline uint32_t clz(uint32_t x)
-{
- unsigned long r = 0;
- _BitScanReverse(&r, x);
-
- assert(x != 0);
- // Static analysis complains about using uninitialized data
- // "r", but the only way that can happen is if "x" is 0,
- // which the callers guarantee to not happen.
-# pragma warning(suppress: 6102)
- return 31 - r;
-}
-# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
-
-# ifdef _WIN64
-# pragma intrinsic(_BitScanReverse64)
-# endif
-
-inline uint32_t clzll(uint64_t x)
-{
- unsigned long r = 0;
-# ifdef _WIN64
- _BitScanReverse64(&r, x);
-# else
- // Scan the high 32 bits.
- if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
- return 63 - (r + 32);
-
- // Scan the low 32 bits.
- _BitScanReverse(&r, static_cast<uint32_t>(x));
-# endif
-
- assert(x != 0);
- // Static analysis complains about using uninitialized data
- // "r", but the only way that can happen is if "x" is 0,
- // which the callers guarantee to not happen.
-# pragma warning(suppress: 6102)
- return 63 - r;
-}
-# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
-}
-}
-#endif
-
-namespace fmt
-{
-namespace internal
-{
-struct DummyInt
-{
- int data[2];
- operator int() const
- {
- return 0;
- }
-};
-typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;
-
-// Dummy implementations of system functions such as signbit and ecvt called
-// if the latter are not available.
-inline DummyInt signbit(...)
-{
- return DummyInt();
-}
-inline DummyInt _ecvt_s(...)
-{
- return DummyInt();
-}
-inline DummyInt isinf(...)
-{
- return DummyInt();
-}
-inline DummyInt _finite(...)
-{
- return DummyInt();
-}
-inline DummyInt isnan(...)
-{
- return DummyInt();
-}
-inline DummyInt _isnan(...)
-{
- return DummyInt();
-}
-
-// A helper function to suppress bogus "conditional expression is constant"
-// warnings.
-template <typename T>
-inline T const_check(T value)
-{
- return value;
-}
-}
-} // namespace fmt
-
-namespace std
-{
-// Standard permits specialization of std::numeric_limits. This specialization
-// is used to resolve ambiguity between isinf and std::isinf in glibc:
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891
-// and the same for isnan and signbit.
-template <>
-class numeric_limits<fmt::internal::DummyInt> :
- public std::numeric_limits<int>
-{
-public:
- // Portable version of isinf.
- template <typename T>
- static bool isinfinity(T x)
- {
- using namespace fmt::internal;
- // The resolution "priority" is:
- // isinf macro > std::isinf > ::isinf > fmt::internal::isinf
- if (const_check(sizeof(isinf(x)) == sizeof(bool) ||
- sizeof(isinf(x)) == sizeof(int)))
- {
- return isinf(x) != 0;
- }
- return !_finite(static_cast<double>(x));
- }
-
- // Portable version of isnan.
- template <typename T>
- static bool isnotanumber(T x)
- {
- using namespace fmt::internal;
- if (const_check(sizeof(isnan(x)) == sizeof(bool) ||
- sizeof(isnan(x)) == sizeof(int)))
- {
- return isnan(x) != 0;
- }
- return _isnan(static_cast<double>(x)) != 0;
- }
-
- // Portable version of signbit.
- static bool isnegative(double x)
- {
- using namespace fmt::internal;
- if (const_check(sizeof(signbit(x)) == sizeof(int)))
- return signbit(x) != 0;
- if (x < 0) return true;
- if (!isnotanumber(x)) return false;
- int dec = 0, sign = 0;
- char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail.
- _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
- return sign != 0;
- }
-};
-} // namespace std
-
-namespace fmt
-{
-
-// Fix the warning about long long on older versions of GCC
-// that don't support the diagnostic pragma.
-FMT_GCC_EXTENSION typedef long long LongLong;
-FMT_GCC_EXTENSION typedef unsigned long long ULongLong;
-
-#if FMT_USE_RVALUE_REFERENCES
-using std::move;
-#endif
-
-template <typename Char>
-class BasicWriter;
-
-typedef BasicWriter<char> Writer;
-typedef BasicWriter<wchar_t> WWriter;
-
-template <typename Char>
-class ArgFormatter;
-
-template <typename Impl, typename Char>
-class BasicPrintfArgFormatter;
-
-template <typename CharType,
- typename ArgFormatter = fmt::ArgFormatter<CharType> >
-class BasicFormatter;
-
-/**
-\rst
-A string reference. It can be constructed from a C string or ``std::string``.
-
-You can use one of the following typedefs for common character types:
-
-+------------+-------------------------+
-| Type | Definition |
-+============+=========================+
-| StringRef | BasicStringRef<char> |
-+------------+-------------------------+
-| WStringRef | BasicStringRef<wchar_t> |
-+------------+-------------------------+
-
-This class is most useful as a parameter type to allow passing
-different types of strings to a function, for example::
-
-template <typename... Args>
-std::string format(StringRef format_str, const Args & ... args);
-
-format("{}", 42);
-format(std::string("{}"), 42);
-\endrst
-*/
-template <typename Char>
-class BasicStringRef
-{
-private:
- const Char *data_;
- std::size_t size_;
-
-public:
- /** Constructs a string reference object from a C string and a size. */
- BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
-
- /**
- \rst
- Constructs a string reference object from a C string computing
- the size with ``std::char_traits<Char>::length``.
- \endrst
- */
- BasicStringRef(const Char *s)
- : data_(s), size_(std::char_traits<Char>::length(s)) {}
-
- /**
- \rst
- Constructs a string reference from an ``std::string`` object.
- \endrst
- */
- BasicStringRef(const std::basic_string<Char> &s)
- : data_(s.c_str()), size_(s.size()) {}
-
- /**
- \rst
- Converts a string reference to an ``std::string`` object.
- \endrst
- */
- std::basic_string<Char> to_string() const
- {
- return std::basic_string<Char>(data_, size_);
- }
-
- /** Returns a pointer to the string data. */
- const Char *data() const
- {
- return data_;
- }
-
- /** Returns the string size. */
- std::size_t size() const
- {
- return size_;
- }
-
- // Lexicographically compare this string reference to other.
- int compare(BasicStringRef other) const
- {
- std::size_t size = size_ < other.size_ ? size_ : other.size_;
- int result = std::char_traits<Char>::compare(data_, other.data_, size);
- if (result == 0)
- result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
- return result;
- }
-
- friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
- {
- return lhs.compare(rhs) == 0;
- }
- friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
- {
- return lhs.compare(rhs) != 0;
- }
- friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)
- {
- return lhs.compare(rhs) < 0;
- }
- friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)
- {
- return lhs.compare(rhs) <= 0;
- }
- friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)
- {
- return lhs.compare(rhs) > 0;
- }
- friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)
- {
- return lhs.compare(rhs) >= 0;
- }
-};
-
-typedef BasicStringRef<char> StringRef;
-typedef BasicStringRef<wchar_t> WStringRef;
-
-/**
-\rst
-A reference to a null terminated string. It can be constructed from a C
-string or ``std::string``.
-
-You can use one of the following typedefs for common character types:
-
-+-------------+--------------------------+
-| Type | Definition |
-+=============+==========================+
-| CStringRef | BasicCStringRef<char> |
-+-------------+--------------------------+
-| WCStringRef | BasicCStringRef<wchar_t> |
-+-------------+--------------------------+
-
-This class is most useful as a parameter type to allow passing
-different types of strings to a function, for example::
-
-template <typename... Args>
-std::string format(CStringRef format_str, const Args & ... args);
-
-format("{}", 42);
-format(std::string("{}"), 42);
-\endrst
-*/
-template <typename Char>
-class BasicCStringRef
-{
-private:
- const Char *data_;
-
-public:
- /** Constructs a string reference object from a C string. */
- BasicCStringRef(const Char *s) : data_(s) {}
-
- /**
- \rst
- Constructs a string reference from an ``std::string`` object.
- \endrst
- */
- BasicCStringRef(const std::basic_string<Char> &s) : data_(s.c_str()) {}
-
- /** Returns the pointer to a C string. */
- const Char *c_str() const
- {
- return data_;
- }
-};
-
-typedef BasicCStringRef<char> CStringRef;
-typedef BasicCStringRef<wchar_t> WCStringRef;
-
-/** A formatting error such as invalid format string. */
-class FormatError : public std::runtime_error
-{
-public:
- explicit FormatError(CStringRef message)
- : std::runtime_error(message.c_str()) {}
- ~FormatError() throw();
-};
-
-namespace internal
-{
-
-// MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
-template <typename T>
-struct MakeUnsigned
-{
- typedef T Type;
-};
-
-#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
- template <> \
- struct MakeUnsigned<T> { typedef U Type; }
-
-FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char);
-FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);
-FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short);
-FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);
-FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);
-FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);
-
-// Casts nonnegative integer to unsigned.
-template <typename Int>
-inline typename MakeUnsigned<Int>::Type to_unsigned(Int value)
-{
- FMT_ASSERT(value >= 0, "negative value");
- return static_cast<typename MakeUnsigned<Int>::Type>(value);
-}
-
-// The number of characters to store in the MemoryBuffer object itself
-// to avoid dynamic memory allocation.
-enum { INLINE_BUFFER_SIZE = 500 };
-
-#if FMT_SECURE_SCL
-// Use checked iterator to avoid warnings on MSVC.
-template <typename T>
-inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size)
-{
- return stdext::checked_array_iterator<T*>(ptr, size);
-}
-#else
-template <typename T>
-inline T *make_ptr(T *ptr, std::size_t)
-{
- return ptr;
-}
-#endif
-} // namespace internal
-
-/**
-\rst
-A buffer supporting a subset of ``std::vector``'s operations.
-\endrst
-*/
-template <typename T>
-class Buffer
-{
-private:
- FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
-
-protected:
- T *ptr_;
- std::size_t size_;
- std::size_t capacity_;
-
- Buffer(T *ptr = 0, std::size_t capacity = 0)
- : ptr_(ptr), size_(0), capacity_(capacity) {}
-
- /**
- \rst
- Increases the buffer capacity to hold at least *size* elements updating
- ``ptr_`` and ``capacity_``.
- \endrst
- */
- virtual void grow(std::size_t size) = 0;
-
-public:
- virtual ~Buffer() {}
-
- /** Returns the size of this buffer. */
- std::size_t size() const
- {
- return size_;
- }
-
- /** Returns the capacity of this buffer. */
- std::size_t capacity() const
- {
- return capacity_;
- }
-
- /**
- Resizes the buffer. If T is a POD type new elements may not be initialized.
- */
- void resize(std::size_t new_size)
- {
- if (new_size > capacity_)
- grow(new_size);
- size_ = new_size;
- }
-
- /**
- \rst
- Reserves space to store at least *capacity* elements.
- \endrst
- */
- void reserve(std::size_t capacity)
- {
- if (capacity > capacity_)
- grow(capacity);
- }
-
- void clear() FMT_NOEXCEPT{ size_ = 0; }
-
- void push_back(const T &value)
- {
- if (size_ == capacity_)
- grow(size_ + 1);
- ptr_[size_++] = value;
- }
-
- /** Appends data to the end of the buffer. */
- template <typename U>
- void append(const U *begin, const U *end);
-
- T &operator[](std::size_t index)
- {
- return ptr_[index];
- }
- const T &operator[](std::size_t index) const
- {
- return ptr_[index];
- }
-};
-
-template <typename T>
-template <typename U>
-void Buffer<T>::append(const U *begin, const U *end)
-{
- std::size_t new_size = size_ + internal::to_unsigned(end - begin);
- if (new_size > capacity_)
- grow(new_size);
- std::uninitialized_copy(begin, end,
- internal::make_ptr(ptr_, capacity_) + size_);
- size_ = new_size;
-}
-
-namespace internal
-{
-
-// A memory buffer for trivially copyable/constructible types with the first
-// SIZE elements stored in the object itself.
-template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
-class MemoryBuffer : private Allocator, public Buffer<T>
-{
-private:
- T data_[SIZE];
-
- // Deallocate memory allocated by the buffer.
- void deallocate()
- {
- if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
- }
-
-protected:
- void grow(std::size_t size) FMT_OVERRIDE;
-
-public:
- explicit MemoryBuffer(const Allocator &alloc = Allocator())
- : Allocator(alloc), Buffer<T>(data_, SIZE) {}
- ~MemoryBuffer()
- {
- deallocate();
- }
-
-#if FMT_USE_RVALUE_REFERENCES
-private:
- // Move data from other to this buffer.
- void move(MemoryBuffer &other)
- {
- Allocator &this_alloc = *this, &other_alloc = other;
- this_alloc = std::move(other_alloc);
- this->size_ = other.size_;
- this->capacity_ = other.capacity_;
- if (other.ptr_ == other.data_)
- {
- this->ptr_ = data_;
- std::uninitialized_copy(other.data_, other.data_ + this->size_,
- make_ptr(data_, this->capacity_));
- }
- else
- {
- this->ptr_ = other.ptr_;
- // Set pointer to the inline array so that delete is not called
- // when deallocating.
- other.ptr_ = other.data_;
- }
- }
-
-public:
- MemoryBuffer(MemoryBuffer &&other)
- {
- move(other);
- }
-
- MemoryBuffer &operator=(MemoryBuffer &&other)
- {
- assert(this != &other);
- deallocate();
- move(other);
- return *this;
- }
-#endif
-
- // Returns a copy of the allocator associated with this buffer.
- Allocator get_allocator() const
- {
- return *this;
- }
-};
-
-template <typename T, std::size_t SIZE, typename Allocator>
-void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size)
-{
- std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
- if (size > new_capacity)
- new_capacity = size;
- T *new_ptr = this->allocate(new_capacity);
- // The following code doesn't throw, so the raw pointer above doesn't leak.
- std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
- make_ptr(new_ptr, new_capacity));
- std::size_t old_capacity = this->capacity_;
- T *old_ptr = this->ptr_;
- this->capacity_ = new_capacity;
- this->ptr_ = new_ptr;
- // deallocate may throw (at least in principle), but it doesn't matter since
- // the buffer already uses the new storage and will deallocate it in case
- // of exception.
- if (old_ptr != data_)
- Allocator::deallocate(old_ptr, old_capacity);
-}
-
-// A fixed-size buffer.
-template <typename Char>
-class FixedBuffer : public fmt::Buffer<Char>
-{
-public:
- FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
-
-protected:
- FMT_API void grow(std::size_t size);
-};
-
-template <typename Char>
-class BasicCharTraits
-{
-public:
-#if FMT_SECURE_SCL
- typedef stdext::checked_array_iterator<Char*> CharPtr;
-#else
- typedef Char *CharPtr;
-#endif
- static Char cast(int value)
- {
- return static_cast<Char>(value);
- }
-};
-
-template <typename Char>
-class CharTraits;
-
-template <>
-class CharTraits<char> : public BasicCharTraits<char>
-{
-private:
- // Conversion from wchar_t to char is not allowed.
- static char convert(wchar_t);
-
-public:
- static char convert(char value)
- {
- return value;
- }
-
- // Formats a floating-point number.
- template <typename T>
- FMT_API static int format_float(char *buffer, std::size_t size,
- const char *format, unsigned width, int precision, T value);
-};
-
-template <>
-class CharTraits<wchar_t> : public BasicCharTraits<wchar_t>
-{
-public:
- static wchar_t convert(char value)
- {
- return value;
- }
- static wchar_t convert(wchar_t value)
- {
- return value;
- }
-
- template <typename T>
- FMT_API static int format_float(wchar_t *buffer, std::size_t size,
- const wchar_t *format, unsigned width, int precision, T value);
-};
-
-// Checks if a number is negative - used to avoid warnings.
-template <bool IsSigned>
-struct SignChecker
-{
- template <typename T>
- static bool is_negative(T value)
- {
- return value < 0;
- }
-};
-
-template <>
-struct SignChecker<false>
-{
- template <typename T>
- static bool is_negative(T)
- {
- return false;
- }
-};
-
-// Returns true if value is negative, false otherwise.
-// Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
-template <typename T>
-inline bool is_negative(T value)
-{
- return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
-}
-
-// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
-template <bool FitsIn32Bits>
-struct TypeSelector
-{
- typedef uint32_t Type;
-};
-
-template <>
-struct TypeSelector<false>
-{
- typedef uint64_t Type;
-};
-
-template <typename T>
-struct IntTraits
-{
- // Smallest of uint32_t and uint64_t that is large enough to represent
- // all values of T.
- typedef typename
- TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;
-};
-
-FMT_API void report_unknown_type(char code, const char *type);
-
-// Static data is placed in this class template to allow header-only
-// configuration.
-template <typename T = void>
-struct FMT_API BasicData
-{
- static const uint32_t POWERS_OF_10_32[];
- static const uint64_t POWERS_OF_10_64[];
- static const char DIGITS[];
-};
-
-#ifndef FMT_USE_EXTERN_TEMPLATES
-// Clang doesn't have a feature check for extern templates so we check
-// for variadic templates which were introduced in the same version.
-# define FMT_USE_EXTERN_TEMPLATES (__clang__ && FMT_USE_VARIADIC_TEMPLATES)
-#endif
-
-#if FMT_USE_EXTERN_TEMPLATES && !defined(FMT_HEADER_ONLY)
-extern template struct BasicData<void>;
-#endif
-
-typedef BasicData<> Data;
-
-#ifdef FMT_BUILTIN_CLZLL
-// Returns the number of decimal digits in n. Leading zeros are not counted
-// except for n == 0 in which case count_digits returns 1.
-inline unsigned count_digits(uint64_t n)
-{
- // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
- // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
- int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
- return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1;
-}
-#else
-// Fallback version of count_digits used when __builtin_clz is not available.
-inline unsigned count_digits(uint64_t n)
-{
- unsigned count = 1;
- for (;;)
- {
- // Integer division is slow so do it for a group of four digits instead
- // of for every digit. The idea comes from the talk by Alexandrescu
- // "Three Optimization Tips for C++". See speed-test for a comparison.
- if (n < 10) return count;
- if (n < 100) return count + 1;
- if (n < 1000) return count + 2;
- if (n < 10000) return count + 3;
- n /= 10000u;
- count += 4;
- }
-}
-#endif
-
-#ifdef FMT_BUILTIN_CLZ
-// Optional version of count_digits for better performance on 32-bit platforms.
-inline unsigned count_digits(uint32_t n)
-{
- int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
- return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1;
-}
-#endif
-
-// A functor that doesn't add a thousands separator.
-struct NoThousandsSep
-{
- template <typename Char>
- void operator()(Char *) {}
-};
-
-// A functor that adds a thousands separator.
-class ThousandsSep
-{
-private:
- fmt::StringRef sep_;
-
- // Index of a decimal digit with the least significant digit having index 0.
- unsigned digit_index_;
-
-public:
- explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {}
-
- template <typename Char>
- void operator()(Char *&buffer)
- {
- if (++digit_index_ % 3 != 0)
- return;
- buffer -= sep_.size();
- std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
- internal::make_ptr(buffer, sep_.size()));
- }
-};
-
-// Formats a decimal unsigned integer value writing into buffer.
-// thousands_sep is a functor that is called after writing each char to
-// add a thousands separator if necessary.
-template <typename UInt, typename Char, typename ThousandsSep>
-inline void format_decimal(Char *buffer, UInt value, unsigned num_digits,
- ThousandsSep thousands_sep)
-{
- buffer += num_digits;
- while (value >= 100)
- {
- // Integer division is slow so do it for a group of two digits instead
- // of for every digit. The idea comes from the talk by Alexandrescu
- // "Three Optimization Tips for C++". See speed-test for a comparison.
- unsigned index = static_cast<unsigned>((value % 100) * 2);
- value /= 100;
- *--buffer = Data::DIGITS[index + 1];
- thousands_sep(buffer);
- *--buffer = Data::DIGITS[index];
- thousands_sep(buffer);
- }
- if (value < 10)
- {
- *--buffer = static_cast<char>('0' + value);
- return;
- }
- unsigned index = static_cast<unsigned>(value * 2);
- *--buffer = Data::DIGITS[index + 1];
- thousands_sep(buffer);
- *--buffer = Data::DIGITS[index];
-}
-
-template <typename UInt, typename Char>
-inline void format_decimal(Char *buffer, UInt value, unsigned num_digits)
-{
- return format_decimal(buffer, value, num_digits, NoThousandsSep());
-}
-
-#ifndef _WIN32
-# define FMT_USE_WINDOWS_H 0
-#elif !defined(FMT_USE_WINDOWS_H)
-# define FMT_USE_WINDOWS_H 1
-#endif
-
-// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
-// All the functionality that relies on it will be disabled too.
-#if FMT_USE_WINDOWS_H
-// A converter from UTF-8 to UTF-16.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class UTF8ToUTF16
-{
-private:
- MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
-
-public:
- FMT_API explicit UTF8ToUTF16(StringRef s);
- operator WStringRef() const
- {
- return WStringRef(&buffer_[0], size());
- }
- size_t size() const
- {
- return buffer_.size() - 1;
- }
- const wchar_t *c_str() const
- {
- return &buffer_[0];
- }
- std::wstring str() const
- {
- return std::wstring(&buffer_[0], size());
- }
-};
-
-// A converter from UTF-16 to UTF-8.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class UTF16ToUTF8
-{
-private:
- MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
-
-public:
- UTF16ToUTF8() {}
- FMT_API explicit UTF16ToUTF8(WStringRef s);
- operator StringRef() const
- {
- return StringRef(&buffer_[0], size());
- }
- size_t size() const
- {
- return buffer_.size() - 1;
- }
- const char *c_str() const
- {
- return &buffer_[0];
- }
- std::string str() const
- {
- return std::string(&buffer_[0], size());
- }
-
- // Performs conversion returning a system error code instead of
- // throwing exception on conversion error. This method may still throw
- // in case of memory allocation error.
- FMT_API int convert(WStringRef s);
-};
-
-FMT_API void format_windows_error(fmt::Writer &out, int error_code,
- fmt::StringRef message) FMT_NOEXCEPT;
-#endif
-
-// A formatting argument value.
-struct Value
-{
- template <typename Char>
- struct StringValue
- {
- const Char *value;
- std::size_t size;
- };
-
- typedef void(*FormatFunc)(
- void *formatter, const void *arg, void *format_str_ptr);
-
- struct CustomValue
- {
- const void *value;
- FormatFunc format;
- };
-
- union
- {
- int int_value;
- unsigned uint_value;
- LongLong long_long_value;
- ULongLong ulong_long_value;
- double double_value;
- long double long_double_value;
- const void *pointer;
- StringValue<char> string;
- StringValue<signed char> sstring;
- StringValue<unsigned char> ustring;
- StringValue<wchar_t> wstring;
- CustomValue custom;
- };
-
- enum Type
- {
- NONE, NAMED_ARG,
- // Integer types should go first,
- INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
- // followed by floating-point types.
- DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
- CSTRING, STRING, WSTRING, POINTER, CUSTOM
- };
-};
-
-// A formatting argument. It is a trivially copyable/constructible type to
-// allow storage in internal::MemoryBuffer.
-struct Arg : Value
-{
- Type type;
-};
-
-template <typename Char>
-struct NamedArg;
-template <typename Char, typename T>
-struct NamedArgWithType;
-
-template <typename T = void>
-struct Null {};
-
-// A helper class template to enable or disable overloads taking wide
-// characters and strings in MakeValue.
-template <typename T, typename Char>
-struct WCharHelper
-{
- typedef Null<T> Supported;
- typedef T Unsupported;
-};
-
-template <typename T>
-struct WCharHelper<T, wchar_t>
-{
- typedef T Supported;
- typedef Null<T> Unsupported;
-};
-
-typedef char Yes[1];
-typedef char No[2];
-
-template <typename T>
-T &get();
-
-// These are non-members to workaround an overload resolution bug in bcc32.
-Yes &convert(fmt::ULongLong);
-No &convert(...);
-
-template<typename T, bool ENABLE_CONVERSION>
-struct ConvertToIntImpl
-{
- enum { value = ENABLE_CONVERSION };
-};
-
-template<typename T, bool ENABLE_CONVERSION>
-struct ConvertToIntImpl2
-{
- enum { value = false };
-};
-
-template<typename T>
-struct ConvertToIntImpl2<T, true>
-{
- enum
- {
- // Don't convert numeric types.
- value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
- };
-};
-
-template<typename T>
-struct ConvertToInt
-{
- enum { enable_conversion = sizeof(convert(get<T>())) == sizeof(Yes) };
- enum { value = ConvertToIntImpl2<T, enable_conversion>::value };
-};
-
-#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
- template <> \
- struct ConvertToInt<Type> { enum { value = 0 }; }
-
-// Silence warnings about convering float to int.
-FMT_DISABLE_CONVERSION_TO_INT(float);
-FMT_DISABLE_CONVERSION_TO_INT(double);
-FMT_DISABLE_CONVERSION_TO_INT(long double);
-
-template<bool B, class T = void>
-struct EnableIf {};
-
-template<class T>
-struct EnableIf<true, T>
-{
- typedef T type;
-};
-
-template<bool B, class T, class F>
-struct Conditional
-{
- typedef T type;
-};
-
-template<class T, class F>
-struct Conditional<false, T, F>
-{
- typedef F type;
-};
-
-// For bcc32 which doesn't understand ! in template arguments.
-template <bool>
-struct Not
-{
- enum { value = 0 };
-};
-
-template <>
-struct Not<false>
-{
- enum { value = 1 };
-};
-
-template <typename T>
-struct False
-{
- enum { value = 0 };
-};
-
-template <typename T, T> struct LConvCheck
-{
- LConvCheck(int) {}
-};
-
-// Returns the thousands separator for the current locale.
-// We check if ``lconv`` contains ``thousands_sep`` because on Android
-// ``lconv`` is stubbed as an empty struct.
-template <typename LConv>
-inline StringRef thousands_sep(
- LConv *lc, LConvCheck<char *LConv::*, &LConv::thousands_sep> = 0)
-{
- return lc->thousands_sep;
-}
-
-inline fmt::StringRef thousands_sep(...)
-{
- return "";
-}
-
-#define FMT_CONCAT(a, b) a##b
-
-#if FMT_GCC_VERSION >= 407
-# define FMT_UNUSED __attribute__((unused))
-#else
-# define FMT_UNUSED
-#endif
-
-#ifndef FMT_USE_STATIC_ASSERT
-# define FMT_USE_STATIC_ASSERT 0
-#endif
-
-#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \
- (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600
-# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message)
-#else
-# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b)
-# define FMT_STATIC_ASSERT(cond, message) \
- typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
-#endif
-
-template <typename Formatter, typename Char, typename T>
-void format_arg(Formatter &, const Char *, const T &)
-{
- FMT_STATIC_ASSERT(False<T>::value,
- "Cannot format argument. To enable the use of ostream "
- "operator<< include fmt/ostream.h. Otherwise provide "
- "an overload of format_arg.");
-}
-
-// Makes an Arg object from any type.
-template <typename Formatter>
-class MakeValue : public Arg
-{
-public:
- typedef typename Formatter::Char Char;
-
-private:
- // The following two methods are private to disallow formatting of
- // arbitrary pointers. If you want to output a pointer cast it to
- // "void *" or "const void *". In particular, this forbids formatting
- // of "[const] volatile char *" which is printed as bool by iostreams.
- // Do not implement!
- template <typename T>
- MakeValue(const T *value);
- template <typename T>
- MakeValue(T *value);
-
- // The following methods are private to disallow formatting of wide
- // characters and strings into narrow strings as in
- // fmt::format("{}", L"test");
- // To fix this, use a wide format string: fmt::format(L"{}", L"test").
-#if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED)
- MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
-#endif
- MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
- MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
- MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
- MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
-
- void set_string(StringRef str)
- {
- string.value = str.data();
- string.size = str.size();
- }
-
- void set_string(WStringRef str)
- {
- wstring.value = str.data();
- wstring.size = str.size();
- }
-
- // Formats an argument of a custom type, such as a user-defined class.
- template <typename T>
- static void format_custom_arg(
- void *formatter, const void *arg, void *format_str_ptr)
- {
- format_arg(*static_cast<Formatter*>(formatter),
- *static_cast<const Char**>(format_str_ptr),
- *static_cast<const T*>(arg));
- }
-
-public:
- MakeValue() {}
-
-#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
- MakeValue(Type value) { field = rhs; } \
- static uint64_t type(Type) { return Arg::TYPE; }
-
-#define FMT_MAKE_VALUE(Type, field, TYPE) \
- FMT_MAKE_VALUE_(Type, field, TYPE, value)
-
- FMT_MAKE_VALUE(bool, int_value, BOOL)
- FMT_MAKE_VALUE(short, int_value, INT)
- FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
- FMT_MAKE_VALUE(int, int_value, INT)
- FMT_MAKE_VALUE(unsigned, uint_value, UINT)
-
- MakeValue(long value)
- {
- // To minimize the number of types we need to deal with, long is
- // translated either to int or to long long depending on its size.
- if (const_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 (const_check(sizeof(unsigned long) == sizeof(unsigned)))
- uint_value = static_cast<unsigned>(value);
- else
- ulong_long_value = value;
- }
- static uint64_t type(unsigned long)
- {
- return sizeof(unsigned long) == sizeof(unsigned) ?
- Arg::UINT : Arg::ULONG_LONG;
- }
-
- FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
- FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
- FMT_MAKE_VALUE(float, double_value, DOUBLE)
- FMT_MAKE_VALUE(double, double_value, DOUBLE)
- FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
- FMT_MAKE_VALUE(signed char, int_value, INT)
- FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
- FMT_MAKE_VALUE(char, int_value, CHAR)
-
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
- MakeValue(typename WCharHelper<wchar_t, Char>::Supported value)
- {
- int_value = value;
- }
- static uint64_t type(wchar_t)
- {
- return Arg::CHAR;
- }
-#endif
-
-#define FMT_MAKE_STR_VALUE(Type, TYPE) \
- MakeValue(Type value) { set_string(value); } \
- static uint64_t type(Type) { return Arg::TYPE; }
-
- FMT_MAKE_VALUE(char *, string.value, CSTRING)
- FMT_MAKE_VALUE(const char *, string.value, CSTRING)
- FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING)
- FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
- FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING)
- FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
- FMT_MAKE_STR_VALUE(const std::string &, STRING)
- FMT_MAKE_STR_VALUE(StringRef, STRING)
- FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
-
-#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
- MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
- set_string(value); \
- } \
- static uint64_t type(Type) { return Arg::TYPE; }
-
- FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
- FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
- FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
- FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
-
- FMT_MAKE_VALUE(void *, pointer, POINTER)
- FMT_MAKE_VALUE(const void *, pointer, POINTER)
-
- template <typename T>
- MakeValue(const T &value,
- typename EnableIf<Not<
- ConvertToInt<T>::value>::value, int>::type = 0)
- {
- custom.value = &value;
- custom.format = &format_custom_arg<T>;
- }
-
- template <typename T>
- MakeValue(const T &value,
- typename EnableIf<ConvertToInt<T>::value, int>::type = 0)
- {
- int_value = value;
- }
-
- template <typename T>
- static uint64_t type(const T &)
- {
- return ConvertToInt<T>::value ? Arg::INT : Arg::CUSTOM;
- }
-
- // Additional template param `Char_` is needed here because make_type always
- // uses char.
- template <typename Char_>
- MakeValue(const NamedArg<Char_> &value)
- {
- pointer = &value;
- }
- template <typename Char_, typename T>
- MakeValue(const NamedArgWithType<Char_, T> &value)
- {
- pointer = &value;
- }
-
- template <typename Char_>
- static uint64_t type(const NamedArg<Char_> &)
- {
- return Arg::NAMED_ARG;
- }
- template <typename Char_, typename T>
- static uint64_t type(const NamedArgWithType<Char_, T> &)
- {
- return Arg::NAMED_ARG;
- }
-};
-
-template <typename Formatter>
-class MakeArg : public Arg
-{
-public:
- MakeArg()
- {
- type = Arg::NONE;
- }
-
- template <typename T>
- MakeArg(const T &value)
- : Arg(MakeValue<Formatter>(value))
- {
- type = static_cast<Arg::Type>(MakeValue<Formatter>::type(value));
- }
-};
-
-template <typename Char>
-struct NamedArg : Arg
-{
- BasicStringRef<Char> name;
-
- template <typename T>
- NamedArg(BasicStringRef<Char> argname, const T &value)
- : Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname) {}
-};
-
-template <typename Char, typename T>
-struct NamedArgWithType : NamedArg<Char>
-{
- NamedArgWithType(BasicStringRef<Char> argname, const T &value)
- : NamedArg<Char>(argname, value) {}
-};
-
-class RuntimeError : public std::runtime_error
-{
-protected:
- RuntimeError() : std::runtime_error("") {}
- ~RuntimeError() throw();
-};
-
-template <typename Char>
-class ArgMap;
-} // namespace internal
-
-/** An argument list. */
-class ArgList
-{
-private:
- // To reduce compiled code size per formatting function call, types of first
- // MAX_PACKED_ARGS arguments are passed in the types_ field.
- uint64_t types_;
- union
- {
- // If the number of arguments is less than MAX_PACKED_ARGS, the argument
- // values are stored in values_, otherwise they are stored in args_.
- // This is done to reduce compiled code size as storing larger objects
- // may require more code (at least on x86-64) even if the same amount of
- // data is actually copied to stack. It saves ~10% on the bloat test.
- const internal::Value *values_;
- const internal::Arg *args_;
- };
-
- internal::Arg::Type type(unsigned index) const
- {
- return type(types_, index);
- }
-
- 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) {}
-
- uint64_t types() const
- {
- return types_;
- }
-
- /** 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];
- }
-
- static internal::Arg::Type type(uint64_t types, unsigned index)
- {
- unsigned shift = index * 4;
- uint64_t mask = 0xf;
- return static_cast<internal::Arg::Type>(
- (types & (mask << shift)) >> shift);
- }
-};
-
-#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
-
-/**
-\rst
-An argument visitor based on the `curiously recurring template pattern
-<http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.
-
-To use `~fmt::ArgVisitor` define a subclass that implements some or all of the
-visit methods with the same signatures as the methods in `~fmt::ArgVisitor`,
-for example, `~fmt::ArgVisitor::visit_int()`.
-Pass the subclass as the *Impl* template parameter. Then calling
-`~fmt::ArgVisitor::visit` for some argument will dispatch to a visit method
-specific to the argument type. For example, if the argument type is
-``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
-will be called. If the subclass doesn't contain a method with this signature,
-then a corresponding method of `~fmt::ArgVisitor` will be called.
-
-**Example**::
-
-class MyArgVisitor : public fmt::ArgVisitor<MyArgVisitor, void> {
-public:
-void visit_int(int value) { fmt::print("{}", value); }
-void visit_double(double value) { fmt::print("{}", value ); }
-};
-\endrst
-*/
-template <typename Impl, typename Result>
-class ArgVisitor
-{
-private:
- typedef internal::Arg Arg;
-
-public:
- void report_unhandled_arg() {}
-
- Result visit_unhandled_arg()
- {
- FMT_DISPATCH(report_unhandled_arg());
- return Result();
- }
-
- /** Visits an ``int`` argument. **/
- Result visit_int(int value)
- {
- return FMT_DISPATCH(visit_any_int(value));
- }
-
- /** Visits a ``long long`` argument. **/
- Result visit_long_long(LongLong value)
- {
- return FMT_DISPATCH(visit_any_int(value));
- }
-
- /** Visits an ``unsigned`` argument. **/
- Result visit_uint(unsigned value)
- {
- return FMT_DISPATCH(visit_any_int(value));
- }
-
- /** Visits an ``unsigned long long`` argument. **/
- Result visit_ulong_long(ULongLong value)
- {
- return FMT_DISPATCH(visit_any_int(value));
- }
-
- /** Visits a ``bool`` argument. **/
- Result visit_bool(bool value)
- {
- return FMT_DISPATCH(visit_any_int(value));
- }
-
- /** Visits a ``char`` or ``wchar_t`` argument. **/
- Result visit_char(int value)
- {
- return FMT_DISPATCH(visit_any_int(value));
- }
-
- /** Visits an argument of any integral type. **/
- template <typename T>
- Result visit_any_int(T)
- {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
-
- /** Visits a ``double`` argument. **/
- Result visit_double(double value)
- {
- return FMT_DISPATCH(visit_any_double(value));
- }
-
- /** Visits a ``long double`` argument. **/
- Result visit_long_double(long double value)
- {
- return FMT_DISPATCH(visit_any_double(value));
- }
-
- /** Visits a ``double`` or ``long double`` argument. **/
- template <typename T>
- Result visit_any_double(T)
- {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
-
- /** Visits a null-terminated C string (``const char *``) argument. **/
- Result visit_cstring(const char *)
- {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
-
- /** Visits a string argument. **/
- Result visit_string(Arg::StringValue<char>)
- {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
-
- /** Visits a wide string argument. **/
- Result visit_wstring(Arg::StringValue<wchar_t>)
- {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
-
- /** Visits a pointer argument. **/
- Result visit_pointer(const void *)
- {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
-
- /** Visits an argument of a custom (user-defined) type. **/
- Result visit_custom(Arg::CustomValue)
- {
- return FMT_DISPATCH(visit_unhandled_arg());
- }
-
- /**
- \rst
- Visits an argument dispatching to the appropriate visit method based on
- the argument type. For example, if the argument type is ``double`` then
- the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be
- called.
- \endrst
- */
- Result visit(const Arg &arg)
- {
- switch (arg.type)
- {
- case Arg::NONE:
- case Arg::NAMED_ARG:
- FMT_ASSERT(false, "invalid argument type");
- break;
- case Arg::INT:
- return FMT_DISPATCH(visit_int(arg.int_value));
- case Arg::UINT:
- return FMT_DISPATCH(visit_uint(arg.uint_value));
- case Arg::LONG_LONG:
- return FMT_DISPATCH(visit_long_long(arg.long_long_value));
- case Arg::ULONG_LONG:
- return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
- case Arg::BOOL:
- return FMT_DISPATCH(visit_bool(arg.int_value != 0));
- case Arg::CHAR:
- return FMT_DISPATCH(visit_char(arg.int_value));
- case Arg::DOUBLE:
- return FMT_DISPATCH(visit_double(arg.double_value));
- case Arg::LONG_DOUBLE:
- return FMT_DISPATCH(visit_long_double(arg.long_double_value));
- case Arg::CSTRING:
- return FMT_DISPATCH(visit_cstring(arg.string.value));
- case Arg::STRING:
- return FMT_DISPATCH(visit_string(arg.string));
- case Arg::WSTRING:
- return FMT_DISPATCH(visit_wstring(arg.wstring));
- case Arg::POINTER:
- return FMT_DISPATCH(visit_pointer(arg.pointer));
- case Arg::CUSTOM:
- return FMT_DISPATCH(visit_custom(arg.custom));
- }
- return Result();
- }
-};
-
-enum Alignment
-{
- ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
-};
-
-// Flags.
-enum
-{
- SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
- CHAR_FLAG = 0x10 // Argument has char type - used in error reporting.
-};
-
-// An empty format specifier.
-struct EmptySpec {};
-
-// A type specifier.
-template <char TYPE>
-struct TypeSpec : EmptySpec
-{
- Alignment align() const
- {
- return ALIGN_DEFAULT;
- }
- unsigned width() const
- {
- return 0;
- }
- int precision() const
- {
- return -1;
- }
- bool flag(unsigned) const
- {
- return false;
- }
- char type() const
- {
- return TYPE;
- }
- char fill() const
- {
- return ' ';
- }
-};
-
-// A width specifier.
-struct WidthSpec
-{
- unsigned width_;
- // Fill is always wchar_t and cast to char if necessary to avoid having
- // two specialization of WidthSpec and its subclasses.
- wchar_t fill_;
-
- WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
-
- unsigned width() const
- {
- return width_;
- }
- wchar_t fill() const
- {
- return fill_;
- }
-};
-
-// An alignment specifier.
-struct AlignSpec : WidthSpec
-{
- Alignment align_;
-
- AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
- : WidthSpec(width, fill), align_(align) {}
-
- Alignment align() const
- {
- return align_;
- }
-
- int precision() const
- {
- return -1;
- }
-};
-
-// An alignment and type specifier.
-template <char TYPE>
-struct AlignTypeSpec : AlignSpec
-{
- AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
-
- bool flag(unsigned) const
- {
- return false;
- }
- char type() const
- {
- return TYPE;
- }
-};
-
-// A full format specifier.
-struct FormatSpec : AlignSpec
-{
- unsigned flags_;
- int precision_;
- char type_;
-
- FormatSpec(
- unsigned width = 0, char type = 0, wchar_t fill = ' ')
- : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}
-
- bool flag(unsigned f) const
- {
- return (flags_ & f) != 0;
- }
- int precision() const
- {
- return precision_;
- }
- char type() const
- {
- return type_;
- }
-};
-
-// An integer format specifier.
-template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
-class IntFormatSpec : public SpecT
-{
-private:
- T value_;
-
-public:
- IntFormatSpec(T val, const SpecT &spec = SpecT())
- : SpecT(spec), value_(val) {}
-
- T value() const
- {
- return value_;
- }
-};
-
-// A string format specifier.
-template <typename Char>
-class StrFormatSpec : public AlignSpec
-{
-private:
- const Char *str_;
-
-public:
- template <typename FillChar>
- StrFormatSpec(const Char *str, unsigned width, FillChar fill)
- : AlignSpec(width, fill), str_(str)
- {
- internal::CharTraits<Char>::convert(FillChar());
- }
-
- const Char *str() const
- {
- return str_;
- }
-};
-
-/**
-Returns an integer format specifier to format the value in base 2.
-*/
-IntFormatSpec<int, TypeSpec<'b'> > bin(int value);
-
-/**
-Returns an integer format specifier to format the value in base 8.
-*/
-IntFormatSpec<int, TypeSpec<'o'> > oct(int value);
-
-/**
-Returns an integer format specifier to format the value in base 16 using
-lower-case letters for the digits above 9.
-*/
-IntFormatSpec<int, TypeSpec<'x'> > hex(int value);
-
-/**
-Returns an integer formatter format specifier to format in base 16 using
-upper-case letters for the digits above 9.
-*/
-IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);
-
-/**
-\rst
-Returns an integer format specifier to pad the formatted argument with the
-fill character to the specified width using the default (right) numeric
-alignment.
-
-**Example**::
-
-MemoryWriter out;
-out << pad(hex(0xcafe), 8, '0');
-// out.str() == "0000cafe"
-
-\endrst
-*/
-template <char TYPE_CODE, typename Char>
-IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
- int value, unsigned width, Char fill = ' ');
-
-#define FMT_DEFINE_INT_FORMATTERS(TYPE) \
-inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
- return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
- } \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \
- return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \
- } \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
- return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \
- } \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
- return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
- } \
- \
-template <char TYPE_CODE> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
- IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
- return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
- f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
- } \
- \
-/* For compatibility with older compilers we provide two overloads for pad, */ \
-/* one that takes a fill character and one that doesn't. In the future this */ \
-/* can be replaced with one overload making the template argument Char */ \
-/* default to char (C++11). */ \
-template <char TYPE_CODE, typename Char> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
- IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \
- unsigned width, Char fill) { \
- return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
- f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
- } \
- \
-inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
- TYPE value, unsigned width) { \
- return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
- value, AlignTypeSpec<0>(width, ' ')); \
- } \
- \
-template <typename Char> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
- TYPE value, unsigned width, Char fill) { \
- return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
- value, AlignTypeSpec<0>(width, fill)); \
- }
-
-FMT_DEFINE_INT_FORMATTERS(int)
-FMT_DEFINE_INT_FORMATTERS(long)
-FMT_DEFINE_INT_FORMATTERS(unsigned)
-FMT_DEFINE_INT_FORMATTERS(unsigned long)
-FMT_DEFINE_INT_FORMATTERS(LongLong)
-FMT_DEFINE_INT_FORMATTERS(ULongLong)
-
-/**
-\rst
-Returns a string formatter that pads the formatted argument with the fill
-character to the specified width using the default (left) string alignment.
-
-**Example**::
-
-std::string s = str(MemoryWriter() << pad("abc", 8));
-// s == "abc "
-
-\endrst
-*/
-template <typename Char>
-inline StrFormatSpec<Char> pad(
- const Char *str, unsigned width, Char fill = ' ')
-{
- return StrFormatSpec<Char>(str, width, fill);
-}
-
-inline StrFormatSpec<wchar_t> pad(
- const wchar_t *str, unsigned width, char fill = ' ')
-{
- return StrFormatSpec<wchar_t>(str, width, fill);
-}
-
-namespace internal
-{
-
-template <typename Char>
-class ArgMap
-{
-private:
- typedef std::vector<
- std::pair<fmt::BasicStringRef<Char>, internal::Arg> > MapType;
- typedef typename MapType::value_type Pair;
-
- MapType map_;
-
-public:
- FMT_API void init(const ArgList &args);
-
- const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const
- {
- // The list is unsorted, so just return the first matching name.
- for (typename MapType::const_iterator it = map_.begin(), end = map_.end();
- it != end; ++it)
- {
- if (it->first == name)
- return &it->second;
- }
- return 0;
- }
-};
-
-template <typename Impl, typename Char>
-class ArgFormatterBase : public ArgVisitor<Impl, void>
-{
-private:
- BasicWriter<Char> &writer_;
- FormatSpec &spec_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);
-
- void write_pointer(const void *p)
- {
- spec_.flags_ = HASH_FLAG;
- spec_.type_ = 'x';
- writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
- }
-
-protected:
- BasicWriter<Char> &writer()
- {
- return writer_;
- }
- FormatSpec &spec()
- {
- return spec_;
- }
-
- void write(bool value)
- {
- const char *str_value = value ? "true" : "false";
- Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
- writer_.write_str(str, spec_);
- }
-
- void write(const char *value)
- {
- Arg::StringValue<char> str = { value, value != 0 ? std::strlen(value) : 0 };
- writer_.write_str(str, spec_);
- }
-
-public:
- ArgFormatterBase(BasicWriter<Char> &w, FormatSpec &s)
- : writer_(w), spec_(s) {}
-
- template <typename T>
- void visit_any_int(T value)
- {
- writer_.write_int(value, spec_);
- }
-
- template <typename T>
- void visit_any_double(T value)
- {
- writer_.write_double(value, spec_);
- }
-
- void visit_bool(bool value)
- {
- if (spec_.type_)
- return visit_any_int(value);
- write(value);
- }
-
- void visit_char(int value)
- {
- if (spec_.type_ && spec_.type_ != 'c')
- {
- spec_.flags_ |= CHAR_FLAG;
- writer_.write_int(value, spec_);
- return;
- }
- if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
- FMT_THROW(FormatError("invalid format specifier for char"));
- typedef typename BasicWriter<Char>::CharPtr CharPtr;
- Char fill = internal::CharTraits<Char>::cast(spec_.fill());
- CharPtr out = CharPtr();
- const unsigned CHAR_SIZE = 1;
- if (spec_.width_ > CHAR_SIZE)
- {
- out = writer_.grow_buffer(spec_.width_);
- if (spec_.align_ == ALIGN_RIGHT)
- {
- std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill);
- out += spec_.width_ - CHAR_SIZE;
- }
- else if (spec_.align_ == ALIGN_CENTER)
- {
- out = writer_.fill_padding(out, spec_.width_,
- internal::const_check(CHAR_SIZE), fill);
- }
- else
- {
- std::uninitialized_fill_n(out + CHAR_SIZE,
- spec_.width_ - CHAR_SIZE, fill);
- }
- }
- else
- {
- out = writer_.grow_buffer(CHAR_SIZE);
- }
- *out = internal::CharTraits<Char>::cast(value);
- }
-
- void visit_cstring(const char *value)
- {
- if (spec_.type_ == 'p')
- return write_pointer(value);
- write(value);
- }
-
- void visit_string(Arg::StringValue<char> value)
- {
- writer_.write_str(value, spec_);
- }
-
- using ArgVisitor<Impl, void>::visit_wstring;
-
- void visit_wstring(Arg::StringValue<Char> value)
- {
- writer_.write_str(value, spec_);
- }
-
- void visit_pointer(const void *value)
- {
- if (spec_.type_ && spec_.type_ != 'p')
- report_unknown_type(spec_.type_, "pointer");
- write_pointer(value);
- }
-};
-
-class FormatterBase
-{
-private:
- ArgList args_;
- int next_arg_index_;
-
- // Returns the argument with specified index.
- FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);
-
-protected:
- const ArgList &args() const
- {
- return args_;
- }
-
- explicit FormatterBase(const ArgList &args)
- {
- args_ = args;
- next_arg_index_ = 0;
- }
-
- // Returns the next argument.
- Arg next_arg(const char *&error)
- {
- if (next_arg_index_ >= 0)
- return do_get_arg(internal::to_unsigned(next_arg_index_++), error);
- error = "cannot switch from manual to automatic argument indexing";
- return Arg();
- }
-
- // Checks if manual indexing is used and returns the argument with
- // specified index.
- Arg get_arg(unsigned arg_index, const char *&error)
- {
- return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
- }
-
- bool check_no_auto_index(const char *&error)
- {
- if (next_arg_index_ > 0)
- {
- error = "cannot switch from automatic to manual argument indexing";
- return false;
- }
- next_arg_index_ = -1;
- return true;
- }
-
- template <typename Char>
- void write(BasicWriter<Char> &w, const Char *start, const Char *end)
- {
- if (start != end)
- w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
- }
-};
-} // namespace internal
-
-/**
-\rst
-An argument formatter based on the `curiously recurring template pattern
-<http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.
-
-To use `~fmt::BasicArgFormatter` define a subclass that implements some or
-all of the visit methods with the same signatures as the methods in
-`~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`.
-Pass the subclass as the *Impl* template parameter. When a formatting
-function processes an argument, it will dispatch to a visit method
-specific to the argument type. For example, if the argument type is
-``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
-will be called. If the subclass doesn't contain a method with this signature,
-then a corresponding method of `~fmt::BasicArgFormatter` or its superclass
-will be called.
-\endrst
-*/
-template <typename Impl, typename Char>
-class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char>
-{
-private:
- BasicFormatter<Char, Impl> &formatter_;
- const Char *format_;
-
-public:
- /**
- \rst
- Constructs an argument formatter object.
- *formatter* is a reference to the main formatter object, *spec* contains
- format specifier information for standard argument types, and *fmt* points
- to the part of the format string being parsed for custom argument types.
- \endrst
- */
- BasicArgFormatter(BasicFormatter<Char, Impl> &formatter,
- FormatSpec &spec, const Char *fmt)
- : internal::ArgFormatterBase<Impl, Char>(formatter.writer(), spec),
- formatter_(formatter), format_(fmt) {}
-
- /** Formats an argument of a custom (user-defined) type. */
- void visit_custom(internal::Arg::CustomValue c)
- {
- c.format(&formatter_, c.value, &format_);
- }
-};
-
-/** The default argument formatter. */
-template <typename Char>
-class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char>
-{
-public:
- /** Constructs an argument formatter object. */
- ArgFormatter(BasicFormatter<Char> &formatter,
- FormatSpec &spec, const Char *fmt)
- : BasicArgFormatter<ArgFormatter<Char>, Char>(formatter, spec, fmt) {}
-};
-
-/** This template formats data and writes the output to a writer. */
-template <typename CharType, typename ArgFormatter>
-class BasicFormatter : private internal::FormatterBase
-{
-public:
- /** The character type for the output. */
- typedef CharType Char;
-
-private:
- BasicWriter<Char> &writer_;
- internal::ArgMap<Char> map_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
-
- using internal::FormatterBase::get_arg;
-
- // Checks if manual indexing is used and returns the argument with
- // specified name.
- internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
-
- // Parses argument index and returns corresponding argument.
- internal::Arg parse_arg_index(const Char *&s);
-
- // Parses argument name and returns corresponding argument.
- internal::Arg parse_arg_name(const Char *&s);
-
-public:
- /**
- \rst
- Constructs a ``BasicFormatter`` object. References to the arguments and
- the writer are stored in the formatter object so make sure they have
- appropriate lifetimes.
- \endrst
- */
- BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
- : internal::FormatterBase(args), writer_(w) {}
-
- /** Returns a reference to the writer associated with this formatter. */
- BasicWriter<Char> &writer()
- {
- return writer_;
- }
-
- /** Formats stored arguments and writes the output to the writer. */
- void format(BasicCStringRef<Char> format_str);
-
- // Formats a single argument and advances format_str, a format string pointer.
- const Char *format(const Char *&format_str, const internal::Arg &arg);
-};
-
-// Generates a comma-separated list with results of applying f to
-// numbers 0..n-1.
-# define FMT_GEN(n, f) FMT_GEN##n(f)
-# define FMT_GEN1(f) f(0)
-# define FMT_GEN2(f) FMT_GEN1(f), f(1)
-# define FMT_GEN3(f) FMT_GEN2(f), f(2)
-# define FMT_GEN4(f) FMT_GEN3(f), f(3)
-# define FMT_GEN5(f) FMT_GEN4(f), f(4)
-# define FMT_GEN6(f) FMT_GEN5(f), f(5)
-# define FMT_GEN7(f) FMT_GEN6(f), f(6)
-# define FMT_GEN8(f) FMT_GEN7(f), f(7)
-# define FMT_GEN9(f) FMT_GEN8(f), f(8)
-# define FMT_GEN10(f) FMT_GEN9(f), f(9)
-# define FMT_GEN11(f) FMT_GEN10(f), f(10)
-# define FMT_GEN12(f) FMT_GEN11(f), f(11)
-# define FMT_GEN13(f) FMT_GEN12(f), f(12)
-# define FMT_GEN14(f) FMT_GEN13(f), f(13)
-# define FMT_GEN15(f) FMT_GEN14(f), f(14)
-
-namespace internal
-{
-inline uint64_t make_type()
-{
- return 0;
-}
-
-template <typename T>
-inline uint64_t make_type(const T &arg)
-{
- return MakeValue< BasicFormatter<char> >::type(arg);
-}
-
-template <unsigned N, bool/*IsPacked*/ = (N < ArgList::MAX_PACKED_ARGS)>
- struct ArgArray;
-
-template <unsigned N>
-struct ArgArray<N, true/*IsPacked*/>
-{
- typedef Value Type[N > 0 ? N : 1];
-
-template <typename Formatter, typename T>
-static Value make(const T &value)
-{
-#ifdef __clang__
- Value result = MakeValue<Formatter>(value);
- // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang:
- // https://github.com/fmtlib/fmt/issues/276
- (void)result.custom.format;
- return result;
-#else
- return MakeValue<Formatter>(value);
-#endif
-}
- };
-
-template <unsigned N>
-struct ArgArray<N, false/*IsPacked*/>
-{
- typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE
-
- template <typename Formatter, typename T>
- static Arg make(const T &value)
- {
- return MakeArg<Formatter>(value);
- }
-};
-
-#if FMT_USE_VARIADIC_TEMPLATES
-template <typename Arg, typename... Args>
-inline uint64_t make_type(const Arg &first, const Args & ... tail)
-{
- return make_type(first) | (make_type(tail...) << 4);
-}
-
-#else
-
-struct ArgType
-{
- uint64_t type;
-
- ArgType() : type(0) {}
-
- template <typename T>
- ArgType(const T &arg) : type(make_type(arg)) {}
-};
-
-# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
-
-inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT))
-{
- return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
- (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
- (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
- (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
-}
-#endif
-} // namespace internal
-
-# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
-# define FMT_MAKE_ARG_TYPE(n) T##n
-# define FMT_MAKE_ARG(n) const T##n &v##n
-# define FMT_ASSIGN_char(n) \
- arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)
-# define FMT_ASSIGN_wchar_t(n) \
- arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)
-
-#if FMT_USE_VARIADIC_TEMPLATES
-// Defines a variadic function returning void.
-# define FMT_VARIADIC_VOID(func, arg_type) \
- template <typename... Args> \
- void func(arg_type arg0, const Args & ... args) { \
- typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
- typename ArgArray::Type array{ \
- ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
- func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \
- }
-
-// Defines a variadic constructor.
-# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
- template <typename... Args> \
- ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
- typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
- typename ArgArray::Type array{ \
- ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
- func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \
- }
-
-#else
-
-# define FMT_MAKE_REF(n) \
- fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)
-# define FMT_MAKE_REF2(n) v##n
-
-// Defines a wrapper for a function taking one argument of type arg_type
-// and n additional arguments of arbitrary types.
-# define FMT_WRAP1(func, arg_type, n) \
- template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
- inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
- const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
- func(arg1, fmt::ArgList( \
- fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
- }
-
-// Emulates a variadic function returning void on a pre-C++11 compiler.
-# define FMT_VARIADIC_VOID(func, arg_type) \
- inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
- FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
- FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
- FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
- FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \
- FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)
-
-# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
- template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
- ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
- const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
- func(arg0, arg1, fmt::ArgList( \
- fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
- }
-
-// Emulates a variadic constructor on a pre-C++11 compiler.
-# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \
- FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)
-#endif
-
-// Generates a comma-separated list with results of applying f to pairs
-// (argument, index).
-#define FMT_FOR_EACH1(f, x0) f(x0, 0)
-#define FMT_FOR_EACH2(f, x0, x1) \
- FMT_FOR_EACH1(f, x0), f(x1, 1)
-#define FMT_FOR_EACH3(f, x0, x1, x2) \
- FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)
-#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \
- FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)
-#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \
- FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)
-#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \
- FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)
-#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \
- FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)
-#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \
- FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)
-#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \
- FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)
-#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \
- FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)
-
-/**
-An error returned by an operating system or a language runtime,
-for example a file opening error.
-*/
-class SystemError : public internal::RuntimeError
-{
-private:
- void init(int err_code, CStringRef format_str, ArgList args);
-
-protected:
- int error_code_;
-
- typedef char Char; // For FMT_VARIADIC_CTOR.
-
- SystemError() {}
-
-public:
- /**
- \rst
- Constructs a :class:`fmt::SystemError` object with a description
- formatted with `fmt::format_system_error`. *message* and additional
- arguments passed into the constructor are formatted similarly to
- `fmt::format`.
-
- **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)
-
- ~SystemError() throw();
-
- int error_code() const
- {
- return error_code_;
- }
-};
-
-/**
-\rst
-Formats an error returned by an operating system or a language runtime,
-for example a file opening error, and writes it to *out* in the following
-form:
-
-.. parsed-literal::
-*<message>*: *<system-message>*
-
-where *<message>* is the passed 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.
-\endrst
-*/
-FMT_API void format_system_error(fmt::Writer &out, int error_code,
- fmt::StringRef message) FMT_NOEXCEPT;
-
-/**
-\rst
-This template provides operations for formatting and writing data into
-a character stream. The output is stored in a buffer provided by a subclass
-such as :class:`fmt::BasicMemoryWriter`.
-
-You can use one of the following typedefs for common character types:
-
-+---------+----------------------+
-| Type | Definition |
-+=========+======================+
-| Writer | BasicWriter<char> |
-+---------+----------------------+
-| WWriter | BasicWriter<wchar_t> |
-+---------+----------------------+
-
-\endrst
-*/
-template <typename Char>
-class BasicWriter
-{
-private:
- // Output buffer.
- Buffer<Char> &buffer_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
-
- typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
-
-#if FMT_SECURE_SCL
- // Returns pointer value.
- static Char *get(CharPtr p)
- {
- return p.base();
- }
-#else
- static Char *get(Char *p)
- {
- return p;
- }
-#endif
-
- // Fills the padding around the content and returns the pointer to the
- // content area.
- static CharPtr fill_padding(CharPtr buffer,
- unsigned total_size, std::size_t content_size, wchar_t fill);
-
- // Grows the buffer by n characters and returns a pointer to the newly
- // allocated area.
- CharPtr grow_buffer(std::size_t n)
- {
- std::size_t size = buffer_.size();
- buffer_.resize(size + n);
- return internal::make_ptr(&buffer_[size], n);
- }
-
- // Writes an unsigned decimal integer.
- template <typename UInt>
- Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0)
- {
- unsigned num_digits = internal::count_digits(value);
- Char *ptr = get(grow_buffer(prefix_size + num_digits));
- internal::format_decimal(ptr + prefix_size, value, num_digits);
- return ptr;
- }
-
- // Writes a decimal integer.
- template <typename Int>
- void write_decimal(Int value)
- {
- typedef typename internal::IntTraits<Int>::MainType MainType;
- MainType abs_value = static_cast<MainType>(value);
- if (internal::is_negative(value))
- {
- abs_value = 0 - abs_value;
- *write_unsigned_decimal(abs_value, 1) = '-';
- }
- else
- {
- write_unsigned_decimal(abs_value, 0);
- }
- }
-
- // Prepare a buffer for integer formatting.
- CharPtr prepare_int_buffer(unsigned num_digits,
- const EmptySpec &, const char *prefix, unsigned prefix_size)
- {
- unsigned size = prefix_size + num_digits;
- CharPtr p = grow_buffer(size);
- std::uninitialized_copy(prefix, prefix + prefix_size, p);
- return p + size - 1;
- }
-
- template <typename Spec>
- CharPtr prepare_int_buffer(unsigned num_digits,
- const Spec &spec, const char *prefix, unsigned prefix_size);
-
- // Formats an integer.
- template <typename T, typename Spec>
- void write_int(T value, Spec spec);
-
- // Formats a floating-point number (double or long double).
- template <typename T>
- void write_double(T value, const FormatSpec &spec);
-
- // Writes a formatted string.
- template <typename StrChar>
- CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);
-
- template <typename StrChar>
- void write_str(const internal::Arg::StringValue<StrChar> &str,
- const FormatSpec &spec);
-
- // This following methods are private to disallow writing wide characters
- // and strings to a char stream. If you want to print a wide string as a
- // pointer as std::ostream does, cast it to const void*.
- // Do not implement!
- void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
- void operator<<(
- typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
-
- // Appends floating-point length specifier to the format string.
- // The second argument is only used for overload resolution.
- void append_float_length(Char *&format_ptr, long double)
- {
- *format_ptr++ = 'L';
- }
-
- template<typename T>
- void append_float_length(Char *&, T) {}
-
- template <typename Impl, typename Char_>
- friend class internal::ArgFormatterBase;
-
- template <typename Impl, typename Char_>
- friend class BasicPrintfArgFormatter;
-
-protected:
- /**
- Constructs a ``BasicWriter`` object.
- */
- explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
-
-public:
- /**
- \rst
- Destroys a ``BasicWriter`` object.
- \endrst
- */
- virtual ~BasicWriter() {}
-
- /**
- Returns the total number of characters written.
- */
- std::size_t size() const
- {
- return buffer_.size();
- }
-
- /**
- Returns a pointer to the output buffer content. No terminating null
- character is appended.
- */
- const Char *data() const FMT_NOEXCEPT
- {
- return &buffer_[0];
- }
-
- /**
- Returns a pointer to the output buffer content with terminating null
- character appended.
- */
- const Char *c_str() const
- {
- std::size_t size = buffer_.size();
- buffer_.reserve(size + 1);
- buffer_[size] = '\0';
- return &buffer_[0];
- }
-
- /**
- \rst
- Returns the content of the output buffer as an `std::string`.
- \endrst
- */
- std::basic_string<Char> str() const
- {
- return std::basic_string<Char>(&buffer_[0], buffer_.size());
- }
-
- /**
- \rst
- Writes formatted data.
-
- *args* is an argument list representing arbitrary arguments.
-
- **Example**::
-
- MemoryWriter out;
- out.write("Current point:\n");
- out.write("({:+f}, {:+f})", -3.14, 3.14);
-
- This will write the following output to the ``out`` object:
-
- .. code-block:: none
-
- Current point:
- (-3.140000, +3.140000)
-
- The output can be accessed using :func:`data()`, :func:`c_str` or
- :func:`str` methods.
-
- See also :ref:`syntax`.
- \endrst
- */
- void write(BasicCStringRef<Char> format, ArgList args)
- {
- BasicFormatter<Char>(args, *this).format(format);
- }
- FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
-
- BasicWriter &operator<<(int value)
- {
- write_decimal(value);
- return *this;
- }
- BasicWriter &operator<<(unsigned value)
- {
- return *this << IntFormatSpec<unsigned>(value);
- }
- BasicWriter &operator<<(long value)
- {
- write_decimal(value);
- return *this;
- }
- BasicWriter &operator<<(unsigned long value)
- {
- return *this << IntFormatSpec<unsigned long>(value);
- }
- BasicWriter &operator<<(LongLong value)
- {
- write_decimal(value);
- return *this;
- }
-
- /**
- \rst
- Formats *value* and writes it to the stream.
- \endrst
- */
- BasicWriter &operator<<(ULongLong value)
- {
- return *this << IntFormatSpec<ULongLong>(value);
- }
-
- BasicWriter &operator<<(double value)
- {
- write_double(value, FormatSpec());
- return *this;
- }
-
- /**
- \rst
- Formats *value* using the general format for floating-point numbers
- (``'g'``) and writes it to the stream.
- \endrst
- */
- BasicWriter &operator<<(long double value)
- {
- write_double(value, FormatSpec());
- return *this;
- }
-
- /**
- Writes a character to the stream.
- */
- BasicWriter &operator<<(char value)
- {
- buffer_.push_back(value);
- return *this;
- }
-
- BasicWriter &operator<<(
- typename internal::WCharHelper<wchar_t, Char>::Supported value)
- {
- buffer_.push_back(value);
- return *this;
- }
-
- /**
- \rst
- Writes *value* to the stream.
- \endrst
- */
- BasicWriter &operator<<(fmt::BasicStringRef<Char> value)
- {
- const Char *str = value.data();
- buffer_.append(str, str + value.size());
- return *this;
- }
-
- BasicWriter &operator<<(
- typename internal::WCharHelper<StringRef, Char>::Supported value)
- {
- const char *str = value.data();
- buffer_.append(str, str + value.size());
- return *this;
- }
-
- template <typename T, typename Spec, typename FillChar>
- BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec)
- {
- internal::CharTraits<Char>::convert(FillChar());
- write_int(spec.value(), spec);
- return *this;
- }
-
- template <typename StrChar>
- BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec)
- {
- const StrChar *s = spec.str();
- write_str(s, std::char_traits<Char>::length(s), spec);
- return *this;
- }
-
- void clear() FMT_NOEXCEPT{ buffer_.clear(); }
-
- Buffer<Char> &buffer() FMT_NOEXCEPT{ return buffer_; }
-};
-
-template <typename Char>
-template <typename StrChar>
-typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
- const StrChar *s, std::size_t size, const AlignSpec &spec)
-{
- CharPtr out = CharPtr();
- if (spec.width() > size)
- {
- out = grow_buffer(spec.width());
- Char fill = internal::CharTraits<Char>::cast(spec.fill());
- if (spec.align() == ALIGN_RIGHT)
- {
- std::uninitialized_fill_n(out, spec.width() - size, fill);
- out += spec.width() - size;
- }
- else if (spec.align() == ALIGN_CENTER)
- {
- out = fill_padding(out, spec.width(), size, fill);
- }
- else
- {
- std::uninitialized_fill_n(out + size, spec.width() - size, fill);
- }
- }
- else
- {
- out = grow_buffer(size);
- }
- std::uninitialized_copy(s, s + size, out);
- return out;
-}
-
-template <typename Char>
-template <typename StrChar>
-void BasicWriter<Char>::write_str(
- const internal::Arg::StringValue<StrChar> &s, const FormatSpec &spec)
-{
- // Check if StrChar is convertible to Char.
- internal::CharTraits<Char>::convert(StrChar());
- if (spec.type_ && spec.type_ != 's')
- internal::report_unknown_type(spec.type_, "string");
- const StrChar *str_value = s.value;
- std::size_t str_size = s.size;
- if (str_size == 0)
- {
- if (!str_value)
- {
- FMT_THROW(FormatError("string pointer is null"));
- }
- }
- std::size_t precision = static_cast<std::size_t>(spec.precision_);
- if (spec.precision_ >= 0 && precision < str_size)
- str_size = precision;
- write_str(str_value, str_size, spec);
-}
-
-template <typename Char>
-typename BasicWriter<Char>::CharPtr
-BasicWriter<Char>::fill_padding(
- CharPtr buffer, unsigned total_size,
- std::size_t content_size, wchar_t fill)
-{
- std::size_t padding = total_size - content_size;
- std::size_t left_padding = padding / 2;
- Char fill_char = internal::CharTraits<Char>::cast(fill);
- std::uninitialized_fill_n(buffer, left_padding, fill_char);
- buffer += left_padding;
- CharPtr content = buffer;
- std::uninitialized_fill_n(buffer + content_size,
- padding - left_padding, fill_char);
- return content;
-}
-
-template <typename Char>
-template <typename Spec>
-typename BasicWriter<Char>::CharPtr
-BasicWriter<Char>::prepare_int_buffer(
- unsigned num_digits, const Spec &spec,
- const char *prefix, unsigned prefix_size)
-{
- unsigned width = spec.width();
- Alignment align = spec.align();
- Char fill = internal::CharTraits<Char>::cast(spec.fill());
- if (spec.precision() > static_cast<int>(num_digits))
- {
- // Octal prefix '0' is counted as a digit, so ignore it if precision
- // is specified.
- if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
- --prefix_size;
- unsigned number_size =
- prefix_size + internal::to_unsigned(spec.precision());
- AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
- if (number_size >= width)
- return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
- buffer_.reserve(width);
- unsigned fill_size = width - number_size;
- if (align != ALIGN_LEFT)
- {
- CharPtr p = grow_buffer(fill_size);
- std::uninitialized_fill(p, p + fill_size, fill);
- }
- CharPtr result = prepare_int_buffer(
- num_digits, subspec, prefix, prefix_size);
- if (align == ALIGN_LEFT)
- {
- CharPtr p = grow_buffer(fill_size);
- std::uninitialized_fill(p, p + fill_size, fill);
- }
- return result;
- }
- unsigned size = prefix_size + num_digits;
- if (width <= size)
- {
- CharPtr p = grow_buffer(size);
- std::uninitialized_copy(prefix, prefix + prefix_size, p);
- return p + size - 1;
- }
- CharPtr p = grow_buffer(width);
- CharPtr end = p + width;
- if (align == ALIGN_LEFT)
- {
- std::uninitialized_copy(prefix, prefix + prefix_size, p);
- p += size;
- std::uninitialized_fill(p, end, fill);
- }
- else if (align == ALIGN_CENTER)
- {
- p = fill_padding(p, width, size, fill);
- std::uninitialized_copy(prefix, prefix + prefix_size, p);
- p += size;
- }
- else
- {
- if (align == ALIGN_NUMERIC)
- {
- if (prefix_size != 0)
- {
- p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
- size -= prefix_size;
- }
- }
- else
- {
- std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
- }
- std::uninitialized_fill(p, end - size, fill);
- p = end;
- }
- return p - 1;
-}
-
-template <typename Char>
-template <typename T, typename Spec>
-void BasicWriter<Char>::write_int(T value, Spec spec)
-{
- unsigned prefix_size = 0;
- typedef typename internal::IntTraits<T>::MainType UnsignedType;
- UnsignedType abs_value = static_cast<UnsignedType>(value);
- char prefix[4] = "";
- if (internal::is_negative(value))
- {
- prefix[0] = '-';
- ++prefix_size;
- abs_value = 0 - abs_value;
- }
- else if (spec.flag(SIGN_FLAG))
- {
- prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
- ++prefix_size;
- }
- switch (spec.type())
- {
- case 0:
- case 'd':
- {
- unsigned num_digits = internal::count_digits(abs_value);
- CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1;
- internal::format_decimal(get(p), abs_value, 0);
- break;
- }
- case 'x':
- case 'X':
- {
- UnsignedType n = abs_value;
- if (spec.flag(HASH_FLAG))
- {
- prefix[prefix_size++] = '0';
- prefix[prefix_size++] = spec.type();
- }
- unsigned num_digits = 0;
- do
- {
- ++num_digits;
- }
- while ((n >>= 4) != 0);
- Char *p = get(prepare_int_buffer(
- num_digits, spec, prefix, prefix_size));
- n = abs_value;
- const char *digits = spec.type() == 'x' ?
- "0123456789abcdef" : "0123456789ABCDEF";
- do
- {
- *p-- = digits[n & 0xf];
- }
- while ((n >>= 4) != 0);
- break;
- }
- case 'b':
- case 'B':
- {
- UnsignedType n = abs_value;
- if (spec.flag(HASH_FLAG))
- {
- prefix[prefix_size++] = '0';
- prefix[prefix_size++] = spec.type();
- }
- unsigned num_digits = 0;
- do
- {
- ++num_digits;
- }
- while ((n >>= 1) != 0);
- Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
- n = abs_value;
- do
- {
- *p-- = static_cast<Char>('0' + (n & 1));
- }
- while ((n >>= 1) != 0);
- break;
- }
- case 'o':
- {
- UnsignedType n = abs_value;
- if (spec.flag(HASH_FLAG))
- prefix[prefix_size++] = '0';
- unsigned num_digits = 0;
- do
- {
- ++num_digits;
- }
- while ((n >>= 3) != 0);
- Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
- n = abs_value;
- do
- {
- *p-- = static_cast<Char>('0' + (n & 7));
- }
- while ((n >>= 3) != 0);
- break;
- }
- case 'n':
- {
- unsigned num_digits = internal::count_digits(abs_value);
- fmt::StringRef sep = "";
-#ifndef ANDROID
- sep = internal::thousands_sep(std::localeconv());
-#endif
- unsigned size = static_cast<unsigned>(
- num_digits + sep.size() * ((num_digits - 1) / 3));
- CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
- internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep));
- 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':
-#if FMT_MSC_VER
- // MSVC's printf doesn't support 'F'.
- type = 'f';
-#endif
- // Fall through.
- case 'E':
- case 'G':
- case 'A':
- upper = true;
- break;
- default:
- internal::report_unknown_type(type, "double");
- break;
- }
-
- char sign = 0;
- // Use isnegative instead of value < 0 because the latter is always
- // false for NaN.
- if (internal::FPUtil::isnegative(static_cast<double>(value)))
- {
- sign = '-';
- value = -value;
- }
- else if (spec.flag(SIGN_FLAG))
- {
- sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
- }
-
- if (internal::FPUtil::isnotanumber(value))
- {
- // Format NaN ourselves because sprintf's output is not consistent
- // across platforms.
- std::size_t nan_size = 4;
- const char *nan = upper ? " NAN" : " nan";
- if (!sign)
- {
- --nan_size;
- ++nan;
- }
- CharPtr out = write_str(nan, nan_size, spec);
- if (sign)
- *out = sign;
- return;
- }
-
- if (internal::FPUtil::isinfinity(value))
- {
- // Format infinity ourselves because sprintf's output is not consistent
- // across platforms.
- std::size_t inf_size = 4;
- const char *inf = upper ? " INF" : " inf";
- if (!sign)
- {
- --inf_size;
- ++inf;
- }
- CharPtr out = write_str(inf, inf_size, spec);
- if (sign)
- *out = sign;
- return;
- }
-
- std::size_t offset = buffer_.size();
- unsigned width = spec.width();
- if (sign)
- {
- buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
- if (width > 0)
- --width;
- ++offset;
- }
-
- // Build format string.
- enum { MAX_FORMAT_SIZE = 10 }; // longest format: %#-*.*Lg
- Char format[MAX_FORMAT_SIZE];
- Char *format_ptr = format;
- *format_ptr++ = '%';
- unsigned width_for_sprintf = width;
- if (spec.flag(HASH_FLAG))
- *format_ptr++ = '#';
- if (spec.align() == ALIGN_CENTER)
- {
- width_for_sprintf = 0;
- }
- else
- {
- if (spec.align() == ALIGN_LEFT)
- *format_ptr++ = '-';
- if (width != 0)
- *format_ptr++ = '*';
- }
- if (spec.precision() >= 0)
- {
- *format_ptr++ = '.';
- *format_ptr++ = '*';
- }
-
- append_float_length(format_ptr, value);
- *format_ptr++ = type;
- *format_ptr = '\0';
-
- // Format using snprintf.
- Char fill = internal::CharTraits<Char>::cast(spec.fill());
- unsigned n = 0;
- Char *start = 0;
- for (;;)
- {
- std::size_t buffer_size = buffer_.capacity() - offset;
-#if FMT_MSC_VER
- // MSVC's vsnprintf_s doesn't work with zero size, so reserve
- // space for at least one extra character to make the size non-zero.
- // Note that the buffer's capacity will increase by more than 1.
- if (buffer_size == 0)
- {
- buffer_.reserve(offset + 1);
- buffer_size = buffer_.capacity() - offset;
- }
-#endif
- start = &buffer_[offset];
- int result = internal::CharTraits<Char>::format_float(
- start, buffer_size, format, width_for_sprintf, spec.precision(), value);
- if (result >= 0)
- {
- n = internal::to_unsigned(result);
- if (offset + n < buffer_.capacity())
- break; // The buffer is large enough - continue with formatting.
- buffer_.reserve(offset + n + 1);
- }
- else
- {
- // If result is negative we ask to increase the capacity by at least 1,
- // but as std::vector, the buffer grows exponentially.
- buffer_.reserve(buffer_.capacity() + 1);
- }
- }
- if (sign)
- {
- if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
- *start != ' ')
- {
- *(start - 1) = sign;
- sign = 0;
- }
- else
- {
- *(start - 1) = fill;
- }
- ++n;
- }
- if (spec.align() == ALIGN_CENTER && spec.width() > n)
- {
- width = spec.width();
- CharPtr p = grow_buffer(width);
- std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
- fill_padding(p, spec.width(), n, fill);
- return;
- }
- if (spec.fill() != ' ' || sign)
- {
- while (*start == ' ')
- *start++ = fill;
- if (sign)
- *(start - 1) = sign;
- }
- grow_buffer(n);
-}
-
-/**
-\rst
-This class template provides operations for formatting and writing data
-into a character stream. The output is stored in a memory buffer that grows
-dynamically.
-
-You can use one of the following typedefs for common character types
-and the standard allocator:
-
-+---------------+-----------------------------------------------------+
-| Type | Definition |
-+===============+=====================================================+
-| MemoryWriter | BasicMemoryWriter<char, std::allocator<char>> |
-+---------------+-----------------------------------------------------+
-| WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
-+---------------+-----------------------------------------------------+
-
-**Example**::
-
-MemoryWriter out;
-out << "The answer is " << 42 << "\n";
-out.write("({:+f}, {:+f})", -3.14, 3.14);
-
-This will write the following output to the ``out`` object:
-
-.. code-block:: none
-
-The answer is 42
-(-3.140000, +3.140000)
-
-The output can be converted to an ``std::string`` with ``out.str()`` or
-accessed as a C string with ``out.c_str()``.
-\endrst
-*/
-template <typename Char, typename Allocator = std::allocator<Char> >
-class BasicMemoryWriter : public BasicWriter<Char>
-{
-private:
- internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
-
-public:
- explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
- : BasicWriter<Char>(buffer_), buffer_(alloc) {}
-
-#if FMT_USE_RVALUE_REFERENCES
- /**
- \rst
- Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
- of the other object to it.
- \endrst
- */
- BasicMemoryWriter(BasicMemoryWriter &&other)
- : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_))
- {
- }
-
- /**
- \rst
- Moves the content of the other ``BasicMemoryWriter`` object to this one.
- \endrst
- */
- BasicMemoryWriter &operator=(BasicMemoryWriter &&other)
- {
- buffer_ = std::move(other.buffer_);
- return *this;
- }
-#endif
-};
-
-typedef BasicMemoryWriter<char> MemoryWriter;
-typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
-
-/**
-\rst
-This class template provides operations for formatting and writing data
-into a fixed-size array. For writing into a dynamically growing buffer
-use :class:`fmt::BasicMemoryWriter`.
-
-Any write method will throw ``std::runtime_error`` if the output doesn't fit
-into the array.
-
-You can use one of the following typedefs for common character types:
-
-+--------------+---------------------------+
-| Type | Definition |
-+==============+===========================+
-| ArrayWriter | BasicArrayWriter<char> |
-+--------------+---------------------------+
-| WArrayWriter | BasicArrayWriter<wchar_t> |
-+--------------+---------------------------+
-\endrst
-*/
-template <typename Char>
-class BasicArrayWriter : public BasicWriter<Char>
-{
-private:
- internal::FixedBuffer<Char> buffer_;
-
-public:
- /**
- \rst
- Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
- given size.
- \endrst
- */
- BasicArrayWriter(Char *array, std::size_t size)
- : BasicWriter<Char>(buffer_), buffer_(array, size) {}
-
- /**
- \rst
- Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
- size known at compile time.
- \endrst
- */
- template <std::size_t SIZE>
- explicit BasicArrayWriter(Char(&array)[SIZE])
- : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
-};
-
-typedef BasicArrayWriter<char> ArrayWriter;
-typedef BasicArrayWriter<wchar_t> WArrayWriter;
-
-// Reports a system error without throwing an exception.
-// Can be used to report errors from destructors.
-FMT_API void report_system_error(int error_code,
- StringRef message) FMT_NOEXCEPT;
-
-#if FMT_USE_WINDOWS_H
-
-/** A Windows error. */
-class WindowsError : public SystemError
-{
-private:
- FMT_API void init(int error_code, CStringRef format_str, ArgList args);
-
-public:
- /**
- \rst
- Constructs a :class:`fmt::WindowsError` object with the description
- of the form
-
- .. parsed-literal::
- *<message>*: *<system-message>*
-
- where *<message>* is the formatted message and *<system-message>* is the
- system message corresponding to the error code.
- *error_code* is a Windows error code as given by ``GetLastError``.
- If *error_code* is not a valid error code such as -1, the system message
- will look like "error -1".
-
- **Example**::
-
- // This throws a WindowsError with the description
- // cannot open file 'madeup': The system cannot find the file specified.
- // or similar (system message may vary).
- const char *filename = "madeup";
- LPOFSTRUCT of = LPOFSTRUCT();
- HFILE file = OpenFile(filename, &of, OF_READ);
- if (file == HFILE_ERROR) {
- throw fmt::WindowsError(GetLastError(),
- "cannot open file '{}'", filename);
- }
- \endrst
- */
- WindowsError(int error_code, CStringRef message)
- {
- init(error_code, message, ArgList());
- }
- FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
-};
-
-// Reports a Windows error without throwing an exception.
-// Can be used to report errors from destructors.
-FMT_API void report_windows_error(int error_code,
- StringRef message) FMT_NOEXCEPT;
-
-#endif
-
-enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
-
-/**
-Formats a string and prints it to stdout using ANSI escape sequences
-to specify color (experimental).
-Example:
-print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
-*/
-FMT_API void print_colored(Color c, CStringRef format, ArgList args);
-
-/**
-\rst
-Formats arguments and returns the result as a string.
-
-**Example**::
-
-std::string message = format("The answer is {}", 42);
-\endrst
-*/
-inline std::string format(CStringRef format_str, ArgList args)
-{
- MemoryWriter w;
- w.write(format_str, args);
- return w.str();
-}
-
-inline std::wstring format(WCStringRef format_str, ArgList args)
-{
- WMemoryWriter w;
- w.write(format_str, args);
- return w.str();
-}
-
-/**
-\rst
-Prints formatted data to the file *f*.
-
-**Example**::
-
-print(stderr, "Don't {}!", "panic");
-\endrst
-*/
-FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args);
-
-/**
-\rst
-Prints formatted data to ``stdout``.
-
-**Example**::
-
-print("Elapsed time: {0:.2f} seconds", 1.23);
-\endrst
-*/
-FMT_API void print(CStringRef format_str, ArgList args);
-
-/**
-Fast integer formatter.
-*/
-class FormatInt
-{
-private:
- // Buffer should be large enough to hold all digits (digits10 + 1),
- // a sign and a null character.
- enum { BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3 };
- mutable char buffer_[BUFFER_SIZE];
- char *str_;
-
- // Formats value in reverse and returns the number of digits.
- char *format_decimal(ULongLong value)
- {
- char *buffer_end = buffer_ + BUFFER_SIZE - 1;
- while (value >= 100)
- {
- // Integer division is slow so do it for a group of two digits instead
- // of for every digit. The idea comes from the talk by Alexandrescu
- // "Three Optimization Tips for C++". See speed-test for a comparison.
- unsigned index = static_cast<unsigned>((value % 100) * 2);
- value /= 100;
- *--buffer_end = internal::Data::DIGITS[index + 1];
- *--buffer_end = internal::Data::DIGITS[index];
- }
- if (value < 10)
- {
- *--buffer_end = static_cast<char>('0' + value);
- return buffer_end;
- }
- unsigned index = static_cast<unsigned>(value * 2);
- *--buffer_end = internal::Data::DIGITS[index + 1];
- *--buffer_end = internal::Data::DIGITS[index];
- return buffer_end;
- }
-
- void FormatSigned(LongLong value)
- {
- ULongLong abs_value = static_cast<ULongLong>(value);
- bool negative = value < 0;
- if (negative)
- abs_value = 0 - abs_value;
- str_ = format_decimal(abs_value);
- if (negative)
- *--str_ = '-';
- }
-
-public:
- explicit FormatInt(int value)
- {
- FormatSigned(value);
- }
- explicit FormatInt(long value)
- {
- FormatSigned(value);
- }
- explicit FormatInt(LongLong value)
- {
- FormatSigned(value);
- }
- explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
- explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
- explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}
-
- /** Returns the number of characters written to the output buffer. */
- std::size_t size() const
- {
- return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
- }
-
- /**
- Returns a pointer to the output buffer content. No terminating null
- character is appended.
- */
- const char *data() const
- {
- return str_;
- }
-
- /**
- Returns a pointer to the output buffer content with terminating null
- character appended.
- */
- const char *c_str() const
- {
- buffer_[BUFFER_SIZE - 1] = '\0';
- return str_;
- }
-
- /**
- \rst
- Returns the content of the output buffer as an ``std::string``.
- \endrst
- */
- std::string str() const
- {
- return std::string(str_, size());
- }
-};
-
-// Formats a decimal integer value writing into buffer and returns
-// a pointer to the end of the formatted string. This function doesn't
-// write a terminating null character.
-template <typename T>
-inline void format_decimal(char *&buffer, T value)
-{
- typedef typename internal::IntTraits<T>::MainType MainType;
- MainType abs_value = static_cast<MainType>(value);
- if (internal::is_negative(value))
- {
- *buffer++ = '-';
- abs_value = 0 - abs_value;
- }
- if (abs_value < 100)
- {
- if (abs_value < 10)
- {
- *buffer++ = static_cast<char>('0' + abs_value);
- return;
- }
- unsigned index = static_cast<unsigned>(abs_value * 2);
- *buffer++ = internal::Data::DIGITS[index];
- *buffer++ = internal::Data::DIGITS[index + 1];
- return;
- }
- unsigned num_digits = internal::count_digits(abs_value);
- internal::format_decimal(buffer, abs_value, num_digits);
- buffer += num_digits;
-}
-
-/**
-\rst
-Returns a named argument for formatting functions.
-
-**Example**::
-
-print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
-
-\endrst
-*/
-template <typename T>
-inline internal::NamedArgWithType<char, T> arg(StringRef name, const T &arg)
-{
- return internal::NamedArgWithType<char, T>(name, arg);
-}
-
-template <typename T>
-inline internal::NamedArgWithType<wchar_t, T> arg(WStringRef name, const T &arg)
-{
- return internal::NamedArgWithType<wchar_t, T>(name, arg);
-}
-
-// The following two functions are deleted intentionally to disable
-// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``.
-template <typename Char>
-void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
-template <typename Char>
-void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
-}
-
-#if FMT_GCC_VERSION
-// Use the system_header pragma to suppress warnings about variadic macros
-// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't
-// work. It is used at the end because we want to suppress as little warnings
-// as possible.
-# pragma GCC system_header
-#endif
-
-// This is used to work around VC++ bugs in handling variadic macros.
-#define FMT_EXPAND(args) args
-
-// Returns the number of arguments.
-// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s.
-#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())
-#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))
-#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
-
-#define FMT_FOR_EACH_(N, f, ...) \
- FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))
-#define FMT_FOR_EACH(f, ...) \
- FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))
-
-#define FMT_ADD_ARG_NAME(type, index) type arg##index
-#define FMT_GET_ARG_NAME(type, index) arg##index
-
-#if FMT_USE_VARIADIC_TEMPLATES
-# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
- template <typename... Args> \
- ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
- const Args & ... args) { \
- typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
- typename ArgArray::Type array{ \
- ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
- call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
- fmt::ArgList(fmt::internal::make_type(args...), array)); \
- }
-#else
-// Defines a wrapper for a function taking __VA_ARGS__ arguments
-// and n additional arguments of arbitrary types.
-# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \
- template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
- inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
- FMT_GEN(n, FMT_MAKE_ARG)) { \
- fmt::internal::ArgArray<n>::Type arr; \
- FMT_GEN(n, FMT_ASSIGN_##Char); \
- call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
- fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
- }
-
-# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
- inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \
- call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \
- } \
- FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \
- FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)
-#endif // FMT_USE_VARIADIC_TEMPLATES
-
-/**
-\rst
-Defines a variadic function with the specified return type, function name
-and argument types passed as variable arguments to this macro.
-
-**Example**::
-
-void print_error(const char *file, int line, const char *format,
-fmt::ArgList args) {
-fmt::print("{}: {}: ", file, line);
-fmt::print(format, args);
-}
-FMT_VARIADIC(void, print_error, const char *, int, const char *)
-
-``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that
-don't implement variadic templates. You don't have to use this macro if
-you don't need legacy compiler support and can use variadic templates
-directly::
-
-template <typename... Args>
-void print_error(const char *file, int line, const char *format,
-const Args & ... args) {
-fmt::print("{}: {}: ", file, line);
-fmt::print(format, args...);
-}
-\endrst
-*/
-#define FMT_VARIADIC(ReturnType, func, ...) \
- FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)
-
-#define FMT_VARIADIC_W(ReturnType, func, ...) \
- FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
-
-#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)
-
-#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)
-
-/**
-\rst
-Convenient macro to capture the arguments' names and values into several
-``fmt::arg(name, value)``.
-
-**Example**::
-
-int x = 1, y = 2;
-print("point: ({x}, {y})", FMT_CAPTURE(x, y));
-// same as:
-// print("point: ({x}, {y})", arg("x", x), arg("y", y));
-
-\endrst
-*/
-#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)
-
-#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)
-
-namespace fmt
-{
-FMT_VARIADIC(std::string, format, CStringRef)
-FMT_VARIADIC_W(std::wstring, format, WCStringRef)
-FMT_VARIADIC(void, print, CStringRef)
-FMT_VARIADIC(void, print, std::FILE *, CStringRef)
-FMT_VARIADIC(void, print_colored, Color, CStringRef)
-
-namespace internal
-{
-template <typename Char>
-inline bool is_name_start(Char c)
-{
- return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-}
-
-// Parses an unsigned integer advancing s to the end of the parsed input.
-// This function assumes that the first character of s is a digit.
-template <typename Char>
-unsigned parse_nonnegative_int(const Char *&s)
-{
- assert('0' <= *s && *s <= '9');
- unsigned value = 0;
- do
- {
- unsigned new_value = value * 10 + (*s++ - '0');
- // Check if value wrapped around.
- if (new_value < value)
- {
- value = (std::numeric_limits<unsigned>::max)();
- break;
- }
- value = new_value;
- }
- while ('0' <= *s && *s <= '9');
- // Convert to unsigned to prevent a warning.
- unsigned max_int = (std::numeric_limits<int>::max)();
- if (value > max_int)
- FMT_THROW(FormatError("number is too big"));
- return value;
-}
-
-inline void require_numeric_argument(const Arg &arg, char spec)
-{
- if (arg.type > Arg::LAST_NUMERIC_TYPE)
- {
- std::string message =
- fmt::format("format specifier '{}' requires numeric argument", spec);
- FMT_THROW(fmt::FormatError(message));
- }
-}
-
-template <typename Char>
-void check_sign(const Char *&s, const Arg &arg)
-{
- char sign = static_cast<char>(*s);
- require_numeric_argument(arg, sign);
- if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG)
- {
- FMT_THROW(FormatError(fmt::format(
- "format specifier '{}' requires signed argument", sign)));
- }
- ++s;
-}
-} // namespace internal
-
-template <typename Char, typename AF>
-inline internal::Arg BasicFormatter<Char, AF>::get_arg(
- BasicStringRef<Char> arg_name, const char *&error)
-{
- if (check_no_auto_index(error))
- {
- map_.init(args());
- const internal::Arg *arg = map_.find(arg_name);
- if (arg)
- return *arg;
- error = "argument not found";
- }
- return internal::Arg();
-}
-
-template <typename Char, typename AF>
-inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s)
-{
- const char *error = 0;
- internal::Arg arg = *s < '0' || *s > '9' ?
- next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
- if (error)
- {
- FMT_THROW(FormatError(
- *s != '}' && *s != ':' ? "invalid format string" : error));
- }
- return arg;
-}
-
-template <typename Char, typename AF>
-inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s)
-{
- assert(internal::is_name_start(*s));
- const Char *start = s;
- Char c;
- do
- {
- c = *++s;
- }
- while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
- const char *error = 0;
- internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
- if (error)
- FMT_THROW(FormatError(error));
- return arg;
-}
-
-template <typename Char, typename ArgFormatter>
-const Char *BasicFormatter<Char, ArgFormatter>::format(
- const Char *&format_str, const internal::Arg &arg)
-{
- using internal::Arg;
- const Char *s = format_str;
- FormatSpec spec;
- if (*s == ':')
- {
- if (arg.type == Arg::CUSTOM)
- {
- arg.custom.format(this, arg.custom.value, &s);
- return s;
- }
- ++s;
- // Parse fill and alignment.
- if (Char c = *s)
- {
- const Char *p = s + 1;
- spec.align_ = ALIGN_DEFAULT;
- do
- {
- switch (*p)
- {
- case '<':
- spec.align_ = ALIGN_LEFT;
- break;
- case '>':
- spec.align_ = ALIGN_RIGHT;
- break;
- case '=':
- spec.align_ = ALIGN_NUMERIC;
- break;
- case '^':
- spec.align_ = ALIGN_CENTER;
- break;
- }
- if (spec.align_ != ALIGN_DEFAULT)
- {
- if (p != s)
- {
- if (c == '}') break;
- if (c == '{')
- FMT_THROW(FormatError("invalid fill character '{'"));
- s += 2;
- spec.fill_ = c;
- }
- else ++s;
- if (spec.align_ == ALIGN_NUMERIC)
- require_numeric_argument(arg, '=');
- break;
- }
- }
- while (--p >= s);
- }
-
- // Parse sign.
- switch (*s)
- {
- case '+':
- check_sign(s, arg);
- spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
- break;
- case '-':
- check_sign(s, arg);
- spec.flags_ |= MINUS_FLAG;
- break;
- case ' ':
- check_sign(s, arg);
- spec.flags_ |= SIGN_FLAG;
- break;
- }
-
- if (*s == '#')
- {
- require_numeric_argument(arg, '#');
- spec.flags_ |= HASH_FLAG;
- ++s;
- }
-
- // Parse zero flag.
- if (*s == '0')
- {
- require_numeric_argument(arg, '0');
- spec.align_ = ALIGN_NUMERIC;
- spec.fill_ = '0';
- ++s;
- }
-
- // Parse width.
- if ('0' <= *s && *s <= '9')
- {
- spec.width_ = internal::parse_nonnegative_int(s);
- }
- else if (*s == '{')
- {
- ++s;
- Arg width_arg = internal::is_name_start(*s) ?
- parse_arg_name(s) : parse_arg_index(s);
- if (*s++ != '}')
- FMT_THROW(FormatError("invalid format string"));
- ULongLong value = 0;
- switch (width_arg.type)
- {
- case Arg::INT:
- if (width_arg.int_value < 0)
- FMT_THROW(FormatError("negative width"));
- value = width_arg.int_value;
- break;
- case Arg::UINT:
- value = width_arg.uint_value;
- break;
- case Arg::LONG_LONG:
- if (width_arg.long_long_value < 0)
- FMT_THROW(FormatError("negative width"));
- value = width_arg.long_long_value;
- break;
- case Arg::ULONG_LONG:
- value = width_arg.ulong_long_value;
- break;
- default:
- FMT_THROW(FormatError("width is not integer"));
- }
- if (value >(std::numeric_limits<int>::max)())
- FMT_THROW(FormatError("number is too big"));
- spec.width_ = static_cast<int>(value);
- }
-
- // Parse precision.
- if (*s == '.')
- {
- ++s;
- spec.precision_ = 0;
- if ('0' <= *s && *s <= '9')
- {
- spec.precision_ = internal::parse_nonnegative_int(s);
- }
- else if (*s == '{')
- {
- ++s;
- Arg precision_arg = internal::is_name_start(*s) ?
- parse_arg_name(s) : parse_arg_index(s);
- if (*s++ != '}')
- FMT_THROW(FormatError("invalid format string"));
- ULongLong value = 0;
- switch (precision_arg.type)
- {
- case Arg::INT:
- if (precision_arg.int_value < 0)
- FMT_THROW(FormatError("negative precision"));
- value = precision_arg.int_value;
- break;
- case Arg::UINT:
- value = precision_arg.uint_value;
- break;
- case Arg::LONG_LONG:
- if (precision_arg.long_long_value < 0)
- FMT_THROW(FormatError("negative precision"));
- value = precision_arg.long_long_value;
- break;
- case Arg::ULONG_LONG:
- value = precision_arg.ulong_long_value;
- break;
- default:
- FMT_THROW(FormatError("precision is not integer"));
- }
- if (value >(std::numeric_limits<int>::max)())
- FMT_THROW(FormatError("number is too big"));
- spec.precision_ = static_cast<int>(value);
- }
- else
- {
- FMT_THROW(FormatError("missing precision specifier"));
- }
- if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER)
- {
- FMT_THROW(FormatError(
- fmt::format("precision not allowed in {} format specifier",
- arg.type == Arg::POINTER ? "pointer" : "integer")));
- }
- }
-
- // Parse type.
- if (*s != '}' && *s)
- spec.type_ = static_cast<char>(*s++);
- }
-
- if (*s++ != '}')
- FMT_THROW(FormatError("missing '}' in format string"));
-
- // Format argument.
- ArgFormatter(*this, spec, s - 1).visit(arg);
- return s;
-}
-
-template <typename Char, typename AF>
-void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str)
-{
- const Char *s = format_str.c_str();
- const Char *start = s;
- while (*s)
- {
- Char c = *s++;
- if (c != '{' && c != '}') continue;
- if (*s == c)
- {
- write(writer_, start, s);
- start = ++s;
- continue;
- }
- if (c == '}')
- FMT_THROW(FormatError("unmatched '}' in format string"));
- write(writer_, start, s - 1);
- internal::Arg arg = internal::is_name_start(*s) ?
- parse_arg_name(s) : parse_arg_index(s);
- start = s = format(s, arg);
- }
- write(writer_, start, s);
-}
-} // namespace fmt
-
-#if FMT_USE_USER_DEFINED_LITERALS
-namespace fmt
-{
-namespace internal
-{
-
-template <typename Char>
-struct UdlFormat
-{
- const Char *str;
-
- template <typename... Args>
- auto operator()(Args && ... args) const
- -> decltype(format(str, std::forward<Args>(args)...))
- {
- return format(str, std::forward<Args>(args)...);
- }
-};
-
-template <typename Char>
-struct UdlArg
-{
- const Char *str;
-
- template <typename T>
- NamedArgWithType<Char, T> operator=(T &&value) const
- {
- return{ str, std::forward<T>(value) };
- }
-};
-
-} // namespace internal
-
-inline namespace literals
-{
-
-/**
-\rst
-C++11 literal equivalent of :func:`fmt::format`.
-
-**Example**::
-
-using namespace fmt::literals;
-std::string message = "The answer is {}"_format(42);
-\endrst
-*/
-inline internal::UdlFormat<char>
-operator"" _format(const char *s, std::size_t)
-{
- return{ s };
-}
-inline internal::UdlFormat<wchar_t>
-operator"" _format(const wchar_t *s, std::size_t)
-{
- return{ s };
-}
-
-/**
-\rst
-C++11 literal equivalent of :func:`fmt::arg`.
-
-**Example**::
-
-using namespace fmt::literals;
-print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-\endrst
-*/
-inline internal::UdlArg<char>
-operator"" _a(const char *s, std::size_t)
-{
- return{ s };
-}
-inline internal::UdlArg<wchar_t>
-operator"" _a(const wchar_t *s, std::size_t)
-{
- return{ s };
-}
-
-} // inline namespace literals
-} // namespace fmt
-#endif // FMT_USE_USER_DEFINED_LITERALS
-
-// Restore warnings.
-#if FMT_GCC_VERSION >= 406
-# pragma GCC diagnostic pop
-#endif
-
-#if defined(__clang__) && !defined(FMT_ICC_VERSION)
-# pragma clang diagnostic pop
-#endif
-
-#ifdef FMT_HEADER_ONLY
-# define FMT_FUNC inline
-# include "format.cc"
-#else
-# define FMT_FUNC
-#endif
-
-#endif // FMT_FORMAT_H_
\ No newline at end of file
diff --git a/third_party/spdlog/include/spdlog/fmt/bundled/ostream.cc b/third_party/spdlog/include/spdlog/fmt/bundled/ostream.cc
deleted file mode 100644
index 5aff5f5d1668c8d092ee0892358595d0dbcd3bc6..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/fmt/bundled/ostream.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-Formatting library for C++ - std::ostream support
-
-Copyright (c) 2012 - 2016, Victor Zverovich
-All rights reserved.
-
-For the license information refer to format.h.
-*/
-
-#include "ostream.h"
-
-namespace fmt {
-
-namespace internal {
-FMT_FUNC void write(std::ostream &os, Writer &w) {
- const char *data = w.data();
- typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
- UnsignedStreamSize size = w.size();
- UnsignedStreamSize max_size =
- internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
- do {
- UnsignedStreamSize n = size <= max_size ? size : max_size;
- os.write(data, static_cast<std::streamsize>(n));
- data += n;
- size -= n;
- } while (size != 0);
-}
-}
-
-FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) {
- MemoryWriter w;
- w.write(format_str, args);
- internal::write(os, w);
-}
-} // namespace fmt
\ No newline at end of file
diff --git a/third_party/spdlog/include/spdlog/fmt/bundled/ostream.h b/third_party/spdlog/include/spdlog/fmt/bundled/ostream.h
deleted file mode 100644
index 23ba87267796358a3a5e21e3197f12fc78d5ce28..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/fmt/bundled/ostream.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-Formatting library for C++ - std::ostream support
-
-Copyright (c) 2012 - 2016, Victor Zverovich
-All rights reserved.
-
-For the license information refer to format.h.
-*/
-
-#ifndef FMT_OSTREAM_H_
-#define FMT_OSTREAM_H_
-
-// commented out by spdlog
-//#include "format.h"
-#include <ostream>
-
-namespace fmt
-{
-
-namespace internal
-{
-
-template <class Char>
-class FormatBuf : public std::basic_streambuf<Char>
-{
-private:
- typedef typename std::basic_streambuf<Char>::int_type int_type;
- typedef typename std::basic_streambuf<Char>::traits_type traits_type;
-
- Buffer<Char> &buffer_;
- Char *start_;
-
-public:
- FormatBuf(Buffer<Char> &buffer) : buffer_(buffer), start_(&buffer[0])
- {
- this->setp(start_, start_ + buffer_.capacity());
- }
-
- int_type overflow(int_type ch = traits_type::eof())
- {
- if (!traits_type::eq_int_type(ch, traits_type::eof()))
- {
- size_t buf_size = size();
- buffer_.resize(buf_size);
- buffer_.reserve(buf_size * 2);
-
- start_ = &buffer_[0];
- start_[buf_size] = traits_type::to_char_type(ch);
- this->setp(start_ + buf_size + 1, start_ + buf_size * 2);
- }
- return ch;
- }
-
- size_t size() const
- {
- return to_unsigned(this->pptr() - start_);
- }
-};
-
-Yes &convert(std::ostream &);
-
-struct DummyStream : std::ostream
-{
- DummyStream(); // Suppress a bogus warning in MSVC.
- // Hide all operator<< overloads from std::ostream.
- void operator<<(Null<>);
-};
-
-No &operator<<(std::ostream &, int);
-
-template<typename T>
-struct ConvertToIntImpl<T, true>
-{
- // Convert to int only if T doesn't have an overloaded operator<<.
- enum
- {
- value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
- };
-};
-
-// Write the content of w to os.
-void write(std::ostream &os, Writer &w);
-} // namespace internal
-
-// Formats a value.
-template <typename Char, typename ArgFormatter, typename T>
-void format_arg(BasicFormatter<Char, ArgFormatter> &f,
- const Char *&format_str, const T &value)
-{
- internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
-
- internal::FormatBuf<Char> format_buf(buffer);
- std::basic_ostream<Char> output(&format_buf);
- output << value;
-
- BasicStringRef<Char> str(&buffer[0], format_buf.size());
- typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
- format_str = f.format(format_str, MakeArg(str));
-}
-
-/**
-\rst
-Prints formatted data to the stream *os*.
-
-**Example**::
-
-print(cerr, "Don't {}!", "panic");
-\endrst
-*/
-FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
-FMT_VARIADIC(void, print, std::ostream &, CStringRef)
-} // namespace fmt
-
-#ifdef FMT_HEADER_ONLY
-# include "ostream.cc"
-#endif
-
-#endif // FMT_OSTREAM_H_
\ No newline at end of file
diff --git a/third_party/spdlog/include/spdlog/fmt/bundled/printf.h b/third_party/spdlog/include/spdlog/fmt/bundled/printf.h
deleted file mode 100644
index d12cf14c621472e06c2189b1e105396b5e124a1b..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/fmt/bundled/printf.h
+++ /dev/null
@@ -1,642 +0,0 @@
-/*
-Formatting library for C++
-
-Copyright (c) 2012 - 2016, Victor Zverovich
-All rights reserved.
-
-For the license information refer to format.h.
-*/
-
-#ifndef FMT_PRINTF_H_
-#define FMT_PRINTF_H_
-
-#include <algorithm> // std::fill_n
-#include <limits> // std::numeric_limits
-
-#include "ostream.h"
-
-namespace fmt
-{
-namespace internal
-{
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned>
-struct IntChecker
-{
- template <typename T>
- static bool fits_in_int(T value)
- {
- unsigned max = std::numeric_limits<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 >= std::numeric_limits<int>::min() &&
- value <= std::numeric_limits<int>::max();
- }
- static bool fits_in_int(int)
- {
- return true;
- }
-};
-
-class PrecisionHandler : public ArgVisitor<PrecisionHandler, int>
-{
-public:
- void report_unhandled_arg()
- {
- FMT_THROW(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(FormatError("number is too big"));
- return static_cast<int>(value);
- }
-};
-
-// IsZeroInt::visit(arg) returns true iff arg is a zero integer.
-class IsZeroInt : public ArgVisitor<IsZeroInt, bool>
-{
-public:
- template <typename T>
- bool visit_any_int(T value)
- {
- return value == 0;
- }
-};
-
-template <typename T, typename U>
-struct is_same
-{
- enum { value = 0 };
-};
-
-template <typename T>
-struct is_same<T, T>
-{
- enum { value = 1 };
-};
-
-// An argument visitor that converts an integer argument to T for printf,
-// if T is an integral type. If T is void, the argument is converted to
-// corresponding signed or unsigned type depending on the type specifier:
-// 'd' and 'i' - signed, other - unsigned)
-template <typename T = void>
-class ArgConverter : public ArgVisitor<ArgConverter<T>, void>
-{
-private:
- internal::Arg &arg_;
- wchar_t type_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
-
-public:
- ArgConverter(internal::Arg &arg, wchar_t type)
- : arg_(arg), type_(type) {}
-
- void visit_bool(bool value)
- {
- if (type_ != 's')
- visit_any_int(value);
- }
-
- template <typename U>
- void visit_any_int(U value)
- {
- bool is_signed = type_ == 'd' || type_ == 'i';
- using internal::Arg;
- typedef typename internal::Conditional<
- is_same<T, void>::value, U, T>::type TargetType;
- if (sizeof(TargetType) <= sizeof(int))
- {
- // Extra casts are used to silence warnings.
- if (is_signed)
- {
- arg_.type = Arg::INT;
- arg_.int_value = static_cast<int>(static_cast<TargetType>(value));
- }
- else
- {
- arg_.type = Arg::UINT;
- typedef typename internal::MakeUnsigned<TargetType>::Type Unsigned;
- arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));
- }
- }
- else
- {
- if (is_signed)
- {
- arg_.type = Arg::LONG_LONG;
- // glibc's printf doesn't sign extend arguments of smaller types:
- // std::printf("%lld", -42); // prints "4294967254"
- // but we don't have to do the same because it's a UB.
- arg_.long_long_value = static_cast<LongLong>(value);
- }
- else
- {
- arg_.type = Arg::ULONG_LONG;
- arg_.ulong_long_value =
- static_cast<typename internal::MakeUnsigned<U>::Type>(value);
- }
- }
- }
-};
-
-// Converts an integer argument to char for printf.
-class CharConverter : public ArgVisitor<CharConverter, void>
-{
-private:
- internal::Arg &arg_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
-
-public:
- explicit CharConverter(internal::Arg &arg) : arg_(arg) {}
-
- template <typename T>
- void visit_any_int(T value)
- {
- arg_.type = internal::Arg::CHAR;
- arg_.int_value = static_cast<char>(value);
- }
-};
-
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-class WidthHandler : public ArgVisitor<WidthHandler, unsigned>
-{
-private:
- FormatSpec &spec_;
-
- FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
-
-public:
- explicit WidthHandler(FormatSpec &spec) : spec_(spec) {}
-
- void report_unhandled_arg()
- {
- FMT_THROW(FormatError("width is not integer"));
- }
-
- template <typename T>
- unsigned visit_any_int(T value)
- {
- typedef typename internal::IntTraits<T>::MainType UnsignedType;
- UnsignedType width = static_cast<UnsignedType>(value);
- if (internal::is_negative(value))
- {
- spec_.align_ = ALIGN_LEFT;
- width = 0 - width;
- }
- unsigned int_max = std::numeric_limits<int>::max();
- if (width > int_max)
- FMT_THROW(FormatError("number is too big"));
- return static_cast<unsigned>(width);
- }
-};
-} // namespace internal
-
-/**
-\rst
-A ``printf`` argument formatter based on the `curiously recurring template
-pattern <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.
-
-To use `~fmt::BasicPrintfArgFormatter` define a subclass that implements some
-or all of the visit methods with the same signatures as the methods in
-`~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`.
-Pass the subclass as the *Impl* template parameter. When a formatting
-function processes an argument, it will dispatch to a visit method
-specific to the argument type. For example, if the argument type is
-``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
-will be called. If the subclass doesn't contain a method with this signature,
-then a corresponding method of `~fmt::BasicPrintfArgFormatter` or its
-superclass will be called.
-\endrst
-*/
-template <typename Impl, typename Char>
-class BasicPrintfArgFormatter : public internal::ArgFormatterBase<Impl, Char>
-{
-private:
- void write_null_pointer()
- {
- this->spec().type_ = 0;
- this->write("(nil)");
- }
-
- typedef internal::ArgFormatterBase<Impl, Char> Base;
-
-public:
- /**
- \rst
- Constructs an argument formatter object.
- *writer* is a reference to the output writer and *spec* contains format
- specifier information for standard argument types.
- \endrst
- */
- BasicPrintfArgFormatter(BasicWriter<Char> &writer, FormatSpec &spec)
- : internal::ArgFormatterBase<Impl, Char>(writer, spec) {}
-
- /** Formats an argument of type ``bool``. */
- void visit_bool(bool value)
- {
- FormatSpec &fmt_spec = this->spec();
- if (fmt_spec.type_ != 's')
- return this->visit_any_int(value);
- fmt_spec.type_ = 0;
- this->write(value);
- }
-
- /** Formats a character. */
- 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);
- }
-
- /** Formats a null-terminated C string. */
- void visit_cstring(const char *value)
- {
- if (value)
- Base::visit_cstring(value);
- else if (this->spec().type_ == 'p')
- write_null_pointer();
- else
- this->write("(null)");
- }
-
- /** Formats a pointer. */
- void visit_pointer(const void *value)
- {
- if (value)
- return Base::visit_pointer(value);
- this->spec().type_ = 0;
- write_null_pointer();
- }
-
- /** Formats an argument of a custom (user-defined) type. */
- void visit_custom(internal::Arg::CustomValue c)
- {
- BasicFormatter<Char> formatter(ArgList(), this->writer());
- const Char format_str[] = { '}', 0 };
- const Char *format = format_str;
- c.format(&formatter, c.value, &format);
- }
-};
-
-/** The default printf argument formatter. */
-template <typename Char>
-class PrintfArgFormatter
- : public BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char>
-{
-public:
- /** Constructs an argument formatter object. */
- PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
- : BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}
-};
-
-/** This template formats data and writes the output to a writer. */
-template <typename Char, typename ArgFormatter = PrintfArgFormatter<Char> >
-class PrintfFormatter : private internal::FormatterBase
-{
-private:
- BasicWriter<Char> &writer_;
-
- 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.
- internal::Arg get_arg(
- const Char *s,
- unsigned arg_index = (std::numeric_limits<unsigned>::max)());
-
- // Parses argument index, flags and width and returns the argument index.
- unsigned parse_header(const Char *&s, FormatSpec &spec);
-
-public:
- /**
- \rst
- Constructs a ``PrintfFormatter`` object. References to the arguments and
- the writer are stored in the formatter object so make sure they have
- appropriate lifetimes.
- \endrst
- */
- explicit PrintfFormatter(const ArgList &args, BasicWriter<Char> &w)
- : FormatterBase(args), writer_(w) {}
-
- /** Formats stored arguments and writes the output to the writer. */
- FMT_API void format(BasicCStringRef<Char> format_str);
-};
-
-template <typename Char, typename AF>
-void PrintfFormatter<Char, AF>::parse_flags(FormatSpec &spec, const Char *&s)
-{
- for (;;)
- {
- switch (*s++)
- {
- case '-':
- spec.align_ = ALIGN_LEFT;
- break;
- case '+':
- spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
- break;
- case '0':
- spec.fill_ = '0';
- break;
- case ' ':
- spec.flags_ |= SIGN_FLAG;
- break;
- case '#':
- spec.flags_ |= HASH_FLAG;
- break;
- default:
- --s;
- return;
- }
- }
-}
-
-template <typename Char, typename AF>
-internal::Arg PrintfFormatter<Char, AF>::get_arg(const Char *s,
- unsigned arg_index)
-{
- (void)s;
- const char *error = 0;
- internal::Arg arg = arg_index == std::numeric_limits<unsigned>::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, typename AF>
-unsigned PrintfFormatter<Char, AF>::parse_header(
- const Char *&s, FormatSpec &spec)
-{
- unsigned arg_index = std::numeric_limits<unsigned>::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 = internal::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_ = internal::parse_nonnegative_int(s);
- }
- else if (*s == '*')
- {
- ++s;
- spec.width_ = internal::WidthHandler(spec).visit(get_arg(s));
- }
- return arg_index;
-}
-
-template <typename Char, typename AF>
-void PrintfFormatter<Char, AF>::format(BasicCStringRef<Char> format_str)
-{
- const Char *start = format_str.c_str();
- const Char *s = start;
- while (*s)
- {
- Char c = *s++;
- if (c != '%') continue;
- if (*s == c)
- {
- write(writer_, start, s);
- start = ++s;
- continue;
- }
- write(writer_, start, s - 1);
-
- FormatSpec spec;
- spec.align_ = ALIGN_RIGHT;
-
- // Parse argument index, flags and width.
- unsigned arg_index = parse_header(s, spec);
-
- // Parse precision.
- if (*s == '.')
- {
- ++s;
- if ('0' <= *s && *s <= '9')
- {
- spec.precision_ = static_cast<int>(internal::parse_nonnegative_int(s));
- }
- else if (*s == '*')
- {
- ++s;
- spec.precision_ = internal::PrecisionHandler().visit(get_arg(s));
- }
- }
-
- using internal::Arg;
- Arg arg = get_arg(s, arg_index);
- if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg))
- spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
- if (spec.fill_ == '0')
- {
- if (arg.type <= Arg::LAST_NUMERIC_TYPE)
- spec.align_ = ALIGN_NUMERIC;
- else
- spec.fill_ = ' '; // Ignore '0' flag for non-numeric types.
- }
-
- // Parse length and convert the argument to the required type.
- using internal::ArgConverter;
- switch (*s++)
- {
- case 'h':
- if (*s == 'h')
- ArgConverter<signed char>(arg, *++s).visit(arg);
- else
- ArgConverter<short>(arg, *s).visit(arg);
- break;
- case 'l':
- if (*s == 'l')
- ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
- else
- ArgConverter<long>(arg, *s).visit(arg);
- break;
- case 'j':
- ArgConverter<intmax_t>(arg, *s).visit(arg);
- break;
- case 'z':
- ArgConverter<std::size_t>(arg, *s).visit(arg);
- break;
- case 't':
- ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
- break;
- case 'L':
- // printf produces garbage when 'L' is omitted for long double, no
- // need to do the same.
- break;
- default:
- --s;
- ArgConverter<void>(arg, *s).visit(arg);
- }
-
- // Parse type.
- if (!*s)
- FMT_THROW(FormatError("invalid format string"));
- spec.type_ = static_cast<char>(*s++);
- if (arg.type <= Arg::LAST_INTEGER_TYPE)
- {
- // Normalize type.
- switch (spec.type_)
- {
- case 'i':
- case 'u':
- spec.type_ = 'd';
- break;
- case 'c':
- // TODO: handle wchar_t
- internal::CharConverter(arg).visit(arg);
- break;
- }
- }
-
- start = s;
-
- // Format argument.
- AF(writer_, spec).visit(arg);
- }
- write(writer_, start, s);
-}
-
-template <typename Char>
-void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args)
-{
- PrintfFormatter<Char>(args, w).format(format);
-}
-
-/**
-\rst
-Formats arguments and returns the result as a string.
-
-**Example**::
-
-std::string message = fmt::sprintf("The answer is %d", 42);
-\endrst
-*/
-inline std::string sprintf(CStringRef format, ArgList args)
-{
- MemoryWriter w;
- printf(w, format, args);
- return w.str();
-}
-FMT_VARIADIC(std::string, sprintf, CStringRef)
-
-inline std::wstring sprintf(WCStringRef format, ArgList args)
-{
- WMemoryWriter w;
- printf(w, format, args);
- return w.str();
-}
-FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)
-
-/**
-\rst
-Prints formatted data to the file *f*.
-
-**Example**::
-
-fmt::fprintf(stderr, "Don't %s!", "panic");
-\endrst
-*/
-FMT_API int fprintf(std::FILE *f, CStringRef format, ArgList args);
-FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
-
-/**
-\rst
-Prints formatted data to ``stdout``.
-
-**Example**::
-
-fmt::printf("Elapsed time: %.2f seconds", 1.23);
-\endrst
-*/
-inline int printf(CStringRef format, ArgList args)
-{
- return fprintf(stdout, format, args);
-}
-FMT_VARIADIC(int, printf, CStringRef)
-
-/**
-\rst
-Prints formatted data to the stream *os*.
-
-**Example**::
-
-fprintf(cerr, "Don't %s!", "panic");
-\endrst
-*/
-inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args)
-{
- MemoryWriter w;
- printf(w, format_str, args);
- internal::write(os, w);
- return static_cast<int>(w.size());
-}
-FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
-} // namespace fmt
-
-#endif // FMT_PRINTF_H_
\ No newline at end of file
diff --git a/third_party/spdlog/include/spdlog/fmt/fmt.h b/third_party/spdlog/include/spdlog/fmt/fmt.h
deleted file mode 100644
index dd035fd294b9e34e00083de5330849505415adb3..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/fmt/fmt.h
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// Copyright(c) 2016 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-//
-// Include a bundled header-only copy of fmtlib or an external one.
-// By default spdlog include its own copy.
-//
-
-#if !defined(SPDLOG_FMT_EXTERNAL)
-
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#ifndef FMT_USE_WINDOWS_H
-#define FMT_USE_WINDOWS_H 0
-#endif
-#include <spdlog/fmt/bundled/format.h>
-
-#else //external fmtlib
-
-#include <fmt/format.h>
-
-#endif
-
diff --git a/third_party/spdlog/include/spdlog/fmt/ostr.h b/third_party/spdlog/include/spdlog/fmt/ostr.h
deleted file mode 100644
index 7a6518654785a1ada24d87b62a841737a4fb3c05..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/fmt/ostr.h
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// Copyright(c) 2016 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// include external or bundled copy of fmtlib's ostream support
-//
-#if !defined(SPDLOG_FMT_EXTERNAL)
-#include <spdlog/fmt/fmt.h>
-#include <spdlog/fmt/bundled/ostream.h>
-#else
-#include <fmt/ostream.h>
-#endif
-
-
diff --git a/third_party/spdlog/include/spdlog/formatter.h b/third_party/spdlog/include/spdlog/formatter.h
deleted file mode 100644
index 0ffcec03e05856215227bd5e388aa5adafa6e2e0..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/formatter.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/details/log_msg.h>
-
-#include <vector>
-#include <string>
-#include <memory>
-
-namespace spdlog
-{
-namespace details
-{
-class flag_formatter;
-}
-
-class formatter
-{
-public:
- virtual ~formatter() {}
- virtual void format(details::log_msg& msg) = 0;
-};
-
-class pattern_formatter : public formatter
-{
-
-public:
- explicit pattern_formatter(const std::string& pattern);
- pattern_formatter(const pattern_formatter&) = delete;
- pattern_formatter& operator=(const pattern_formatter&) = delete;
- void format(details::log_msg& msg) override;
-private:
- const std::string _pattern;
- std::vector<std::unique_ptr<details::flag_formatter>> _formatters;
- void handle_flag(char flag);
- void compile_pattern(const std::string& pattern);
-};
-}
-
-#include <spdlog/details/pattern_formatter_impl.h>
-
diff --git a/third_party/spdlog/include/spdlog/logger.h b/third_party/spdlog/include/spdlog/logger.h
deleted file mode 100644
index ca0b4b2d646d73166bf773b5d0b7e08e1ea215c1..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/logger.h
+++ /dev/null
@@ -1,94 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Thread safe logger
-// Has name, log level, vector of std::shared sink pointers and formatter
-// Upon each log write the logger:
-// 1. Checks if its log level is enough to log the message
-// 2. Format the message using the formatter function
-// 3. Pass the formatted message to its sinks to performa the actual logging
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/common.h>
-
-#include <vector>
-#include <memory>
-#include <string>
-
-namespace spdlog
-{
-
-class logger
-{
-public:
- logger(const std::string& logger_name, sink_ptr single_sink);
- logger(const std::string& name, sinks_init_list);
- template<class It>
- logger(const std::string& name, const It& begin, const It& end);
-
- virtual ~logger();
- logger(const logger&) = delete;
- logger& operator=(const logger&) = delete;
-
-
- template <typename... Args> void log(level::level_enum lvl, const char* fmt, const Args&... args);
- template <typename... Args> void log(level::level_enum lvl, const char* msg);
- template <typename... Args> void trace(const char* fmt, const Args&... args);
- template <typename... Args> void debug(const char* fmt, const Args&... args);
- template <typename... Args> void info(const char* fmt, const Args&... args);
- template <typename... Args> void warn(const char* fmt, const Args&... args);
- template <typename... Args> void error(const char* fmt, const Args&... args);
- template <typename... Args> void critical(const char* fmt, const Args&... args);
-
- template <typename T> void log(level::level_enum lvl, const T&);
- template <typename T> void trace(const T&);
- template <typename T> void debug(const T&);
- template <typename T> void info(const T&);
- template <typename T> void warn(const T&);
- template <typename T> void error(const T&);
- template <typename T> void critical(const T&);
-
- bool should_log(level::level_enum) const;
- void set_level(level::level_enum);
- level::level_enum level() const;
- const std::string& name() const;
- void set_pattern(const std::string&);
- void set_formatter(formatter_ptr);
-
- // error handler
- void set_error_handler(log_err_handler);
- log_err_handler error_handler();
-
- // automatically call flush() if message level >= log_level
- void flush_on(level::level_enum log_level);
-
- virtual void flush();
-
- const std::vector<sink_ptr>& sinks() const;
-
-protected:
- virtual void _sink_it(details::log_msg&);
- virtual void _set_pattern(const std::string&);
- virtual void _set_formatter(formatter_ptr);
-
- // default error handler: print the error to stderr with the max rate of 1 message/minute
- virtual void _default_err_handler(const std::string &msg);
-
- // return true if the given message level should trigger a flush
- bool _should_flush_on(const details::log_msg&);
-
- const std::string _name;
- std::vector<sink_ptr> _sinks;
- formatter_ptr _formatter;
- spdlog::level_t _level;
- spdlog::level_t _flush_level;
- log_err_handler _err_handler;
- std::atomic<time_t> _last_err_time;
-};
-}
-
-#include <spdlog/details/logger_impl.h>
diff --git a/third_party/spdlog/include/spdlog/sinks/android_sink.h b/third_party/spdlog/include/spdlog/sinks/android_sink.h
deleted file mode 100644
index d8c97e03b31bba2496a10ab1b4b34e44cb7d9c5e..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/android_sink.h
+++ /dev/null
@@ -1,75 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#if defined(__ANDROID__)
-
-#include <spdlog/sinks/sink.h>
-
-#include <mutex>
-#include <string>
-#include <android/log.h>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-/*
-* Android sink (logging using __android_log_write)
-* __android_log_write is thread-safe. No lock is needed.
-*/
-class android_sink : public sink
-{
-public:
- explicit android_sink(const std::string& tag = "spdlog"): _tag(tag) {}
-
- void log(const details::log_msg& msg) override
- {
- const android_LogPriority priority = convert_to_android(msg.level);
- // See system/core/liblog/logger_write.c for explanation of return value
- const int ret = __android_log_write(
- priority, _tag.c_str(), msg.formatted.c_str()
- );
- if (ret < 0)
- {
- throw spdlog_ex("__android_log_write() failed", ret);
- }
- }
-
- void flush() override
- {
- }
-
-private:
- static android_LogPriority convert_to_android(spdlog::level::level_enum level)
- {
- switch(level)
- {
- case spdlog::level::trace:
- return ANDROID_LOG_VERBOSE;
- case spdlog::level::debug:
- return ANDROID_LOG_DEBUG;
- case spdlog::level::info:
- return ANDROID_LOG_INFO;
- case spdlog::level::warn:
- return ANDROID_LOG_WARN;
- case spdlog::level::err:
- return ANDROID_LOG_ERROR;
- case spdlog::level::critical:
- return ANDROID_LOG_FATAL;
- default:
- return ANDROID_LOG_DEFAULT;
- }
- }
-
- std::string _tag;
-};
-
-}
-}
-
-#endif
diff --git a/third_party/spdlog/include/spdlog/sinks/ansicolor_sink.h b/third_party/spdlog/include/spdlog/sinks/ansicolor_sink.h
deleted file mode 100644
index cd9b4057f1df498ac66bbf01a87ee86f5548778d..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/ansicolor_sink.h
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-// Copyright(c) 2016 Kevin M. Godby (a modified version by spdlog).
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/common.h>
-
-#include <string>
-#include <map>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-/**
- * @brief The ansi_color_sink is a decorator around another sink and prefixes
- * the output with an ANSI escape sequence color code depending on the severity
- * of the message.
- */
-class ansicolor_sink : public sink
-{
-public:
- ansicolor_sink(sink_ptr wrapped_sink);
- virtual ~ansicolor_sink();
-
- ansicolor_sink(const ansicolor_sink& other) = delete;
- ansicolor_sink& operator=(const ansicolor_sink& other) = delete;
-
- virtual void log(const details::log_msg& msg) override;
- virtual void flush() override;
-
- void set_color(level::level_enum color_level, const std::string& color);
-
- /// Formatting codes
- const std::string reset = "\033[00m";
- const std::string bold = "\033[1m";
- const std::string dark = "\033[2m";
- const std::string underline = "\033[4m";
- const std::string blink = "\033[5m";
- const std::string reverse = "\033[7m";
- const std::string concealed = "\033[8m";
-
- // Foreground colors
- const std::string grey = "\033[30m";
- const std::string red = "\033[31m";
- const std::string green = "\033[32m";
- const std::string yellow = "\033[33m";
- const std::string blue = "\033[34m";
- const std::string magenta = "\033[35m";
- const std::string cyan = "\033[36m";
- const std::string white = "\033[37m";
-
- /// Background colors
- const std::string on_grey = "\033[40m";
- const std::string on_red = "\033[41m";
- const std::string on_green = "\033[42m";
- const std::string on_yellow = "\033[43m";
- const std::string on_blue = "\033[44m";
- const std::string on_magenta = "\033[45m";
- const std::string on_cyan = "\033[46m";
- const std::string on_white = "\033[47m";
-
-
-protected:
- sink_ptr sink_;
- std::map<level::level_enum, std::string> colors_;
-};
-
-inline ansicolor_sink::ansicolor_sink(sink_ptr wrapped_sink) : sink_(wrapped_sink)
-{
- colors_[level::trace] = green + bold;
- colors_[level::debug] = cyan;
- colors_[level::info] = bold;
- colors_[level::warn] = yellow + bold;
- colors_[level::err] = red + bold;
- colors_[level::critical] = bold + on_red;
- colors_[level::off] = reset;
-}
-
-inline void ansicolor_sink::log(const details::log_msg& msg)
-{
- // Wrap the originally formatted message in color codes
- const std::string& prefix = colors_[msg.level];
- const std::string& s = msg.formatted.str();
- const std::string& suffix = reset;
- details::log_msg m;
- m.level = msg.level;
- m.logger_name = msg.logger_name;
- m.time = msg.time;
- m.thread_id = msg.thread_id;
- m.formatted << prefix << s << suffix;
- sink_->log(m);
-}
-
-inline void ansicolor_sink::flush()
-{
- sink_->flush();
-}
-
-inline void ansicolor_sink::set_color(level::level_enum color_level, const std::string& color)
-{
- colors_[color_level] = color;
-}
-
-inline ansicolor_sink::~ansicolor_sink()
-{
- flush();
-}
-
-} // namespace sinks
-} // namespace spdlog
-
diff --git a/third_party/spdlog/include/spdlog/sinks/base_sink.h b/third_party/spdlog/include/spdlog/sinks/base_sink.h
deleted file mode 100644
index 7f1a31dbd0cb030c76c6101dcea083e337f9d97d..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/base_sink.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-//
-// base sink templated over a mutex (either dummy or realy)
-// concrete implementation should only overrid the _sink_it method.
-// all locking is taken care of here so no locking needed by the implementers..
-//
-
-#include <spdlog/sinks/sink.h>
-#include <spdlog/formatter.h>
-#include <spdlog/common.h>
-#include <spdlog/details/log_msg.h>
-
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class base_sink:public sink
-{
-public:
- base_sink():_mutex() {}
- virtual ~base_sink() = default;
-
- base_sink(const base_sink&) = delete;
- base_sink& operator=(const base_sink&) = delete;
-
- void log(const details::log_msg& msg) override
- {
- std::lock_guard<Mutex> lock(_mutex);
- _sink_it(msg);
- }
-
-protected:
- virtual void _sink_it(const details::log_msg& msg) = 0;
- Mutex _mutex;
-};
-}
-}
diff --git a/third_party/spdlog/include/spdlog/sinks/dist_sink.h b/third_party/spdlog/include/spdlog/sinks/dist_sink.h
deleted file mode 100644
index cef08bfb4062c4f1631083962d325be60a5a17d8..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/dist_sink.h
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// Copyright (c) 2015 David Schury, Gabi Melman
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/details/log_msg.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/sinks/sink.h>
-
-#include <algorithm>
-#include <mutex>
-#include <memory>
-#include <vector>
-
-// Distribution sink (mux). Stores a vector of sinks which get called when log is called
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class dist_sink: public base_sink<Mutex>
-{
-public:
- explicit dist_sink() :_sinks() {}
- dist_sink(const dist_sink&) = delete;
- dist_sink& operator=(const dist_sink&) = delete;
- virtual ~dist_sink() = default;
-
-protected:
- std::vector<std::shared_ptr<sink>> _sinks;
-
- void _sink_it(const details::log_msg& msg) override
- {
- for (auto &sink : _sinks)
- {
- if( sink->should_log( msg.level))
- {
- sink->log(msg);
- }
- }
- }
-
-public:
- void flush() override
- {
- std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
- for (auto &sink : _sinks)
- sink->flush();
- }
-
- void add_sink(std::shared_ptr<sink> sink)
- {
- std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
- _sinks.push_back(sink);
- }
-
- void remove_sink(std::shared_ptr<sink> sink)
- {
- std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
- _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), sink), _sinks.end());
- }
-};
-
-typedef dist_sink<std::mutex> dist_sink_mt;
-typedef dist_sink<details::null_mutex> dist_sink_st;
-}
-}
diff --git a/third_party/spdlog/include/spdlog/sinks/file_sinks.h b/third_party/spdlog/include/spdlog/sinks/file_sinks.h
deleted file mode 100644
index d40499b6679ddf8b9cd4577375e85e957fa55e2f..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/file_sinks.h
+++ /dev/null
@@ -1,244 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/details/file_helper.h>
-#include <spdlog/fmt/fmt.h>
-
-#include <algorithm>
-#include <chrono>
-#include <cstdio>
-#include <ctime>
-#include <mutex>
-#include <string>
-#include <cerrno>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
- * Trivial file sink with single file as target
- */
-template<class Mutex>
-class simple_file_sink : public base_sink < Mutex >
-{
-public:
- explicit simple_file_sink(const filename_t &filename, bool truncate = false):_force_flush(false)
- {
- _file_helper.open(filename, truncate);
- }
- void flush() override
- {
- _file_helper.flush();
- }
- void set_force_flush(bool force_flush)
- {
- _force_flush = force_flush;
- }
-
-protected:
- void _sink_it(const details::log_msg& msg) override
- {
- _file_helper.write(msg);
- if(_force_flush)
- _file_helper.flush();
- }
-private:
- details::file_helper _file_helper;
- bool _force_flush;
-};
-
-typedef simple_file_sink<std::mutex> simple_file_sink_mt;
-typedef simple_file_sink<details::null_mutex> simple_file_sink_st;
-
-/*
- * Rotating file sink based on size
- */
-template<class Mutex>
-class rotating_file_sink : public base_sink < Mutex >
-{
-public:
- rotating_file_sink(const filename_t &base_filename, const filename_t &extension,
- std::size_t max_size, std::size_t max_files ) :
- _base_filename(base_filename),
- _extension(extension),
- _max_size(max_size),
- _max_files(max_files),
- _current_size(0),
- _file_helper()
- {
- _file_helper.open(calc_filename(_base_filename, 0, _extension));
- _current_size = _file_helper.size(); //expensive. called only once
- }
-
- void flush() override
- {
- _file_helper.flush();
- }
-
-protected:
- void _sink_it(const details::log_msg& msg) override
- {
- _current_size += msg.formatted.size();
- if (_current_size > _max_size)
- {
- _rotate();
- _current_size = msg.formatted.size();
- }
- _file_helper.write(msg);
- }
-
-private:
- static filename_t calc_filename(const filename_t& filename, std::size_t index, const filename_t& extension)
- {
- std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
- if (index)
- w.write(SPDLOG_FILENAME_T("{}.{}.{}"), filename, index, extension);
- else
- w.write(SPDLOG_FILENAME_T("{}.{}"), filename, extension);
- return w.str();
- }
-
- // Rotate files:
- // log.txt -> log.1.txt
- // log.1.txt -> log2.txt
- // log.2.txt -> log3.txt
- // log.3.txt -> delete
-
- void _rotate()
- {
- using details::os::filename_to_str;
- _file_helper.close();
- for (auto i = _max_files; i > 0; --i)
- {
- filename_t src = calc_filename(_base_filename, i - 1, _extension);
- filename_t target = calc_filename(_base_filename, i, _extension);
-
- if (details::file_helper::file_exists(target))
- {
- if (details::os::remove(target) != 0)
- {
- throw spdlog_ex("rotating_file_sink: failed removing " + filename_to_str(target), errno);
- }
- }
- if (details::file_helper::file_exists(src) && details::os::rename(src, target))
- {
- throw spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
- }
- }
- _file_helper.reopen(true);
- }
- filename_t _base_filename;
- filename_t _extension;
- std::size_t _max_size;
- std::size_t _max_files;
- std::size_t _current_size;
- details::file_helper _file_helper;
-};
-
-typedef rotating_file_sink<std::mutex> rotating_file_sink_mt;
-typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;
-
-/*
- * Default generator of daily log file names.
- */
-struct default_daily_file_name_calculator
-{
- // Create filename for the form basename.YYYY-MM-DD_hh-mm.extension
- static filename_t calc_filename(const filename_t& basename, const filename_t& extension)
- {
- std::tm tm = spdlog::details::os::localtime();
- std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
- w.write(SPDLOG_FILENAME_T("{}_{: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();
- }
-};
-
-/*
- * Generator of daily log file names in format basename.YYYY-MM-DD.extension
- */
-struct dateonly_daily_file_name_calculator
-{
- // Create filename for the form basename.YYYY-MM-DD.extension
- static filename_t calc_filename(const filename_t& basename, const filename_t& extension)
- {
- std::tm tm = spdlog::details::os::localtime();
- std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
- w.write(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}.{}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, extension);
- return w.str();
- }
-};
-
-/*
- * Rotating file sink based on date. rotates at midnight
- */
-template<class Mutex, class FileNameCalc = default_daily_file_name_calculator>
-class daily_file_sink :public base_sink < Mutex >
-{
-public:
- //create daily file sink which rotates on given time
- daily_file_sink(
- const filename_t& base_filename,
- const filename_t& extension,
- int rotation_hour,
- int rotation_minute) : _base_filename(base_filename),
- _extension(extension),
- _rotation_h(rotation_hour),
- _rotation_m(rotation_minute)
- {
- if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
- throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
- _rotation_tp = _next_rotation_tp();
- _file_helper.open(FileNameCalc::calc_filename(_base_filename, _extension));
- }
-
- void flush() override
- {
- _file_helper.flush();
- }
-
-protected:
- void _sink_it(const details::log_msg& msg) override
- {
- if (std::chrono::system_clock::now() >= _rotation_tp)
- {
- _file_helper.open(FileNameCalc::calc_filename(_base_filename, _extension));
- _rotation_tp = _next_rotation_tp();
- }
- _file_helper.write(msg);
- }
-
-private:
- std::chrono::system_clock::time_point _next_rotation_tp()
- {
- auto now = std::chrono::system_clock::now();
- time_t tnow = std::chrono::system_clock::to_time_t(now);
- tm date = spdlog::details::os::localtime(tnow);
- date.tm_hour = _rotation_h;
- date.tm_min = _rotation_m;
- date.tm_sec = 0;
- auto rotation_time = std::chrono::system_clock::from_time_t(std::mktime(&date));
- if (rotation_time > now)
- return rotation_time;
- else
- return std::chrono::system_clock::time_point(rotation_time + std::chrono::hours(24));
- }
-
- filename_t _base_filename;
- filename_t _extension;
- int _rotation_h;
- int _rotation_m;
- std::chrono::system_clock::time_point _rotation_tp;
- details::file_helper _file_helper;
-};
-
-typedef daily_file_sink<std::mutex> daily_file_sink_mt;
-typedef daily_file_sink<details::null_mutex> daily_file_sink_st;
-}
-}
diff --git a/third_party/spdlog/include/spdlog/sinks/msvc_sink.h b/third_party/spdlog/include/spdlog/sinks/msvc_sink.h
deleted file mode 100644
index 16342ca26435c8aab8dce40a241995f1ea986762..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/msvc_sink.h
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// Copyright(c) 2016 Alexander Dalshov.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#if defined(_MSC_VER)
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-
-#include <WinBase.h>
-
-#include <mutex>
-#include <string>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
-* MSVC sink (logging using OutputDebugStringA)
-*/
-template<class Mutex>
-class msvc_sink : public base_sink < Mutex >
-{
-public:
- explicit msvc_sink()
- {
- }
-
- void flush() override
- {
- }
-
-protected:
- void _sink_it(const details::log_msg& msg) override
- {
- OutputDebugStringA(msg.formatted.c_str());
- }
-};
-
-typedef msvc_sink<std::mutex> msvc_sink_mt;
-typedef msvc_sink<details::null_mutex> msvc_sink_st;
-
-}
-}
-
-#endif
diff --git a/third_party/spdlog/include/spdlog/sinks/null_sink.h b/third_party/spdlog/include/spdlog/sinks/null_sink.h
deleted file mode 100644
index 68bd9c94da13591b5bd596c5c7a1c8f2ff9fb56f..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/null_sink.h
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-template <class Mutex>
-class null_sink : public base_sink < Mutex >
-{
-protected:
- void _sink_it(const details::log_msg&) override
- {}
-
- void flush() override
- {}
-
-};
-typedef null_sink<details::null_mutex> null_sink_st;
-typedef null_sink<std::mutex> null_sink_mt;
-
-}
-}
-
diff --git a/third_party/spdlog/include/spdlog/sinks/ostream_sink.h b/third_party/spdlog/include/spdlog/sinks/ostream_sink.h
deleted file mode 100644
index feb5efa18dd17e91b3add638a30bccd6112f49e9..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/ostream_sink.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/sinks/base_sink.h>
-
-#include <ostream>
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class ostream_sink: public base_sink<Mutex>
-{
-public:
- explicit ostream_sink(std::ostream& os, bool force_flush=false) :_ostream(os), _force_flush(force_flush) {}
- ostream_sink(const ostream_sink&) = delete;
- ostream_sink& operator=(const ostream_sink&) = delete;
- virtual ~ostream_sink() = default;
-
-protected:
- void _sink_it(const details::log_msg& msg) override
- {
- _ostream.write(msg.formatted.data(), msg.formatted.size());
- if (_force_flush)
- _ostream.flush();
- }
-
- void flush() override
- {
- _ostream.flush();
- }
-
- std::ostream& _ostream;
- bool _force_flush;
-};
-
-typedef ostream_sink<std::mutex> ostream_sink_mt;
-typedef ostream_sink<details::null_mutex> ostream_sink_st;
-}
-}
diff --git a/third_party/spdlog/include/spdlog/sinks/sink.h b/third_party/spdlog/include/spdlog/sinks/sink.h
deleted file mode 100644
index d27fdbe0ef7157b9de9e387f32657e121272aa57..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/sink.h
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-
-#pragma once
-
-#include <spdlog/details/log_msg.h>
-
-namespace spdlog
-{
-namespace sinks
-{
-class sink
-{
-public:
- sink(): _level( level::trace ) {}
-
- virtual ~sink() {}
- virtual void log(const details::log_msg& msg) = 0;
- virtual void flush() = 0;
-
- bool should_log(level::level_enum msg_level) const;
- void set_level(level::level_enum log_level);
- level::level_enum level() const;
-
-private:
- level_t _level;
-
-};
-
-inline bool sink::should_log(level::level_enum msg_level) const
-{
- return msg_level >= _level.load(std::memory_order_relaxed);
-}
-
-inline void sink::set_level(level::level_enum log_level)
-{
- _level.store(log_level);
-}
-
-inline level::level_enum sink::level() const
-{
- return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
-}
-
-}
-}
-
diff --git a/third_party/spdlog/include/spdlog/sinks/stdout_sinks.h b/third_party/spdlog/include/spdlog/sinks/stdout_sinks.h
deleted file mode 100644
index c05f80dd12846713f751d53fbb55ee3817ad6024..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/stdout_sinks.h
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/sinks/base_sink.h>
-
-#include <cstdio>
-#include <memory>
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-template <class Mutex>
-class stdout_sink: public base_sink<Mutex>
-{
- using MyType = stdout_sink<Mutex>;
-public:
- stdout_sink()
- {}
- static std::shared_ptr<MyType> instance()
- {
- static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
- return instance;
- }
-
- void _sink_it(const details::log_msg& msg) override
- {
- fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stdout);
- flush();
- }
-
- void flush() override
- {
- fflush(stdout);
- }
-};
-
-typedef stdout_sink<details::null_mutex> stdout_sink_st;
-typedef stdout_sink<std::mutex> stdout_sink_mt;
-
-
-template <class Mutex>
-class stderr_sink: public base_sink<Mutex>
-{
- using MyType = stderr_sink<Mutex>;
-public:
- stderr_sink()
- {}
- static std::shared_ptr<MyType> instance()
- {
- static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
- return instance;
- }
-
- void _sink_it(const details::log_msg& msg) override
- {
- fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stderr);
- flush();
- }
-
- void flush() override
- {
- fflush(stderr);
- }
-};
-
-typedef stderr_sink<std::mutex> stderr_sink_mt;
-typedef stderr_sink<details::null_mutex> stderr_sink_st;
-}
-}
diff --git a/third_party/spdlog/include/spdlog/sinks/syslog_sink.h b/third_party/spdlog/include/spdlog/sinks/syslog_sink.h
deleted file mode 100644
index 0d8633c5e72a1dd8bdd63e5f490071abd8b8d4be..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/syslog_sink.h
+++ /dev/null
@@ -1,81 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/common.h>
-
-#ifdef SPDLOG_ENABLE_SYSLOG
-
-#include <spdlog/sinks/sink.h>
-#include <spdlog/details/log_msg.h>
-
-#include <array>
-#include <string>
-#include <syslog.h>
-
-
-namespace spdlog
-{
-namespace sinks
-{
-/**
- * Sink that write to syslog using the `syscall()` library call.
- *
- * Locking is not needed, as `syslog()` itself is thread-safe.
- */
-class syslog_sink : public sink
-{
-public:
- //
- syslog_sink(const std::string& ident = "", int syslog_option=0, int syslog_facility=LOG_USER):
- _ident(ident)
- {
- _priorities[static_cast<int>(level::trace)] = LOG_DEBUG;
- _priorities[static_cast<int>(level::debug)] = LOG_DEBUG;
- _priorities[static_cast<int>(level::info)] = LOG_INFO;
- _priorities[static_cast<int>(level::warn)] = LOG_WARNING;
- _priorities[static_cast<int>(level::err)] = LOG_ERR;
- _priorities[static_cast<int>(level::critical)] = LOG_CRIT;
- _priorities[static_cast<int>(level::off)] = LOG_INFO;
-
- //set ident to be program name if empty
- ::openlog(_ident.empty()? nullptr:_ident.c_str(), syslog_option, syslog_facility);
- }
- ~syslog_sink()
- {
- ::closelog();
- }
-
- syslog_sink(const syslog_sink&) = delete;
- syslog_sink& operator=(const syslog_sink&) = delete;
-
- void log(const details::log_msg &msg) override
- {
- ::syslog(syslog_prio_from_level(msg), "%s", msg.raw.str().c_str());
- }
-
- void flush() override
- {
- }
-
-
-private:
- std::array<int, 7> _priorities;
- //must store the ident because the man says openlog might use the pointer as is and not a string copy
- const std::string _ident;
-
- //
- // Simply maps spdlog's log level to syslog priority level.
- //
- int syslog_prio_from_level(const details::log_msg &msg) const
- {
- return _priorities[static_cast<int>(msg.level)];
- }
-};
-}
-}
-
-#endif
diff --git a/third_party/spdlog/include/spdlog/sinks/wincolor_sink.h b/third_party/spdlog/include/spdlog/sinks/wincolor_sink.h
deleted file mode 100644
index 5555d80188febd0a9a0ad933d4e12e1f0708c67a..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/sinks/wincolor_sink.h
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-// Copyright(c) 2016 spdlog
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/common.h>
-
-#include <mutex>
-#include <string>
-#include <map>
-#include <wincon.h>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
- * Windows color console sink. Uses WriteConsoleA to write to the console with colors
- */
-template<class Mutex>
-class wincolor_sink: public base_sink<Mutex>
-{
-public:
- const WORD BOLD = FOREGROUND_INTENSITY;
- const WORD RED = FOREGROUND_RED;
- const WORD CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE;
- const WORD WHITE = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
- const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN;
-
- wincolor_sink(HANDLE std_handle): out_handle_(std_handle)
- {
- colors_[level::trace] = CYAN;
- colors_[level::debug] = CYAN;
- colors_[level::info] = WHITE | BOLD;
- colors_[level::warn] = YELLOW | BOLD;
- colors_[level::err] = RED | BOLD; // red bold
- colors_[level::critical] = BACKGROUND_RED | WHITE | BOLD; // white bold on red background
- colors_[level::off] = 0;
- }
-
- virtual ~wincolor_sink()
- {
- flush();
- }
-
- wincolor_sink(const wincolor_sink& other) = delete;
- wincolor_sink& operator=(const wincolor_sink& other) = delete;
-
- virtual void _sink_it(const details::log_msg& msg) override
- {
- auto color = colors_[msg.level];
- auto orig_attribs = set_console_attribs(color);
- WriteConsoleA(out_handle_, msg.formatted.data(), static_cast<DWORD>(msg.formatted.size()), nullptr, nullptr);
- SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors
- }
-
- virtual void flush() override
- {
- // windows console always flushed?
- }
-
- // change the color for the given level
- void set_color(level::level_enum level, WORD color)
- {
- std::lock_guard<Mutex> lock(_mutex);
- colors_[level] = color;
- }
-
-private:
- HANDLE out_handle_;
- std::map<level::level_enum, WORD> colors_;
-
- // set color and return the orig console attributes (for resetting later)
- WORD set_console_attribs(WORD attribs)
- {
- CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
- GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info);
- SetConsoleTextAttribute(out_handle_, attribs);
- return orig_buffer_info.wAttributes; //return orig attribs
- }
-};
-
-//
-// windows color console to stdout
-//
-template<class Mutex>
-class wincolor_stdout_sink: public wincolor_sink<Mutex>
-{
-public:
- wincolor_stdout_sink():wincolor_sink(GetStdHandle(STD_OUTPUT_HANDLE))
- {}
-};
-
-typedef wincolor_stdout_sink<std::mutex> wincolor_stdout_sink_mt;
-typedef wincolor_stdout_sink<details::null_mutex> wincolor_stdout_sink_st;
-
-//
-// windows color console to stderr
-//
-template<class Mutex>
-class wincolor_stderr_sink: public wincolor_sink<Mutex>
-{
-public:
- wincolor_stderr_sink():wincolor_sink(GetStdHandle(STD_ERROR_HANDLE))
- {}
-};
-
-typedef wincolor_stderr_sink<std::mutex> wincolor_stderr_sink_mt;
-typedef wincolor_stderr_sink<details::null_mutex> wincolor_stderr_sink_st;
-
-}
-}
diff --git a/third_party/spdlog/include/spdlog/spdlog.h b/third_party/spdlog/include/spdlog/spdlog.h
deleted file mode 100644
index b4bfc84efcf08034385d593099513fa4a35db7d8..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/spdlog.h
+++ /dev/null
@@ -1,177 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-// spdlog main header file.
-// see example.cpp for usage example
-
-#pragma once
-
-#include <spdlog/tweakme.h>
-#include <spdlog/common.h>
-#include <spdlog/logger.h>
-
-#include <memory>
-#include <functional>
-#include <chrono>
-#include <string>
-
-namespace spdlog
-{
-
-//
-// Return an existing logger or nullptr if a logger with such name doesn't exist.
-// example: spdlog::get("my_logger")->info("hello {}", "world");
-//
-std::shared_ptr<logger> get(const std::string& name);
-
-
-//
-// Set global formatting
-// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
-//
-void set_pattern(const std::string& format_string);
-void set_formatter(formatter_ptr f);
-
-//
-// Set global logging level for
-//
-void set_level(level::level_enum log_level);
-
-//
-// Set global error handler
-//
-void set_error_handler(log_err_handler);
-
-//
-// Turn on async mode (off by default) and set the queue size for each async_logger.
-// effective only for loggers created after this call.
-// queue_size: size of queue (must be power of 2):
-// Each logger will pre-allocate a dedicated queue with queue_size entries upon construction.
-//
-// async_overflow_policy (optional, block_retry by default):
-// async_overflow_policy::block_retry - if queue is full, block until queue has room for the new log entry.
-// async_overflow_policy::discard_log_msg - never block and discard any new messages when queue overflows.
-//
-// worker_warmup_cb (optional):
-// callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity)
-//
-// worker_teardown_cb (optional):
-// callback function that will be called in worker thread upon exit
-//
-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(), const std::function<void()>& worker_teardown_cb = nullptr);
-
-// Turn off async mode
-void set_sync_mode();
-
-
-//
-// Create and register multi/single threaded basic file logger.
-// Basic logger simply writes to given file without any limitatons or rotations.
-//
-std::shared_ptr<logger> basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate = false);
-std::shared_ptr<logger> basic_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate = false);
-
-//
-// Create and register multi/single threaded rotating file logger
-//
-std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);
-std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);
-
-//
-// Create file logger which creates new file on the given time (default in midnight):
-//
-std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
-std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
-
-//
-// Create and register stdout/stderr loggers
-//
-std::shared_ptr<logger> stdout_logger_mt(const std::string& logger_name);
-std::shared_ptr<logger> stdout_logger_st(const std::string& logger_name);
-std::shared_ptr<logger> stderr_logger_mt(const std::string& logger_name);
-std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name);
-//
-// Create and register colored stdout/stderr loggers
-//
-std::shared_ptr<logger> stdout_color_mt(const std::string& logger_name);
-std::shared_ptr<logger> stdout_color_st(const std::string& logger_name);
-std::shared_ptr<logger> stderr_color_mt(const std::string& logger_name);
-std::shared_ptr<logger> stderr_color_st(const std::string& logger_name);
-
-
-//
-// Create and register a syslog logger
-//
-#ifdef SPDLOG_ENABLE_SYSLOG
-std::shared_ptr<logger> syslog_logger(const std::string& logger_name, const std::string& ident = "", int syslog_option = 0);
-#endif
-
-#if defined(__ANDROID__)
-std::shared_ptr<logger> android_logger(const std::string& logger_name, const std::string& tag = "spdlog");
-#endif
-
-// Create and register a logger a single sink
-std::shared_ptr<logger> create(const std::string& logger_name, const sink_ptr& sink);
-
-// Create and register a logger with multiple sinks
-std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks);
-template<class It>
-std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end);
-
-
-// Create and register a logger with templated sink type
-// Example:
-// spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename", "txt");
-template <typename Sink, typename... Args>
-std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);
-
-
-// Register the given logger with the given name
-void register_logger(std::shared_ptr<logger> logger);
-
-// Apply a user defined function on all registered loggers
-// Example:
-// spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();});
-void apply_all(std::function<void(std::shared_ptr<logger>)> fun);
-
-// Drop the reference to the given logger
-void drop(const std::string &name);
-
-// Drop all references from the registry
-void drop_all();
-
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Trace & Debug can be switched on/off at compile time for zero cost debug statements.
-// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in teakme.h to enable.
-// SPDLOG_TRACE(..) will also print current file and line.
-//
-// Example:
-// spdlog::set_level(spdlog::level::trace);
-// SPDLOG_TRACE(my_logger, "some trace message");
-// SPDLOG_TRACE(my_logger, "another trace message {} {}", 1, 2);
-// SPDLOG_DEBUG(my_logger, "some debug message {} {}", 3, 4);
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef SPDLOG_TRACE_ON
-#define SPDLOG_STR_H(x) #x
-#define SPDLOG_STR_HELPER(x) SPDLOG_STR_H(x)
-#define SPDLOG_TRACE(logger, ...) logger->trace("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__)
-#else
-#define SPDLOG_TRACE(logger, ...)
-#endif
-
-#ifdef SPDLOG_DEBUG_ON
-#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__)
-#else
-#define SPDLOG_DEBUG(logger, ...)
-#endif
-
-
-}
-
-
-#include <spdlog/details/spdlog_impl.h>
diff --git a/third_party/spdlog/include/spdlog/tweakme.h b/third_party/spdlog/include/spdlog/tweakme.h
deleted file mode 100644
index da6b77b702a3839346e3b928d56dd7c7f1ed38c2..0000000000000000000000000000000000000000
--- a/third_party/spdlog/include/spdlog/tweakme.h
+++ /dev/null
@@ -1,103 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Edit this file to squeeze more performance, and to customize supported features
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// 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.
-// Uncomment to use it instead of the regular clock.
-//
-// #define SPDLOG_CLOCK_COARSE
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment if date/time logging is not needed and never appear in the log pattern.
-// This will prevent spdlog from quering the clock on each log call.
-//
-// WARNING: If the log pattern contains any date/time while this flag is on, the result is undefined.
-// You must set new pattern(spdlog::set_pattern(..") without any date/time in it
-//
-// #define SPDLOG_NO_DATETIME
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// 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.
-//
-// WARNING: If the log pattern contains thread id (i.e, %t) while this flag is on, the result is undefined.
-//
-// #define SPDLOG_NO_THREAD_ID
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment if logger name logging is not needed.
-// This will prevent spdlog from copying the logger name on each log call.
-//
-#define SPDLOG_NO_NAME
-///////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////
-// 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.
-// Note that upon creating a logger the registry is modified by spdlog..
-//
-// #define SPDLOG_NO_REGISTRY_MUTEX
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to avoid spdlog's usage of atomic log levels
-// Use only if your code never modifies a logger's log levels concurrently by different threads.
-//
-#define SPDLOG_NO_ATOMIC_LEVELS
-///////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable usage of wchar_t for file names on Windows.
-//
-// #define SPDLOG_WCHAR_FILENAMES
-///////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to override default eol ("\n" or "\r\n" under Linux/Windows)
-//
-// #define SPDLOG_EOL ";-)\n"
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to use your own copy of the fmt library instead of spdlog's copy.
-// In this case spdlog will try to include <fmt/format.h> so set your -I flag accordingly.
-//
-// #define SPDLOG_FMT_EXTERNAL
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable syslog (disabled by default)
-//
-// #define SPDLOG_ENABLE_SYSLOG
-///////////////////////////////////////////////////////////////////////////////
-
-