From 59a237acb4770097f416f35ebab2d24fdbb113ac Mon Sep 17 00:00:00 2001 From: cks Date: Tue, 7 Aug 2018 17:14:47 +0700 Subject: [PATCH 01/11] add example and CustomLogger --- CustomLogger.cpp | 308 ++ CustomLogger.h | 60 + example.cpp | 50 + spdlog_lib/spdlog/async.h | 87 + spdlog_lib/spdlog/async_logger.h | 71 + spdlog_lib/spdlog/common.h | 183 + spdlog_lib/spdlog/details/async_logger_impl.h | 100 + spdlog_lib/spdlog/details/circular_q.h | 62 + spdlog_lib/spdlog/details/console_globals.h | 61 + spdlog_lib/spdlog/details/file_helper.h | 153 + spdlog_lib/spdlog/details/fmt_helper.h | 130 + spdlog_lib/spdlog/details/log_msg.h | 47 + spdlog_lib/spdlog/details/logger_impl.h | 345 ++ spdlog_lib/spdlog/details/mpmc_blocking_q.h | 115 + spdlog_lib/spdlog/details/null_mutex.h | 45 + spdlog_lib/spdlog/details/os.h | 432 ++ spdlog_lib/spdlog/details/pattern_formatter.h | 772 +++ spdlog_lib/spdlog/details/periodic_worker.h | 71 + spdlog_lib/spdlog/details/registry.h | 218 + spdlog_lib/spdlog/details/thread_pool.h | 220 + spdlog_lib/spdlog/fmt/bundled/LICENSE.rst | 23 + spdlog_lib/spdlog/fmt/bundled/colors.h | 257 + spdlog_lib/spdlog/fmt/bundled/core.h | 1578 ++++++ spdlog_lib/spdlog/fmt/bundled/format-inl.h | 578 ++ spdlog_lib/spdlog/fmt/bundled/format.h | 4716 +++++++++++++++++ spdlog_lib/spdlog/fmt/bundled/locale.h | 27 + spdlog_lib/spdlog/fmt/bundled/ostream.h | 173 + spdlog_lib/spdlog/fmt/bundled/posix.h | 484 ++ spdlog_lib/spdlog/fmt/bundled/printf.h | 807 +++ spdlog_lib/spdlog/fmt/bundled/ranges.h | 344 ++ spdlog_lib/spdlog/fmt/bundled/time.h | 199 + spdlog_lib/spdlog/fmt/fmt.h | 25 + spdlog_lib/spdlog/fmt/ostr.h | 18 + spdlog_lib/spdlog/formatter.h | 20 + spdlog_lib/spdlog/logger.h | 162 + spdlog_lib/spdlog/sinks/android_sink.h | 117 + spdlog_lib/spdlog/sinks/ansicolor_sink.h | 156 + spdlog_lib/spdlog/sinks/base_sink.h | 63 + spdlog_lib/spdlog/sinks/basic_file_sink.h | 66 + spdlog_lib/spdlog/sinks/daily_file_sink.h | 132 + spdlog_lib/spdlog/sinks/dist_sink.h | 68 + spdlog_lib/spdlog/sinks/msvc_sink.h | 50 + spdlog_lib/spdlog/sinks/null_sink.h | 28 + spdlog_lib/spdlog/sinks/ostream_sink.h | 51 + spdlog_lib/spdlog/sinks/rotating_file_sink.h | 144 + spdlog_lib/spdlog/sinks/sink.h | 57 + spdlog_lib/spdlog/sinks/stdout_color_sinks.h | 53 + spdlog_lib/spdlog/sinks/stdout_sinks.h | 100 + spdlog_lib/spdlog/sinks/syslog_sink.h | 91 + spdlog_lib/spdlog/sinks/wincolor_sink.h | 139 + spdlog_lib/spdlog/spdlog.h | 161 + spdlog_lib/spdlog/tweakme.h | 132 + spdlog_lib/spdlog/version.h | 12 + 53 files changed, 14561 insertions(+) create mode 100644 CustomLogger.cpp create mode 100644 CustomLogger.h create mode 100644 example.cpp create mode 100644 spdlog_lib/spdlog/async.h create mode 100644 spdlog_lib/spdlog/async_logger.h create mode 100644 spdlog_lib/spdlog/common.h create mode 100644 spdlog_lib/spdlog/details/async_logger_impl.h create mode 100644 spdlog_lib/spdlog/details/circular_q.h create mode 100644 spdlog_lib/spdlog/details/console_globals.h create mode 100644 spdlog_lib/spdlog/details/file_helper.h create mode 100644 spdlog_lib/spdlog/details/fmt_helper.h create mode 100644 spdlog_lib/spdlog/details/log_msg.h create mode 100644 spdlog_lib/spdlog/details/logger_impl.h create mode 100644 spdlog_lib/spdlog/details/mpmc_blocking_q.h create mode 100644 spdlog_lib/spdlog/details/null_mutex.h create mode 100644 spdlog_lib/spdlog/details/os.h create mode 100644 spdlog_lib/spdlog/details/pattern_formatter.h create mode 100644 spdlog_lib/spdlog/details/periodic_worker.h create mode 100644 spdlog_lib/spdlog/details/registry.h create mode 100644 spdlog_lib/spdlog/details/thread_pool.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/LICENSE.rst create mode 100644 spdlog_lib/spdlog/fmt/bundled/colors.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/core.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/format-inl.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/format.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/locale.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/ostream.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/posix.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/printf.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/ranges.h create mode 100644 spdlog_lib/spdlog/fmt/bundled/time.h create mode 100644 spdlog_lib/spdlog/fmt/fmt.h create mode 100644 spdlog_lib/spdlog/fmt/ostr.h create mode 100644 spdlog_lib/spdlog/formatter.h create mode 100644 spdlog_lib/spdlog/logger.h create mode 100644 spdlog_lib/spdlog/sinks/android_sink.h create mode 100644 spdlog_lib/spdlog/sinks/ansicolor_sink.h create mode 100644 spdlog_lib/spdlog/sinks/base_sink.h create mode 100644 spdlog_lib/spdlog/sinks/basic_file_sink.h create mode 100644 spdlog_lib/spdlog/sinks/daily_file_sink.h create mode 100644 spdlog_lib/spdlog/sinks/dist_sink.h create mode 100644 spdlog_lib/spdlog/sinks/msvc_sink.h create mode 100644 spdlog_lib/spdlog/sinks/null_sink.h create mode 100644 spdlog_lib/spdlog/sinks/ostream_sink.h create mode 100644 spdlog_lib/spdlog/sinks/rotating_file_sink.h create mode 100644 spdlog_lib/spdlog/sinks/sink.h create mode 100644 spdlog_lib/spdlog/sinks/stdout_color_sinks.h create mode 100644 spdlog_lib/spdlog/sinks/stdout_sinks.h create mode 100644 spdlog_lib/spdlog/sinks/syslog_sink.h create mode 100644 spdlog_lib/spdlog/sinks/wincolor_sink.h create mode 100644 spdlog_lib/spdlog/spdlog.h create mode 100644 spdlog_lib/spdlog/tweakme.h create mode 100644 spdlog_lib/spdlog/version.h diff --git a/CustomLogger.cpp b/CustomLogger.cpp new file mode 100644 index 0000000..fe277bb --- /dev/null +++ b/CustomLogger.cpp @@ -0,0 +1,308 @@ +#include "CustomLogger.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////////// + +//class Entry + +//private +std::string CustomLogger::Entry::AddQuotation(std::string msg) //return quotation in message input +{ + return "\"" + msg + "\""; +} + +std::string CustomLogger::Entry::JSONformatter() //return json formatter +{ + return "\"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : \"%v\" "; +} + +std::string CustomLogger::Entry::processPattern(std::string pattern) +{ + if(JSON) //jsonform is true + { + return "{ " + JSONformatter() + pattern + "}"; + } + else //jsonform is false + { + return "%+ " + pattern; + } +} + +std::string CustomLogger::Entry::processKey() +{ + std::string pattern =""; + + for (auto& [key,val] : entry_field) + { + pattern = pattern + casting(key, val); + } + return processPattern(pattern); +} + +std::string CustomLogger::Entry::casting(std::string key, std::any val) //casting the value in map into string +{ + std::string custom_string; + if(JSON) + { + custom_string = custom_string + ", " + AddQuotation(key) + " : " ; + //check type for any_cast + if (val.type() == typeid(char)) //char + { + custom_string = custom_string + "\""; + custom_string += (std::any_cast(val)); + custom_string = custom_string + "\" "; + } + else if (val.type() == typeid(const char *)) //array of char + { + std::string temp(std::any_cast(val)); + custom_string = custom_string + AddQuotation(temp) + " "; + } + else if (val.type() == typeid(int)) //integer + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(float)) //float + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(double)) //double + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(bool)) //boolean + { + if (std::any_cast(val) == 1) + { + custom_string = custom_string + "true "; + } + else if (std::any_cast(val) == 0) + { + custom_string = custom_string + "false "; + } + } + else if (val.type() == typeid(std::string)) //string + { + custom_string = custom_string + AddQuotation(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(long)) //long + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + } + else + { + custom_string = custom_string + key + " = " ; + //check type for any_cast + if (val.type() == typeid(char)) + { + custom_string = custom_string + "\""; + custom_string += (std::any_cast(val)); + custom_string = custom_string + "\" "; + } + else if (val.type() == typeid(const char *)) + { + std::string temp(std::any_cast(val)); + custom_string = custom_string + AddQuotation(temp) + " "; + } + else if (val.type() == typeid(int)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(float)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(double)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(bool)) + { + if (std::any_cast(val) == 1) + { + custom_string = custom_string + "true "; + } + else if (std::any_cast(val) == 0) + { + custom_string = custom_string + "false "; + } + } + else if (val.type() == typeid(std::string)) + { + custom_string = custom_string + AddQuotation(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(long)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + } + + return custom_string; +} + +//public +CustomLogger::Entry::Entry() +{ + //default ctor (not used) +} + +CustomLogger::Entry::Entry(std::shared_ptr& log, bool JSON ) //ctor +{ + entry_log = log; + this -> JSON = JSON; +} + +CustomLogger::Entry& CustomLogger::Entry::WithField(std::map& keyMap) +{ + entry_field = keyMap; + return *this; +} +void CustomLogger::Entry::info(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> info(msg); +} + +void CustomLogger::Entry::trace(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> trace(msg); +} + +void CustomLogger::Entry::debug(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> debug(msg); +} + +void CustomLogger::Entry::warn(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> warn(msg); +} + +void CustomLogger::Entry::error(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> error(msg); +} + +void CustomLogger::Entry::critical(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> critical(msg); +} +//////////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////////// +// CustomLogger implementation + +CustomLogger::CustomLogger(std::string name, bool to_file) //constructor +{ + if (to_file) + { + logger = spdlog::basic_logger_mt(name , "logs/basic-log.txt"); + } + else + { + logger = spdlog::stdout_color_mt(name); + } + WriteFile = to_file; + JSONstatus = false; +} + +// function +void CustomLogger::OutputJSON() +{ + JSONstatus = true; +} + +void CustomLogger::OutputDefault() +{ + JSONstatus = false; +} + +CustomLogger::Entry& CustomLogger::WithField(std::map& keyMap) +{ + loggerEntry = Entry(logger, JSONstatus); + return loggerEntry.WithField(keyMap); +} + +std::string CustomLogger::JSONformatter() +{ + return "\"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : \"%v\" "; +} + +//basic logging +void CustomLogger::info(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> info(msg); +} + +void CustomLogger::trace(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> trace(msg); +} +void CustomLogger::debug(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> debug(msg); +} +void CustomLogger::warn(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> warn(msg); +} +void CustomLogger::error(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> error(msg); +} +void CustomLogger::critical(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> critical(msg); +} diff --git a/CustomLogger.h b/CustomLogger.h new file mode 100644 index 0000000..ea250b5 --- /dev/null +++ b/CustomLogger.h @@ -0,0 +1,60 @@ +#pragma once + +#include +#include +#include +#include +#include "spdlog/spdlog.h" +#include "spdlog/sinks/stdout_color_sinks.h" +#include "spdlog/sinks/basic_file_sink.h" + +class CustomLogger +{ +private: + //member + class Entry + { + private: + //member + std::map entry_field; + std::shared_ptr entry_log; + bool JSON; + //function + std::string AddQuotation(std::string msg); + std::string JSONformatter(); + std::string processPattern(std::string pattern); + std::string processKey(); + std::string casting(std::string key, std::any val); + public: + Entry(); //default ctor + Entry(std::shared_ptr& log, bool JSON ); //ctor with parameter + Entry& WithField(std::map& keyMap); + void info(std::string msg); + void trace(std::string msg); + void debug(std::string msg); + void warn(std::string msg); + void error(std::string msg); + void critical(std::string msg); + }; + Entry loggerEntry; + std::shared_ptr logger; + bool JSONstatus; // make this true to make log in JSON form / false in normal form + bool WriteFile; // make this true to write log into file +public: + //member + std::map custom_field; + //ctor + CustomLogger(std::string name, bool to_file); + //function + void OutputJSON(); + void OutputDefault(); + CustomLogger::Entry& WithField(std::map& keyMap); + std::string JSONformatter(); + //basic logging + void info(std::string msg); + void trace(std::string msg); + void debug(std::string msg); + void warn(std::string msg); + void error(std::string msg); + void critical(std::string msg); +}; diff --git a/example.cpp b/example.cpp new file mode 100644 index 0000000..bb6dd8c --- /dev/null +++ b/example.cpp @@ -0,0 +1,50 @@ +#include "CustomLogger.h" + +#define toFile false + +// Compile with "g++ example.cpp CustomLogger.cpp -o example -Wall -Wextra -pedantic -std=c++17 -pthread -Ispdlog_lib -fmax-errors=1 -O3 -march=native" +// dont forget to create logs folder if logging to file + +int main() +{ + std::string a ="testing"; + float float_test = 2.8; + long long_test = 100; + CustomLogger log("test", toFile); + + spdlog::set_level(spdlog::level::trace); + log.WithField(log.custom_field={{"animal", "walrus"}, {"total", 100}}).info("INFO of WALRUS and its total"); + log.info("No Walrus "); + log.WithField(log.custom_field={{"animal", "horse"}, {"total", 90}}).debug("DEBUG of HORSE and its total"); + log.debug("No Horse"); + + log.OutputJSON(); //output in JSON format + log.WithField(log.custom_field={{"animal", "bird"}, {"total", 40.5}}).trace("TRACE of BIRD and its total"); + log.trace("No Bird"); + log.WithField(log.custom_field={{"animal", "dog"}, {"total", float_test}}).warn("WARN of DOG and its total"); + log.warn("No Dog"); + + log.OutputDefault(); //output in default format + log.WithField(log.custom_field={{"animal", "cat"}, {"total", long_test}}).critical("CRITICAL of CAT and its total"); + log.critical("No Cat"); + log.WithField(log.custom_field={{"animal", "falcon"}, {"total", 10}}).error("ERROR of FALCON and its total"); + log.error("No Falcon"); + + log.OutputJSON(); + auto staticformat = log.WithField(log.custom_field={{"float",float_test}, {"long", long_test}, {"string", a}}); + staticformat.info("This is INFO with custom key"); + staticformat.debug("This is DEBUG with custom key"); + staticformat.trace("This is TRACE with custom key"); + staticformat.warn("This is WARN with custom key"); + staticformat.critical("This is CRITICAL with custom key"); + staticformat.error("This is ERROR with custom key"); + + log.OutputDefault(); + auto staticformat2 = log.WithField(log.custom_field={{"animal","griffin"}, {"rider", "azure"}, {"weapon", "spear"}}); + staticformat2.info("This is INFO with custom key"); + staticformat2.debug("This is DEBUG with custom key"); + staticformat2.trace("This is TRACE with custom key"); + staticformat2.warn("This is WARN with custom key"); + staticformat2.critical("This is CRITICAL with custom key"); + staticformat2.error("This is ERROR with custom key"); +} diff --git a/spdlog_lib/spdlog/async.h b/spdlog_lib/spdlog/async.h new file mode 100644 index 0000000..f70c4a3 --- /dev/null +++ b/spdlog_lib/spdlog/async.h @@ -0,0 +1,87 @@ + +// +// Copyright(c) 2018 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +// +// Async logging using global thread pool +// All loggers created here share same global thread pool. +// Each log message is pushed to a queue along withe a shared pointer to the +// logger. +// If a logger deleted while having pending messages in the queue, it's actual +// destruction will defer +// until all its messages are processed by the thread pool. +// This is because each message in the queue holds a shared_ptr to the +// originating logger. + +#include "spdlog/async_logger.h" +#include "spdlog/details/registry.h" +#include "spdlog/details/thread_pool.h" + +#include +#include + +namespace spdlog { + +namespace details { +static const size_t default_async_q_size = 8192; +} + +// async logger factory - creates async loggers backed with thread pool. +// if a global thread pool doesn't already exist, create it with default queue +// size of 8192 items and single thread. +template +struct async_factory_impl +{ + template + static std::shared_ptr create(const std::string &logger_name, SinkArgs &&... args) + { + auto ®istry_inst = details::registry::instance(); + + // create global thread pool if not already exists.. + std::lock_guard(registry_inst.tp_mutex()); + auto tp = registry_inst.get_tp(); + if (tp == nullptr) + { + tp = std::make_shared(details::default_async_q_size, 1); + registry_inst.set_tp(tp); + } + + auto sink = std::make_shared(std::forward(args)...); + auto new_logger = std::make_shared(logger_name, std::move(sink), std::move(tp), OverflowPolicy); + registry_inst.register_and_init(new_logger); + return new_logger; + } +}; + +using async_factory = async_factory_impl; +using async_factory_nonblock = async_factory_impl; + +template +inline std::shared_ptr create_async(const std::string &logger_name, SinkArgs &&... sink_args) +{ + return async_factory::create(logger_name, std::forward(sink_args)...); +} + +template +inline std::shared_ptr create_async_nb(const std::string &logger_name, SinkArgs &&... sink_args) +{ + return async_factory_nonblock::create(logger_name, std::forward(sink_args)...); +} + +// set global thread pool. +inline void init_thread_pool(size_t q_size, size_t thread_count) +{ + auto tp = std::make_shared(q_size, thread_count); + details::registry::instance().set_tp(std::move(tp)); +} + +// get the global thread pool. +inline std::shared_ptr thread_pool() +{ + return details::registry::instance().get_tp(); +} +} // namespace spdlog diff --git a/spdlog_lib/spdlog/async_logger.h b/spdlog_lib/spdlog/async_logger.h new file mode 100644 index 0000000..2d58f98 --- /dev/null +++ b/spdlog_lib/spdlog/async_logger.h @@ -0,0 +1,71 @@ +// +// 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 +#include +#include + +namespace spdlog { + +// Async overflow policy - block by default. +enum class async_overflow_policy +{ + block, // Block until message can be enqueued + overrun_oldest // Discard oldest message in the queue if full when trying to + // add new item. +}; + +namespace details { +class thread_pool; +} + +class async_logger SPDLOG_FINAL : public std::enable_shared_from_this, public logger +{ + friend class details::thread_pool; + +public: + template + async_logger(std::string logger_name, const It &begin, const It &end, std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block); + + async_logger(std::string logger_name, sinks_init_list sinks, std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block); + + async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block); + +protected: + void sink_it_(details::log_msg &msg) override; + void flush_() override; + + void backend_log_(details::log_msg &incoming_log_msg); + void backend_flush_(); + +private: + std::weak_ptr thread_pool_; + async_overflow_policy overflow_policy_; +}; +} // namespace spdlog + +#include "details/async_logger_impl.h" diff --git a/spdlog_lib/spdlog/common.h b/spdlog_lib/spdlog/common.h new file mode 100644 index 0000000..b8d4517 --- /dev/null +++ b/spdlog_lib/spdlog/common.h @@ -0,0 +1,183 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "spdlog/tweakme.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) +#include +#include +#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 + +// final keyword support. On by default. See tweakme.h +#if defined(SPDLOG_NO_FINAL) +#define SPDLOG_FINAL +#else +#define SPDLOG_FINAL final +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define SPDLOG_DEPRECATED __attribute__((deprecated)) +#elif defined(_MSC_VER) +#define SPDLOG_DEPRECATED __declspec(deprecated) +#else +#define SPDLOG_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; +using sinks_init_list = std::initializer_list; +using log_err_handler = std::function; + +#if defined(SPDLOG_NO_ATOMIC_LEVELS) +using level_t = details::null_atomic_int; +#else +using level_t = std::atomic; +#endif + +// Log level enum +namespace level { +enum level_enum +{ + trace = 0, + debug = 1, + info = 2, + warn = 3, + err = 4, + critical = 5, + off = 6 +}; + +#if !defined(SPDLOG_LEVEL_NAMES) +#define SPDLOG_LEVEL_NAMES \ + { \ + "trace", "debug", "info", "warning", "error", "critical", "off" \ + } +#endif +static const char *level_names[] SPDLOG_LEVEL_NAMES; + +static const char *short_level_names[]{"T", "D", "I", "W", "E", "C", "O"}; + +inline const char *to_c_str(spdlog::level::level_enum l) +{ + return level_names[l]; +} + +inline const char *to_short_c_str(spdlog::level::level_enum l) +{ + return short_level_names[l]; +} +inline spdlog::level::level_enum from_str(const std::string &name) +{ + static std::unordered_map name_to_level = // map string->level + {{level_names[0], level::trace}, // trace + {level_names[1], level::debug}, // debug + {level_names[2], level::info}, // info + {level_names[3], level::warn}, // warn + {level_names[4], level::err}, // err + {level_names[5], level::critical}, // critical + {level_names[6], level::off}}; // off + + auto lvl_it = name_to_level.find(name); + return lvl_it != name_to_level.end() ? lvl_it->second : level::off; +} + +using level_hasher = std::hash; +} // namespace level + +// +// Pattern time - specific time getting to use for pattern_formatter. +// local time by default +// +enum class pattern_time_type +{ + local, // log localtime + utc // log utc +}; + +// +// Log exception +// +class spdlog_ex : public std::runtime_error +{ +public: + explicit spdlog_ex(const std::string &msg) + : runtime_error(msg) + { + } + spdlog_ex(std::string msg, int last_errno) + : runtime_error(std::move(msg)) + , last_errno_(last_errno) + { + } + const char *what() const SPDLOG_NOEXCEPT override + { + if (last_errno_) + { + fmt::memory_buffer buf; + std::string msg(runtime_error::what()); + fmt::format_system_error(buf, last_errno_, msg); + return fmt::to_string(buf).c_str(); + } + else + { + return runtime_error::what(); + } + } + +private: + int last_errno_{0}; +}; + +// +// 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 + +#define SPDLOG_CATCH_AND_HANDLE \ + catch (const std::exception &ex) \ + { \ + err_handler_(ex.what()); \ + } \ + catch (...) \ + { \ + err_handler_("Unknown exeption in logger"); \ + } +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/async_logger_impl.h b/spdlog_lib/spdlog/details/async_logger_impl.h new file mode 100644 index 0000000..a42ade9 --- /dev/null +++ b/spdlog_lib/spdlog/details/async_logger_impl.h @@ -0,0 +1,100 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +// async logger implementation +// uses a thread pool to perform the actual logging + +#include "spdlog/details/thread_pool.h" + +#include +#include +#include + +template +inline spdlog::async_logger::async_logger( + std::string logger_name, const It &begin, const It &end, std::weak_ptr tp, async_overflow_policy overflow_policy) + : logger(std::move(logger_name), begin, end) + , thread_pool_(tp) + , overflow_policy_(overflow_policy) +{ +} + +inline spdlog::async_logger::async_logger( + std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, async_overflow_policy overflow_policy) + : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), tp, overflow_policy) +{ +} + +inline spdlog::async_logger::async_logger( + std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, async_overflow_policy overflow_policy) + : async_logger(std::move(logger_name), {single_sink}, tp, overflow_policy) +{ +} + +// send the log message to the thread pool +inline void spdlog::async_logger::sink_it_(details::log_msg &msg) +{ +#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER) + incr_msg_counter_(msg); +#endif + if (auto pool_ptr = thread_pool_.lock()) + { + pool_ptr->post_log(shared_from_this(), std::move(msg), overflow_policy_); + } + else + { + throw spdlog_ex("async log: thread pool doens't exist anymore"); + } +} + +// send flush request to the thread pool +inline void spdlog::async_logger::flush_() +{ + if (auto pool_ptr = thread_pool_.lock()) + { + pool_ptr->post_flush(shared_from_this(), overflow_policy_); + } + else + { + throw spdlog_ex("async flush: thread pool doesn't exist anymore"); + } +} + +// +// backend functions - called from the thread pool to do the actual job +// +inline void spdlog::async_logger::backend_log_(details::log_msg &incoming_log_msg) +{ + try + { + for (auto &s : sinks_) + { + if (s->should_log(incoming_log_msg.level)) + { + s->log(incoming_log_msg); + } + } + } + SPDLOG_CATCH_AND_HANDLE + + if (should_flush_(incoming_log_msg)) + { + backend_flush_(); + } +} + +inline void spdlog::async_logger::backend_flush_() +{ + try + { + for (auto &sink : sinks_) + { + sink->flush(); + } + } + SPDLOG_CATCH_AND_HANDLE +} diff --git a/spdlog_lib/spdlog/details/circular_q.h b/spdlog_lib/spdlog/details/circular_q.h new file mode 100644 index 0000000..48f9a8f --- /dev/null +++ b/spdlog_lib/spdlog/details/circular_q.h @@ -0,0 +1,62 @@ +// +// Copyright(c) 2018 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +// cirucal q view of std::vector. +#pragma once + +namespace spdlog { +namespace details { +template +class circular_q +{ +public: + using item_type = T; + + explicit circular_q(size_t max_items) + : max_items_(max_items + 1) // one item is reserved as marker for full q + , v_(max_items_) + { + } + + // push back, overrun (oldest) item if no room left + void push_back(T &&item) + { + v_[tail_] = std::move(item); + tail_ = (tail_ + 1) % max_items_; + + if (tail_ == head_) // overrun last item if full + { + head_ = (head_ + 1) % max_items_; + } + } + + // Pop item from front. + // If there are no elements in the container, the behavior is undefined. + void pop_front(T &popped_item) + { + popped_item = std::move(v_[head_]); + head_ = (head_ + 1) % max_items_; + } + + bool empty() + { + return tail_ == head_; + } + + bool full() + { + // head is ahead of the tail by 1 + return ((tail_ + 1) % max_items_) == head_; + } + +private: + size_t max_items_; + typename std::vector::size_type head_ = 0; + typename std::vector::size_type tail_ = 0; + + std::vector v_; +}; +} // namespace details +} // namespace spdlog \ No newline at end of file diff --git a/spdlog_lib/spdlog/details/console_globals.h b/spdlog_lib/spdlog/details/console_globals.h new file mode 100644 index 0000000..52de06a --- /dev/null +++ b/spdlog_lib/spdlog/details/console_globals.h @@ -0,0 +1,61 @@ +#pragma once +// +// Copyright(c) 2018 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#include "spdlog/details/null_mutex.h" +#include "stdio.h" +#include + +namespace spdlog { +namespace details { +struct console_stdout +{ + static FILE *stream() + { + return stdout; + } +#ifdef _WIN32 + static HANDLE handle() + { + return ::GetStdHandle(STD_OUTPUT_HANDLE); + } +#endif +}; + +struct console_stderr +{ + static FILE *stream() + { + return stderr; + } +#ifdef _WIN32 + static HANDLE handle() + { + return ::GetStdHandle(STD_ERROR_HANDLE); + } +#endif +}; + +struct console_mutex +{ + using mutex_t = std::mutex; + static mutex_t &mutex() + { + static mutex_t s_mutex; + return s_mutex; + } +}; + +struct console_nullmutex +{ + using mutex_t = null_mutex; + static mutex_t &mutex() + { + static mutex_t s_mutex; + return s_mutex; + } +}; +} // namespace details +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/file_helper.h b/spdlog_lib/spdlog/details/file_helper.h new file mode 100644 index 0000000..ef70d56 --- /dev/null +++ b/spdlog_lib/spdlog/details/file_helper.h @@ -0,0 +1,153 @@ +// +// 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) +// Throw spdlog_ex exception on errors + +#include "../details/log_msg.h" +#include "../details/os.h" + +#include +#include +#include +#include +#include +#include + +namespace spdlog { +namespace details { + +class file_helper +{ + +public: + const int open_tries = 5; + const int open_interval = 10; + + explicit file_helper() = default; + + 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; + } + + details::os::sleep_for_millis(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_ != nullptr) + { + std::fclose(fd_); + fd_ = nullptr; + } + } + + void write(const fmt::memory_buffer &buf) + { + size_t msg_size = buf.size(); + auto data = buf.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() const + { + if (fd_ == nullptr) + { + 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 &fname) + { + return os::file_exists(fname); + } + + // + // return file path and its extension: + // + // "mylog.txt" => ("mylog", ".txt") + // "mylog" => ("mylog", "") + // "mylog." => ("mylog.", "") + // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") + // + // the starting dot in filenames is ignored (hidden files): + // + // ".mylog" => (".mylog". "") + // "my_folder/.mylog" => ("my_folder/.mylog", "") + // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") + static std::tuple split_by_extenstion(const spdlog::filename_t &fname) + { + auto ext_index = fname.rfind('.'); + + // no valid extension found - return whole path and empty string as + // extension + if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) + { + return std::make_tuple(fname, spdlog::filename_t()); + } + + // treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile" + auto folder_index = fname.rfind(details::os::folder_sep); + if (folder_index != fname.npos && folder_index >= ext_index - 1) + { + return std::make_tuple(fname, spdlog::filename_t()); + } + + // finally - return a valid base and extension tuple + return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); + } + +private: + FILE *fd_{nullptr}; + filename_t _filename; +}; +} // namespace details +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/fmt_helper.h b/spdlog_lib/spdlog/details/fmt_helper.h new file mode 100644 index 0000000..0f67053 --- /dev/null +++ b/spdlog_lib/spdlog/details/fmt_helper.h @@ -0,0 +1,130 @@ +// +// Created by gabi on 6/15/18. +// + +#pragma once + +#include "chrono" +#include "spdlog/fmt/fmt.h" + +// Some fmt helpers to efficiently format and pad ints and strings +namespace spdlog { +namespace details { +namespace fmt_helper { + +template +inline void append_str(const std::string &str, fmt::basic_memory_buffer &dest) +{ + auto *str_ptr = str.data(); + dest.append(str_ptr, str_ptr + str.size()); +} + +template +inline void append_c_str(const char *c_str, fmt::basic_memory_buffer &dest) +{ + char ch; + while ((ch = *c_str) != '\0') + { + dest.push_back(ch); + ++c_str; + } +} + +template +inline void append_buf(const fmt::basic_memory_buffer &buf, fmt::basic_memory_buffer &dest) +{ + auto *buf_ptr = buf.data(); + dest.append(buf_ptr, buf_ptr + buf.size()); +} + +template +inline void append_int(T n, fmt::basic_memory_buffer &dest) +{ + fmt::format_int i(n); + dest.append(i.data(), i.data() + i.size()); +} + +template +inline void pad2(int n, fmt::basic_memory_buffer &dest) +{ + if (n > 99) + { + append_int(n, dest); + return; + } + if (n > 9) // 10-99 + { + dest.push_back('0' + static_cast(n / 10)); + dest.push_back('0' + static_cast(n % 10)); + return; + } + if (n >= 0) // 0-9 + { + dest.push_back('0'); + dest.push_back('0' + static_cast(n)); + return; + } + // negatives (unlikely, but just in case, let fmt deal with it) + fmt::format_to(dest, "{:02}", n); +} + +template +inline void pad3(int n, fmt::basic_memory_buffer &dest) +{ + if (n > 999) + { + append_int(n, dest); + return; + } + + if (n > 99) // 100-999 + { + append_int(n / 100, dest); + pad2(n % 100, dest); + return; + } + if (n > 9) // 10-99 + { + dest.push_back('0'); + dest.push_back('0' + static_cast(n / 10)); + dest.push_back('0' + static_cast(n % 10)); + return; + } + if (n >= 0) + { + dest.push_back('0'); + dest.push_back('0'); + dest.push_back('0' + static_cast(n)); + return; + } + // negatives (unlikely, but just in case let fmt deal with it) + fmt::format_to(dest, "{:03}", n); +} + +template +inline void pad6(size_t n, fmt::basic_memory_buffer &dest) +{ + if (n > 99999) + { + append_int(n, dest); + return; + } + pad3(static_cast(n / 1000), dest); + pad3(static_cast(n % 1000), dest); +} + +// return fraction of a second of the given time_point. +// e.g. +// fraction(tp) -> will return the millis part of the second +template +inline ToDuration time_fraction(const log_clock::time_point &tp) +{ + using namespace std::chrono; + auto duration = tp.time_since_epoch(); + auto secs = duration_cast(duration); + return duration_cast(duration) - duration_cast(secs); +} + +} // namespace fmt_helper +} // namespace details +} // namespace spdlog \ No newline at end of file diff --git a/spdlog_lib/spdlog/details/log_msg.h b/spdlog_lib/spdlog/details/log_msg.h new file mode 100644 index 0000000..ce988e4 --- /dev/null +++ b/spdlog_lib/spdlog/details/log_msg.h @@ -0,0 +1,47 @@ +// +// 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 +#include + +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(log_msg &&other) = delete; + log_msg &operator=(log_msg &&other) = delete; + + const std::string *logger_name{nullptr}; + level::level_enum level; + log_clock::time_point time; + size_t thread_id; + fmt::memory_buffer raw; + size_t msg_id{0}; + // info about wrapping the formatted text with color + mutable size_t color_range_start{0}; + mutable size_t color_range_end{0}; +}; +} // namespace details +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/logger_impl.h b/spdlog_lib/spdlog/details/logger_impl.h new file mode 100644 index 0000000..0a7c5b6 --- /dev/null +++ b/spdlog_lib/spdlog/details/logger_impl.h @@ -0,0 +1,345 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include +#include + +// create logger with given name, sinks and the default pattern formatter +// all other ctors will call this one +template +inline spdlog::logger::logger(std::string logger_name, const It &begin, const It &end) + : name_(std::move(logger_name)) + , sinks_(begin, end) + , level_(level::info) + , flush_level_(level::off) + , last_err_time_(0) + , msg_counter_(1) // message counter will start from 1. 0-message id will be + // reserved for controll messages +{ + err_handler_ = [this](const std::string &msg) { this->default_err_handler_(msg); }; +} + +// ctor with sinks as init list +inline spdlog::logger::logger(std::string logger_name, sinks_init_list sinks_list) + : logger(std::move(logger_name), sinks_list.begin(), sinks_list.end()) +{ +} + +// ctor with single sink +inline spdlog::logger::logger(std::string logger_name, spdlog::sink_ptr single_sink) + : logger(std::move(logger_name), {std::move(single_sink)}) +{ +} + +inline spdlog::logger::~logger() = default; + +inline void spdlog::logger::set_formatter(std::unique_ptr f) +{ + for (auto &sink : sinks_) + { + sink->set_formatter(f->clone()); + } +} + +inline void spdlog::logger::set_pattern(std::string pattern, pattern_time_type time_type) +{ + set_formatter(std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); +} + +template +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); + fmt::format_to(log_msg.raw, fmt, args...); + sink_it_(log_msg); + } + SPDLOG_CATCH_AND_HANDLE +} + +template +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); + fmt::format_to(log_msg.raw, "{}", msg); + sink_it_(log_msg); + } + SPDLOG_CATCH_AND_HANDLE +} + +template +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); + fmt::format_to(log_msg.raw, "{}", msg); + sink_it_(log_msg); + } + SPDLOG_CATCH_AND_HANDLE +} + +template +inline void spdlog::logger::trace(const char *fmt, const Args &... args) +{ + log(level::trace, fmt, args...); +} + +template +inline void spdlog::logger::debug(const char *fmt, const Args &... args) +{ + log(level::debug, fmt, args...); +} + +template +inline void spdlog::logger::info(const char *fmt, const Args &... args) +{ + log(level::info, fmt, args...); +} + +template +inline void spdlog::logger::warn(const char *fmt, const Args &... args) +{ + log(level::warn, fmt, args...); +} + +template +inline void spdlog::logger::error(const char *fmt, const Args &... args) +{ + log(level::err, fmt, args...); +} + +template +inline void spdlog::logger::critical(const char *fmt, const Args &... args) +{ + log(level::critical, fmt, args...); +} + +template +inline void spdlog::logger::trace(const T &msg) +{ + log(level::trace, msg); +} + +template +inline void spdlog::logger::debug(const T &msg) +{ + log(level::debug, msg); +} + +template +inline void spdlog::logger::info(const T &msg) +{ + log(level::info, msg); +} + +template +inline void spdlog::logger::warn(const T &msg) +{ + log(level::warn, msg); +} + +template +inline void spdlog::logger::error(const T &msg) +{ + log(level::err, msg); +} + +template +inline void spdlog::logger::critical(const T &msg) +{ + log(level::critical, msg); +} + +#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT +template +inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args) +{ + if (!should_log(lvl)) + { + return; + } + + decltype(wstring_converter_)::byte_string utf8_string; + + try + { + { + std::lock_guard lock(wstring_converter_mutex_); + utf8_string = wstring_converter_.to_bytes(fmt); + } + log(lvl, utf8_string.c_str(), args...); + } + SPDLOG_CATCH_AND_HANDLE +} + +template +inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args) +{ + log(level::trace, fmt, args...); +} + +template +inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args) +{ + log(level::debug, fmt, args...); +} + +template +inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args) +{ + log(level::info, fmt, args...); +} + +template +inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args) +{ + log(level::warn, fmt, args...); +} + +template +inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args) +{ + log(level::err, fmt, args...); +} + +template +inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args) +{ + log(level::critical, fmt, args...); +} + +#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT + +// +// 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_ = std::move(err_handler); +} + +inline spdlog::log_err_handler spdlog::logger::error_handler() +{ + return err_handler_; +} + +inline void spdlog::logger::flush() +{ + try + { + flush_(); + } + SPDLOG_CATCH_AND_HANDLE +} + +inline void spdlog::logger::flush_on(level::level_enum log_level) +{ + flush_level_.store(log_level); +} + +inline bool spdlog::logger::should_flush_(const details::log_msg &msg) +{ + auto flush_level = flush_level_.load(std::memory_order_relaxed); + return (msg.level >= flush_level) && (msg.level != level::off); +} + +inline spdlog::level::level_enum spdlog::logger::level() const +{ + return static_cast(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) +{ +#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER) + incr_msg_counter_(msg); +#endif + for (auto &sink : sinks_) + { + if (sink->should_log(msg.level)) + { + sink->log(msg); + } + } + + if (should_flush_(msg)) + { + flush(); + } +} + +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; + } + last_err_time_ = now; + 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); + fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg); +} + +inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg) +{ + msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed); +} + +inline const std::vector &spdlog::logger::sinks() const +{ + return sinks_; +} + +inline std::vector &spdlog::logger::sinks() +{ + return sinks_; +} diff --git a/spdlog_lib/spdlog/details/mpmc_blocking_q.h b/spdlog_lib/spdlog/details/mpmc_blocking_q.h new file mode 100644 index 0000000..d607da2 --- /dev/null +++ b/spdlog_lib/spdlog/details/mpmc_blocking_q.h @@ -0,0 +1,115 @@ +#pragma once + +// +// Copyright(c) 2018 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +// multi producer-multi consumer blocking queue. +// enqueue(..) - will block until room found to put the new message. +// enqueue_nowait(..) - will return immediately with false if no room left in +// the queue. +// dequeue_for(..) - will block until the queue is not empty or timeout have +// passed. + +#include "spdlog/details/circular_q.h" + +#include +#include + +namespace spdlog { +namespace details { + +template +class mpmc_blocking_queue +{ +public: + using item_type = T; + explicit mpmc_blocking_queue(size_t max_items) + : q_(max_items) + { + } + +#ifndef __MINGW32__ + // try to enqueue and block if no room left + void enqueue(T &&item) + { + { + std::unique_lock lock(queue_mutex_); + pop_cv_.wait(lock, [this] { return !this->q_.full(); }); + q_.push_back(std::move(item)); + } + push_cv_.notify_one(); + } + + // enqueue immediately. overrun oldest message in the queue if no room left. + void enqueue_nowait(T &&item) + { + { + std::unique_lock lock(queue_mutex_); + q_.push_back(std::move(item)); + } + push_cv_.notify_one(); + } + + // try to dequeue item. if no item found. wait upto timeout and try again + // Return true, if succeeded dequeue item, false otherwise + bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) + { + { + std::unique_lock lock(queue_mutex_); + if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) + { + return false; + } + q_.pop_front(popped_item); + } + pop_cv_.notify_one(); + return true; + } + +#else + // apparently mingw deadlocks if the mutex is released before cv.notify_one(), + // so release the mutex at the very end each function. + + // try to enqueue and block if no room left + void enqueue(T &&item) + { + std::unique_lock lock(queue_mutex_); + pop_cv_.wait(lock, [this] { return !this->q_.full(); }); + q_.push_back(std::move(item)); + push_cv_.notify_one(); + } + + // enqueue immediately. overrun oldest message in the queue if no room left. + void enqueue_nowait(T &&item) + { + std::unique_lock lock(queue_mutex_); + q_.push_back(std::move(item)); + push_cv_.notify_one(); + } + + // try to dequeue item. if no item found. wait upto timeout and try again + // Return true, if succeeded dequeue item, false otherwise + bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) + { + std::unique_lock lock(queue_mutex_); + if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) + { + return false; + } + q_.pop_front(popped_item); + pop_cv_.notify_one(); + return true; + } + +#endif + +private: + std::mutex queue_mutex_; + std::condition_variable push_cv_; + std::condition_variable pop_cv_; + spdlog::details::circular_q q_; +}; +} // namespace details +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/null_mutex.h b/spdlog_lib/spdlog/details/null_mutex.h new file mode 100644 index 0000000..3f495bd --- /dev/null +++ b/spdlog_lib/spdlog/details/null_mutex.h @@ -0,0 +1,45 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include +// 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; + + explicit null_atomic_int(int val) + : value(val) + { + } + + int load(std::memory_order) const + { + return value; + } + + void store(int val) + { + value = val; + } +}; + +} // namespace details +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/os.h b/spdlog_lib/spdlog/details/os.h new file mode 100644 index 0000000..d7f7430 --- /dev/null +++ b/spdlog_lib/spdlog/details/os.h @@ -0,0 +1,432 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// +#pragma once + +#include "../common.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef _WIN32 + +#ifndef NOMINMAX +#define NOMINMAX // prevent windows redefining min/max +#endif + +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#include // _get_osfhandle and _isatty support +#include // _get_pid support +#include + +#ifdef __MINGW32__ +#include +#endif + +#else // unix + +#include +#include + +#ifdef __linux__ +#include //Use gettid() syscall under linux to get thread id + +#elif __FreeBSD__ +#include //Use thr_self() syscall under FreeBSD to get thread id +#endif + +#endif // unix + +#ifndef __has_feature // Clang - feature checking macros. +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#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( + std::chrono::duration_cast(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 *default_eol = SPDLOG_EOL; + +// folder separator +#ifdef _WIN32 +SPDLOG_CONSTEXPR static const char folder_sep = '\\'; +#else +SPDLOG_CONSTEXPR static const char folder_sep = '/'; +#endif + +inline void prevent_child_fd(FILE *f) +{ + +#ifdef _WIN32 +#if !defined(__cplusplus_winrt) + auto file_handle = (HANDLE)_get_osfhandle(_fileno(f)); + if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) + throw spdlog_ex("SetHandleInformation failed", errno); +#endif +#else + auto fd = fileno(f); + if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) + { + throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno); + } +#endif +} + +// fopen_s on non windows for writing +inline bool 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 +#else // unix + *fp = fopen((filename.c_str()), mode.c_str()); +#endif + +#ifdef SPDLOG_PREVENT_CHILD_FD + if (*fp != nullptr) + { + prevent_child_fd(*fp); + } +#endif + return *fp == nullptr; +} + +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"); + } +#if defined(_WIN32) && !defined(__CYGWIN__) + 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(ret); + } +#endif + +#else // unix + int fd = fileno(f); +// 64 bits(but not in osx or cygwin, where fstat64 is deprecated) +#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__) + struct stat64 st; + if (fstat64(fd, &st) == 0) + { + return static_cast(st.st_size); + } +#else // unix 32 bits or cygwin + struct stat st; + + if (fstat(fd, &st) == 0) + { + return static_cast(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) || defined(_AIX) + // '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; + } + }; + + auto offset_seconds = helper::calculate_gmt_offset(tm); +#else + auto offset_seconds = tm.tm_gmtoff; +#endif + + return static_cast(offset_seconds / 60); +#endif +} + +// Return current thread id as size_t +// It exists because the std::this_thread::get_id() is much slower(especially +// under VS 2013) +inline size_t _thread_id() +{ +#ifdef _WIN32 + return static_cast(::GetCurrentThreadId()); +#elif __linux__ +#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) +#define SYS_gettid __NR_gettid +#endif + return static_cast(syscall(SYS_gettid)); +#elif __FreeBSD__ + long tid; + thr_self(&tid); + return static_cast(tid); +#elif __APPLE__ + uint64_t tid; + pthread_threadid_np(nullptr, &tid); + return static_cast(tid); +#else // Default to standard C++11 (other Unix) + return static_cast(std::hash()(std::this_thread::get_id())); +#endif +} + +// Return current thread id as size_t (from thread local storage) +inline size_t thread_id() +{ +#if defined(SPDLOG_DISABLE_TID_CACHING) || (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) || \ + (defined(__clang__) && !__has_feature(cxx_thread_local)) + return _thread_id(); +#else // cache thread id in tls + static thread_local const size_t tid = _thread_id(); + return tid; +#endif +} + +// This is avoid msvc issue in sleep_for that happens if the clock changes. +// See https://github.com/gabime/spdlog/issues/609 +inline void sleep_for_millis(int milliseconds) +{ +#if defined(_WIN32) + ::Sleep(milliseconds); +#else + std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); +#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, 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 + +inline int pid() +{ + +#ifdef _WIN32 + return static_cast(::GetCurrentProcessId()); +#else + return static_cast(::getpid()); +#endif +} + +// Determine if the terminal supports colors +// Source: https://github.com/agauniyal/rang/ +inline bool is_color_terminal() +{ +#ifdef _WIN32 + return true; +#else + static constexpr const char *Terms[] = { + "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"}; + + const char *env_p = std::getenv("TERM"); + if (env_p == nullptr) + { + return false; + } + + static const bool result = + std::any_of(std::begin(Terms), std::end(Terms), [&](const char *term) { return std::strstr(env_p, term) != nullptr; }); + return result; +#endif +} + +// Detrmine if the terminal attached +// Source: https://github.com/agauniyal/rang/ +inline bool in_terminal(FILE *file) +{ + +#ifdef _WIN32 + return _isatty(_fileno(file)) != 0; +#else + return isatty(fileno(file)) != 0; +#endif +} +} // namespace os +} // namespace details +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/pattern_formatter.h b/spdlog_lib/spdlog/details/pattern_formatter.h new file mode 100644 index 0000000..765f930 --- /dev/null +++ b/spdlog_lib/spdlog/details/pattern_formatter.h @@ -0,0 +1,772 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "spdlog/details/fmt_helper.h" +#include "spdlog/details/log_msg.h" +#include "spdlog/details/os.h" +#include "spdlog/fmt/fmt.h" +#include "spdlog/formatter.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace spdlog { +namespace details { + +class flag_formatter +{ +public: + virtual ~flag_formatter() = default; + virtual void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) = 0; +}; + +/////////////////////////////////////////////////////////////////////// +// name & level pattern appenders +/////////////////////////////////////////////////////////////////////// +class name_formatter : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + fmt_helper::append_str(*msg.logger_name, dest); + } +}; + +// log level appender +class level_formatter : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + fmt_helper::append_c_str(level::to_c_str(msg.level), dest); + } +}; + +// short log level appender +class short_level_formatter : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + fmt_helper::append_c_str(level::to_short_c_str(msg.level), dest); + } +}; + +/////////////////////////////////////////////////////////////////////// +// Date time pattern appenders +/////////////////////////////////////////////////////////////////////// + +static const char *ampm(const tm &t) +{ + return t.tm_hour >= 12 ? "PM" : "AM"; +} + +static unsigned int to12h(const tm &t) +{ + return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; +} + +// Abbreviated weekday name +static const char *days[]{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; +class a_formatter : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::append_c_str(days[tm_time.tm_wday], dest); + } +}; + +// Full weekday name +static const char *full_days[]{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; +class A_formatter : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::append_c_str(full_days[tm_time.tm_wday], dest); + } +}; + +// Abbreviated month +static const char *months[]{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}; +class b_formatter : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::append_c_str(months[tm_time.tm_mon], dest); + } +}; + +// Full month name +static const char *full_months[]{ + "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; +class B_formatter : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::append_c_str(full_months[tm_time.tm_mon], dest); + } +}; + +// Date and time representation (Thu Aug 23 15:35:46 2014) +class c_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + // fmt::format_to(dest, "{} {} {} ", days[tm_time.tm_wday], + // months[tm_time.tm_mon], tm_time.tm_mday); + // date + fmt_helper::append_str(days[tm_time.tm_wday], dest); + dest.push_back(' '); + fmt_helper::append_str(months[tm_time.tm_mon], dest); + dest.push_back(' '); + fmt_helper::append_int(tm_time.tm_mday, dest); + dest.push_back(' '); + // time + + fmt_helper::pad2(tm_time.tm_hour, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_sec, dest); + dest.push_back(' '); + fmt_helper::append_int(tm_time.tm_year + 1900, dest); + } +}; + +// year - 2 digit +class C_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(tm_time.tm_year % 100, dest); + } +}; + +// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01 +class D_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(tm_time.tm_mon + 1, dest); + dest.push_back('/'); + fmt_helper::pad2(tm_time.tm_mday, dest); + dest.push_back('/'); + fmt_helper::pad2(tm_time.tm_year % 100, dest); + } +}; + +// year - 4 digit +class Y_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::append_int(tm_time.tm_year + 1900, dest); + } +}; + +// month 1-12 +class m_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(tm_time.tm_mon + 1, dest); + } +}; + +// day of month 1-31 +class d_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(tm_time.tm_mday, dest); + } +}; + +// hours in 24 format 0-23 +class H_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(tm_time.tm_hour, dest); + } +}; + +// hours in 12 format 1-12 +class I_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(to12h(tm_time), dest); + } +}; + +// minutes 0-59 +class M_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(tm_time.tm_min, dest); + } +}; + +// seconds 0-59 +class S_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(tm_time.tm_sec, dest); + } +}; + +// milliseconds +class e_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + auto millis = fmt_helper::time_fraction(msg.time); + fmt_helper::pad3(static_cast(millis.count()), dest); + } +}; + +// microseconds +class f_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + auto micros = fmt_helper::time_fraction(msg.time); + fmt_helper::pad6(static_cast(micros.count()), dest); + } +}; + +// nanoseconds +class F_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + auto ns = fmt_helper::time_fraction(msg.time); + fmt::format_to(dest, "{:09}", ns.count()); + } +}; + +// seconds since epoch +class E_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + auto duration = msg.time.time_since_epoch(); + auto seconds = std::chrono::duration_cast(duration).count(); + fmt_helper::append_int(seconds, dest); + } +}; + +// AM/PM +class p_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::append_c_str(ampm(tm_time), dest); + } +}; + +// 12 hour clock 02:55:02 pm +class r_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(to12h(tm_time), dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_sec, dest); + dest.push_back(' '); + fmt_helper::append_c_str(ampm(tm_time), dest); + } +}; + +// 24-hour HH:MM time, equivalent to %H:%M +class R_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + fmt_helper::pad2(tm_time.tm_hour, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, dest); + } +}; + +// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S +class T_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + // fmt::format_to(dest, "{:02}:{:02}:{:02}", tm_time.tm_hour, + // tm_time.tm_min, tm_time.tm_sec); + fmt_helper::pad2(tm_time.tm_hour, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_sec, dest); + } +}; + +// ISO 8601 offset from UTC in timezone (+-HH:MM) +class z_formatter SPDLOG_FINAL : public flag_formatter +{ +public: + const std::chrono::seconds cache_refresh = std::chrono::seconds(5); + + z_formatter() = default; + z_formatter(const z_formatter &) = delete; + z_formatter &operator=(const z_formatter &) = delete; + + void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) 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) + (void)(msg); + int total_minutes = os::utc_minutes_offset(tm_time); +#endif + bool is_negative = total_minutes < 0; + if (is_negative) + { + total_minutes = -total_minutes; + dest.push_back('-'); + } + else + { + dest.push_back('+'); + } + + fmt_helper::pad2(total_minutes / 60, dest); // hours + dest.push_back(':'); + fmt_helper::pad2(total_minutes % 60, dest); // minutes + } + +private: + log_clock::time_point last_update_{std::chrono::seconds(0)}; +#ifdef _WIN32 + int offset_minutes_{0}; + + int get_cached_offset(const log_msg &msg, const std::tm &tm_time) + { + if (msg.time - last_update_ >= cache_refresh) + { + offset_minutes_ = os::utc_minutes_offset(tm_time); + last_update_ = msg.time; + } + return offset_minutes_; + } +#endif +}; + +// Thread id +class t_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + fmt_helper::pad6(msg.thread_id, dest); + } +}; + +// Current pid +class pid_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override + { + fmt_helper::append_int(details::os::pid(), dest); + } +}; + +// message counter formatter +class i_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + fmt_helper::pad6(msg.msg_id, dest); + } +}; + +class v_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + fmt_helper::append_buf(msg.raw, dest); + } +}; + +class ch_formatter SPDLOG_FINAL : public flag_formatter +{ +public: + explicit ch_formatter(char ch) + : ch_(ch) + { + } + void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override + { + dest.push_back(ch_); + } + +private: + char ch_; +}; + +// aggregate user chars to display as is +class aggregate_formatter SPDLOG_FINAL : public flag_formatter +{ +public: + aggregate_formatter() = default; + + void add_ch(char ch) + { + str_ += ch; + } + void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override + { + fmt_helper::append_str(str_, dest); + } + +private: + std::string str_; +}; + +// mark the color range. expect it to be in the form of "%^colored text%$" +class color_start_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + msg.color_range_start = dest.size(); + } +}; +class color_stop_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override + { + msg.color_range_end = dest.size(); + } +}; + +// Full info formatter +// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v +class full_formatter SPDLOG_FINAL : public flag_formatter +{ + void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override + { + using namespace std::chrono; +#ifndef SPDLOG_NO_DATETIME + + // cache the date/time part for the next second. + auto duration = msg.time.time_since_epoch(); + auto secs = duration_cast(duration); + + if (cache_timestamp_ != secs || cached_datetime_.size() == 0) + { + cached_datetime_.resize(0); + cached_datetime_.push_back('['); + fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_); + cached_datetime_.push_back('-'); + + fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_); + cached_datetime_.push_back('-'); + + fmt_helper::pad2(tm_time.tm_mday, cached_datetime_); + cached_datetime_.push_back(' '); + + fmt_helper::pad2(tm_time.tm_hour, cached_datetime_); + cached_datetime_.push_back(':'); + + fmt_helper::pad2(tm_time.tm_min, cached_datetime_); + cached_datetime_.push_back(':'); + + fmt_helper::pad2(tm_time.tm_sec, cached_datetime_); + cached_datetime_.push_back('.'); + + cache_timestamp_ = secs; + } + fmt_helper::append_buf(cached_datetime_, dest); + + auto millis = fmt_helper::time_fraction(msg.time); + fmt_helper::pad3(static_cast(millis.count()), dest); + dest.push_back(']'); + dest.push_back(' '); + +#else // no datetime needed + (void)tm_time; +#endif + +#ifndef SPDLOG_NO_NAME + dest.push_back('['); + fmt_helper::append_str(*msg.logger_name, dest); + dest.push_back(']'); + dest.push_back(' '); +#endif + + dest.push_back('['); + // wrap the level name with color + msg.color_range_start = dest.size(); + fmt_helper::append_c_str(level::to_c_str(msg.level), dest); + msg.color_range_end = dest.size(); + dest.push_back(']'); + dest.push_back(' '); + fmt_helper::append_buf(msg.raw, dest); + } + +private: + std::chrono::seconds cache_timestamp_{0}; + fmt::basic_memory_buffer cached_datetime_; +}; + +} // namespace details + +class pattern_formatter SPDLOG_FINAL : public formatter +{ +public: + explicit pattern_formatter( + std::string pattern, pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol) + : pattern_(std::move(pattern)) + , eol_(std::move(eol)) + , pattern_time_type_(time_type) + , last_log_secs_(0) + { + std::memset(&cached_tm_, 0, sizeof(cached_tm_)); + compile_pattern_(pattern_); + } + + pattern_formatter(const pattern_formatter &other) = delete; + pattern_formatter &operator=(const pattern_formatter &other) = delete; + + virtual std::unique_ptr clone() const override + { + return std::unique_ptr(new pattern_formatter(pattern_, pattern_time_type_, eol_)); + } + + void format(const details::log_msg &msg, fmt::memory_buffer &dest) override + { +#ifndef SPDLOG_NO_DATETIME + auto secs = std::chrono::duration_cast(msg.time.time_since_epoch()); + if (secs != last_log_secs_) + { + cached_tm_ = get_time_(msg); + last_log_secs_ = secs; + } +#endif + for (auto &f : formatters_) + { + f->format(msg, cached_tm_, dest); + } + // write eol + details::fmt_helper::append_str(eol_, dest); + } + +private: + std::string pattern_; + std::string eol_; + pattern_time_type pattern_time_type_; + std::tm cached_tm_; + std::chrono::seconds last_log_secs_; + + std::vector> formatters_; + + std::tm get_time_(const details::log_msg &msg) + { + if (pattern_time_type_ == pattern_time_type::local) + { + return details::os::localtime(log_clock::to_time_t(msg.time)); + } + return details::os::gmtime(log_clock::to_time_t(msg.time)); + } + + void handle_flag_(char flag) + { + switch (flag) + { + // logger name + case 'n': + formatters_.emplace_back(new details::name_formatter()); + break; + + case 'l': + formatters_.emplace_back(new details::level_formatter()); + break; + + case 'L': + formatters_.emplace_back(new details::short_level_formatter()); + break; + + case ('t'): + formatters_.emplace_back(new details::t_formatter()); + break; + + case ('v'): + formatters_.emplace_back(new details::v_formatter()); + break; + + case ('a'): + formatters_.emplace_back(new details::a_formatter()); + break; + + case ('A'): + formatters_.emplace_back(new details::A_formatter()); + break; + + case ('b'): + case ('h'): + formatters_.emplace_back(new details::b_formatter()); + break; + + case ('B'): + formatters_.emplace_back(new details::B_formatter()); + break; + case ('c'): + formatters_.emplace_back(new details::c_formatter()); + break; + + case ('C'): + formatters_.emplace_back(new details::C_formatter()); + break; + + case ('Y'): + formatters_.emplace_back(new details::Y_formatter()); + break; + + case ('D'): + case ('x'): + formatters_.emplace_back(new details::D_formatter()); + break; + + case ('m'): + formatters_.emplace_back(new details::m_formatter()); + break; + + case ('d'): + formatters_.emplace_back(new details::d_formatter()); + break; + + case ('H'): + formatters_.emplace_back(new details::H_formatter()); + break; + + case ('I'): + formatters_.emplace_back(new details::I_formatter()); + break; + + case ('M'): + formatters_.emplace_back(new details::M_formatter()); + break; + + case ('S'): + formatters_.emplace_back(new details::S_formatter()); + break; + + case ('e'): + formatters_.emplace_back(new details::e_formatter()); + break; + + case ('f'): + formatters_.emplace_back(new details::f_formatter()); + break; + case ('F'): + formatters_.emplace_back(new details::F_formatter()); + break; + + case ('E'): + formatters_.emplace_back(new details::E_formatter()); + break; + + case ('p'): + formatters_.emplace_back(new details::p_formatter()); + break; + + case ('r'): + formatters_.emplace_back(new details::r_formatter()); + break; + + case ('R'): + formatters_.emplace_back(new details::R_formatter()); + break; + + case ('T'): + case ('X'): + formatters_.emplace_back(new details::T_formatter()); + break; + + case ('z'): + formatters_.emplace_back(new details::z_formatter()); + break; + + case ('+'): + formatters_.emplace_back(new details::full_formatter()); + break; + + case ('P'): + formatters_.emplace_back(new details::pid_formatter()); + break; + + case ('i'): + formatters_.emplace_back(new details::i_formatter()); + break; + + case ('^'): + formatters_.emplace_back(new details::color_start_formatter()); + break; + + case ('$'): + formatters_.emplace_back(new details::color_stop_formatter()); + break; + + default: // Unknown flag appears as is + formatters_.emplace_back(new details::ch_formatter('%')); + formatters_.emplace_back(new details::ch_formatter(flag)); + break; + } + } + + void compile_pattern_(const std::string &pattern) + { + auto end = pattern.end(); + std::unique_ptr user_chars; + formatters_.clear(); + 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( + 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(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)); + } + } +}; +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/periodic_worker.h b/spdlog_lib/spdlog/details/periodic_worker.h new file mode 100644 index 0000000..acc1311 --- /dev/null +++ b/spdlog_lib/spdlog/details/periodic_worker.h @@ -0,0 +1,71 @@ + +// +// Copyright(c) 2018 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +// periodic worker thread - periodically executes the given callback function. +// +// RAII over the owned thread: +// creates the thread on construction. +// stops and joins the thread on destruction. + +#include +#include +#include +#include +#include +namespace spdlog { +namespace details { + +class periodic_worker +{ +public: + periodic_worker(std::function callback_fun, std::chrono::seconds interval) + { + active_ = (interval > std::chrono::seconds::zero()); + if (!active_) + { + return; + } + + worker_thread_ = std::thread([this, callback_fun, interval]() { + for (;;) + { + std::unique_lock lock(this->mutex_); + if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) + { + return; // active_ == false, so exit this thread + } + callback_fun(); + } + }); + } + + periodic_worker(const periodic_worker &) = delete; + periodic_worker &operator=(const periodic_worker &) = delete; + + // stop the worker thread and join it + ~periodic_worker() + { + if (worker_thread_.joinable()) + { + { + std::lock_guard lock(mutex_); + active_ = false; + } + cv_.notify_one(); + worker_thread_.join(); + } + } + +private: + bool active_; + std::thread worker_thread_; + std::mutex mutex_; + std::condition_variable cv_; +}; +} // namespace details +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/registry.h b/spdlog_lib/spdlog/details/registry.h new file mode 100644 index 0000000..b3db19a --- /dev/null +++ b/spdlog_lib/spdlog/details/registry.h @@ -0,0 +1,218 @@ +// +// 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/common.h" +#include "spdlog/details/periodic_worker.h" +#include "spdlog/logger.h" + +#include +#include +#include +#include +#include + +namespace spdlog { +namespace details { +class thread_pool; + +class registry +{ +public: + registry(const registry &) = delete; + registry &operator=(const registry &) = delete; + + void register_logger(std::shared_ptr new_logger) + { + std::lock_guard lock(logger_map_mutex_); + auto logger_name = new_logger->name(); + throw_if_exists_(logger_name); + loggers_[logger_name] = new_logger; + } + + void register_and_init(std::shared_ptr new_logger) + { + std::lock_guard lock(logger_map_mutex_); + auto logger_name = new_logger->name(); + throw_if_exists_(logger_name); + + // set the global formatter pattern + new_logger->set_formatter(formatter_->clone()); + + if (err_handler_) + { + new_logger->set_error_handler(err_handler_); + } + + new_logger->set_level(level_); + new_logger->flush_on(flush_level_); + + // add to registry + loggers_[logger_name] = new_logger; + } + + std::shared_ptr get(const std::string &logger_name) + { + std::lock_guard lock(logger_map_mutex_); + auto found = loggers_.find(logger_name); + return found == loggers_.end() ? nullptr : found->second; + } + + void set_tp(std::shared_ptr tp) + { + std::lock_guard lock(tp_mutex_); + tp_ = std::move(tp); + } + + std::shared_ptr get_tp() + { + std::lock_guard lock(tp_mutex_); + return tp_; + } + + // Set global formatter. Each sink in each logger will get a clone of this object + void set_formatter(std::unique_ptr formatter) + { + std::lock_guard lock(logger_map_mutex_); + formatter_ = std::move(formatter); + for (auto &l : loggers_) + { + l.second->set_formatter(formatter_->clone()); + } + } + + void set_level(level::level_enum log_level) + { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) + { + l.second->set_level(log_level); + } + level_ = log_level; + } + + void flush_on(level::level_enum log_level) + { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) + { + l.second->flush_on(log_level); + } + flush_level_ = log_level; + } + + void flush_every(std::chrono::seconds interval) + { + std::lock_guard lock(flusher_mutex_); + std::function clbk(std::bind(®istry::flush_all, this)); + periodic_flusher_.reset(new periodic_worker(clbk, interval)); + } + + void set_error_handler(log_err_handler handler) + { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) + { + l.second->set_error_handler(handler); + } + err_handler_ = handler; + } + + void apply_all(std::function)> fun) + { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) + { + fun(l.second); + } + } + + void flush_all() + { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) + { + l.second->flush(); + } + } + + void drop(const std::string &logger_name) + { + std::lock_guard lock(logger_map_mutex_); + loggers_.erase(logger_name); + } + + void drop_all() + { + std::lock_guard lock(logger_map_mutex_); + loggers_.clear(); + } + + // clean all reasources and threads started by the registry + void shutdown() + { + { + std::lock_guard lock(flusher_mutex_); + periodic_flusher_.reset(); + } + + drop_all(); + + { + std::lock_guard lock(tp_mutex_); + tp_.reset(); + } + } + + std::recursive_mutex &tp_mutex() + { + return tp_mutex_; + } + + static registry &instance() + { + static registry s_instance; + return s_instance; + } + +private: + registry() + : formatter_(new pattern_formatter("%+")) + { + } + + ~registry() + { + /*std::lock_guard lock(flusher_mutex_); + periodic_flusher_.reset();*/ + } + + 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"); + } + } + + std::mutex logger_map_mutex_, flusher_mutex_; + std::recursive_mutex tp_mutex_; + std::unordered_map> loggers_; + std::unique_ptr formatter_; + level::level_enum level_ = level::info; + level::level_enum flush_level_ = level::off; + log_err_handler err_handler_; + std::shared_ptr tp_; + std::unique_ptr periodic_flusher_; +}; + +} // namespace details +} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/thread_pool.h b/spdlog_lib/spdlog/details/thread_pool.h new file mode 100644 index 0000000..2620a19 --- /dev/null +++ b/spdlog_lib/spdlog/details/thread_pool.h @@ -0,0 +1,220 @@ +#pragma once + +#include "spdlog/details/log_msg.h" +#include "spdlog/details/mpmc_blocking_q.h" +#include "spdlog/details/os.h" + +#include +#include +#include +#include + +namespace spdlog { +namespace details { + +using async_logger_ptr = std::shared_ptr; + +enum class async_msg_type +{ + log, + flush, + terminate +}; + +// Async msg to move to/from the queue +// Movable only. should never be copied +struct async_msg +{ + async_msg_type msg_type; + level::level_enum level; + log_clock::time_point time; + size_t thread_id; + fmt::basic_memory_buffer raw; + + size_t msg_id; + async_logger_ptr worker_ptr; + + async_msg() = default; + ~async_msg() = default; + + // should only be moved in or out of the queue.. + async_msg(const async_msg &) = delete; + +// support for vs2013 move +#if defined(_MSC_VER) && _MSC_VER <= 1800 + async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type), + level(other.level), + time(other.time), + thread_id(other.thread_id), + raw(move(other.raw)), + msg_id(other.msg_id), + worker_ptr(std::move(other.worker_ptr)) + { + } + + async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT + { + msg_type = other.msg_type; + level = other.level; + time = other.time; + thread_id = other.thread_id; + raw = std::move(other.raw); + msg_id = other.msg_id; + worker_ptr = std::move(other.worker_ptr); + return *this; + } +#else // (_MSC_VER) && _MSC_VER <= 1800 + async_msg(async_msg &&other) = default; + async_msg &operator=(async_msg &&other) = default; +#endif + + // construct from log_msg with given type + async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &&m) + : msg_type(the_type) + , level(m.level) + , time(m.time) + , thread_id(m.thread_id) + , msg_id(m.msg_id) + , worker_ptr(std::forward(worker)) + { + fmt_helper::append_buf(m.raw, raw); + } + + async_msg(async_logger_ptr &&worker, async_msg_type the_type) + : async_msg(std::forward(worker), the_type, details::log_msg()) + { + } + + explicit async_msg(async_msg_type the_type) + : async_msg(nullptr, the_type, details::log_msg()) + { + } + + // copy into log_msg + void to_log_msg(log_msg &msg) + { + msg.logger_name = &worker_ptr->name(); + msg.level = level; + msg.time = time; + msg.thread_id = thread_id; + fmt_helper::append_buf(raw, msg.raw); + msg.msg_id = msg_id; + msg.color_range_start = 0; + msg.color_range_end = 0; + } +}; + +class thread_pool +{ +public: + using item_type = async_msg; + using q_type = details::mpmc_blocking_queue; + + thread_pool(size_t q_max_items, size_t threads_n) + : q_(q_max_items) + { + // std::cout << "thread_pool() q_size_bytes: " << q_size_bytes << + // "\tthreads_n: " << threads_n << std::endl; + if (threads_n == 0 || threads_n > 1000) + { + throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid " + "range is 1-1000)"); + } + for (size_t i = 0; i < threads_n; i++) + { + threads_.emplace_back(std::bind(&thread_pool::worker_loop_, this)); + } + } + + // message all threads to terminate gracefully join them + ~thread_pool() + { + try + { + for (size_t i = 0; i < threads_.size(); i++) + { + post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block); + } + + for (auto &t : threads_) + { + t.join(); + } + } + catch (...) + { + } + } + + void post_log(async_logger_ptr &&worker_ptr, details::log_msg &&msg, async_overflow_policy overflow_policy) + { + async_msg async_m(std::forward(worker_ptr), async_msg_type::log, std::forward(msg)); + post_async_msg_(std::move(async_m), overflow_policy); + } + + void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy) + { + post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy); + } + +private: + q_type q_; + + std::vector threads_; + + void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) + { + if (overflow_policy == async_overflow_policy::block) + { + q_.enqueue(std::move(new_msg)); + } + else + { + q_.enqueue_nowait(std::move(new_msg)); + } + } + + void worker_loop_() + { + while (process_next_msg_()) {}; + } + + // process next message in the queue + // return true if this thread should still be active (while no terminate msg + // was received) + bool process_next_msg_() + { + async_msg incoming_async_msg; + bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10)); + if (!dequeued) + { + return true; + } + + switch (incoming_async_msg.msg_type) + { + case async_msg_type::flush: + { + incoming_async_msg.worker_ptr->backend_flush_(); + return true; + } + + case async_msg_type::terminate: + { + return false; + } + + default: + { + log_msg msg; + incoming_async_msg.to_log_msg(msg); + incoming_async_msg.worker_ptr->backend_log_(msg); + return true; + } + } + return true; // should not be reached + } +}; + +} // namespace details +} // namespace spdlog \ No newline at end of file diff --git a/spdlog_lib/spdlog/fmt/bundled/LICENSE.rst b/spdlog_lib/spdlog/fmt/bundled/LICENSE.rst new file mode 100644 index 0000000..eb6be65 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/LICENSE.rst @@ -0,0 +1,23 @@ +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. diff --git a/spdlog_lib/spdlog/fmt/bundled/colors.h b/spdlog_lib/spdlog/fmt/bundled/colors.h new file mode 100644 index 0000000..003a667 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/colors.h @@ -0,0 +1,257 @@ +// Formatting library for C++ - the core API +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. +// +// Copyright (c) 2018 - present, Remotion (Igor Schulz) +// All Rights Reserved +// {fmt} support for rgb color output. + +#ifndef FMT_COLORS_H_ +#define FMT_COLORS_H_ + +#include "format.h" + +FMT_BEGIN_NAMESPACE + +// rgb is a struct for red, green and blue colors. +// We use rgb as name because some editors will show it as color direct in the +// editor. +struct rgb +{ + FMT_CONSTEXPR_DECL rgb() + : r(0) + , g(0) + , b(0) + { + } + FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_) + : r(r_) + , g(g_) + , b(b_) + { + } + FMT_CONSTEXPR_DECL rgb(uint32_t hex) + : r((hex >> 16) & 0xFF) + , g((hex >> 8) & 0xFF) + , b((hex)&0xFF) + { + } + uint8_t r; + uint8_t g; + uint8_t b; +}; + +namespace internal { + +FMT_CONSTEXPR inline void to_esc(uint8_t c, char out[], int offset) +{ + out[offset + 0] = static_cast('0' + c / 100); + out[offset + 1] = static_cast('0' + c / 10 % 10); + out[offset + 2] = static_cast('0' + c % 10); +} + +} // namespace internal + +FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) +{ + char escape_fd[] = "\x1b[38;2;000;000;000m"; + static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m"; + internal::to_esc(fd.r, escape_fd, 7); + internal::to_esc(fd.g, escape_fd, 11); + internal::to_esc(fd.b, escape_fd, 15); + + std::fputs(escape_fd, stdout); + vprint(format, args); + std::fputs(RESET_COLOR, stdout); +} + +FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) +{ + char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color + char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color + static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m"; + internal::to_esc(fd.r, escape_fd, 7); + internal::to_esc(fd.g, escape_fd, 11); + internal::to_esc(fd.b, escape_fd, 15); + + internal::to_esc(bg.r, escape_bg, 7); + internal::to_esc(bg.g, escape_bg, 11); + internal::to_esc(bg.b, escape_bg, 15); + + std::fputs(escape_fd, stdout); + std::fputs(escape_bg, stdout); + vprint(format, args); + std::fputs(RESET_COLOR, stdout); +} + +template +inline void print_rgb(rgb fd, string_view format_str, const Args &... args) +{ + vprint_rgb(fd, format_str, make_format_args(args...)); +} + +// rgb foreground color +template +inline void print(rgb fd, string_view format_str, const Args &... args) +{ + vprint_rgb(fd, format_str, make_format_args(args...)); +} + +// rgb foreground color and background color +template +inline void print(rgb fd, rgb bg, string_view format_str, const Args &... args) +{ + vprint_rgb(fd, bg, format_str, make_format_args(args...)); +} + +enum class color : uint32_t +{ + alice_blue = 0xF0F8FF, // rgb(240,248,255) + antique_white = 0xFAEBD7, // rgb(250,235,215) + aqua = 0x00FFFF, // rgb(0,255,255) + aquamarine = 0x7FFFD4, // rgb(127,255,212) + azure = 0xF0FFFF, // rgb(240,255,255) + beige = 0xF5F5DC, // rgb(245,245,220) + bisque = 0xFFE4C4, // rgb(255,228,196) + black = 0x000000, // rgb(0,0,0) + blanched_almond = 0xFFEBCD, // rgb(255,235,205) + blue = 0x0000FF, // rgb(0,0,255) + blue_violet = 0x8A2BE2, // rgb(138,43,226) + brown = 0xA52A2A, // rgb(165,42,42) + burly_wood = 0xDEB887, // rgb(222,184,135) + cadet_blue = 0x5F9EA0, // rgb(95,158,160) + chartreuse = 0x7FFF00, // rgb(127,255,0) + chocolate = 0xD2691E, // rgb(210,105,30) + coral = 0xFF7F50, // rgb(255,127,80) + cornflower_blue = 0x6495ED, // rgb(100,149,237) + cornsilk = 0xFFF8DC, // rgb(255,248,220) + crimson = 0xDC143C, // rgb(220,20,60) + cyan = 0x00FFFF, // rgb(0,255,255) + dark_blue = 0x00008B, // rgb(0,0,139) + dark_cyan = 0x008B8B, // rgb(0,139,139) + dark_golden_rod = 0xB8860B, // rgb(184,134,11) + dark_gray = 0xA9A9A9, // rgb(169,169,169) + dark_green = 0x006400, // rgb(0,100,0) + dark_khaki = 0xBDB76B, // rgb(189,183,107) + dark_magenta = 0x8B008B, // rgb(139,0,139) + dark_olive_green = 0x556B2F, // rgb(85,107,47) + dark_orange = 0xFF8C00, // rgb(255,140,0) + dark_orchid = 0x9932CC, // rgb(153,50,204) + dark_red = 0x8B0000, // rgb(139,0,0) + dark_salmon = 0xE9967A, // rgb(233,150,122) + dark_sea_green = 0x8FBC8F, // rgb(143,188,143) + dark_slate_blue = 0x483D8B, // rgb(72,61,139) + dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) + dark_turquoise = 0x00CED1, // rgb(0,206,209) + dark_violet = 0x9400D3, // rgb(148,0,211) + deep_pink = 0xFF1493, // rgb(255,20,147) + deep_sky_blue = 0x00BFFF, // rgb(0,191,255) + dim_gray = 0x696969, // rgb(105,105,105) + dodger_blue = 0x1E90FF, // rgb(30,144,255) + fire_brick = 0xB22222, // rgb(178,34,34) + floral_white = 0xFFFAF0, // rgb(255,250,240) + forest_green = 0x228B22, // rgb(34,139,34) + fuchsia = 0xFF00FF, // rgb(255,0,255) + gainsboro = 0xDCDCDC, // rgb(220,220,220) + ghost_white = 0xF8F8FF, // rgb(248,248,255) + gold = 0xFFD700, // rgb(255,215,0) + golden_rod = 0xDAA520, // rgb(218,165,32) + gray = 0x808080, // rgb(128,128,128) + green = 0x008000, // rgb(0,128,0) + green_yellow = 0xADFF2F, // rgb(173,255,47) + honey_dew = 0xF0FFF0, // rgb(240,255,240) + hot_pink = 0xFF69B4, // rgb(255,105,180) + indian_red = 0xCD5C5C, // rgb(205,92,92) + indigo = 0x4B0082, // rgb(75,0,130) + ivory = 0xFFFFF0, // rgb(255,255,240) + khaki = 0xF0E68C, // rgb(240,230,140) + lavender = 0xE6E6FA, // rgb(230,230,250) + lavender_blush = 0xFFF0F5, // rgb(255,240,245) + lawn_green = 0x7CFC00, // rgb(124,252,0) + lemon_chiffon = 0xFFFACD, // rgb(255,250,205) + light_blue = 0xADD8E6, // rgb(173,216,230) + light_coral = 0xF08080, // rgb(240,128,128) + light_cyan = 0xE0FFFF, // rgb(224,255,255) + light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) + light_gray = 0xD3D3D3, // rgb(211,211,211) + light_green = 0x90EE90, // rgb(144,238,144) + light_pink = 0xFFB6C1, // rgb(255,182,193) + light_salmon = 0xFFA07A, // rgb(255,160,122) + light_sea_green = 0x20B2AA, // rgb(32,178,170) + light_sky_blue = 0x87CEFA, // rgb(135,206,250) + light_slate_gray = 0x778899, // rgb(119,136,153) + light_steel_blue = 0xB0C4DE, // rgb(176,196,222) + light_yellow = 0xFFFFE0, // rgb(255,255,224) + lime = 0x00FF00, // rgb(0,255,0) + lime_green = 0x32CD32, // rgb(50,205,50) + linen = 0xFAF0E6, // rgb(250,240,230) + magenta = 0xFF00FF, // rgb(255,0,255) + maroon = 0x800000, // rgb(128,0,0) + medium_aqua_marine = 0x66CDAA, // rgb(102,205,170) + medium_blue = 0x0000CD, // rgb(0,0,205) + medium_orchid = 0xBA55D3, // rgb(186,85,211) + medium_purple = 0x9370DB, // rgb(147,112,219) + medium_sea_green = 0x3CB371, // rgb(60,179,113) + medium_slate_blue = 0x7B68EE, // rgb(123,104,238) + medium_spring_green = 0x00FA9A, // rgb(0,250,154) + medium_turquoise = 0x48D1CC, // rgb(72,209,204) + medium_violet_red = 0xC71585, // rgb(199,21,133) + midnight_blue = 0x191970, // rgb(25,25,112) + mint_cream = 0xF5FFFA, // rgb(245,255,250) + misty_rose = 0xFFE4E1, // rgb(255,228,225) + moccasin = 0xFFE4B5, // rgb(255,228,181) + navajo_white = 0xFFDEAD, // rgb(255,222,173) + navy = 0x000080, // rgb(0,0,128) + old_lace = 0xFDF5E6, // rgb(253,245,230) + olive = 0x808000, // rgb(128,128,0) + olive_drab = 0x6B8E23, // rgb(107,142,35) + orange = 0xFFA500, // rgb(255,165,0) + orange_red = 0xFF4500, // rgb(255,69,0) + orchid = 0xDA70D6, // rgb(218,112,214) + pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) + pale_green = 0x98FB98, // rgb(152,251,152) + pale_turquoise = 0xAFEEEE, // rgb(175,238,238) + pale_violet_red = 0xDB7093, // rgb(219,112,147) + papaya_whip = 0xFFEFD5, // rgb(255,239,213) + peach_puff = 0xFFDAB9, // rgb(255,218,185) + peru = 0xCD853F, // rgb(205,133,63) + pink = 0xFFC0CB, // rgb(255,192,203) + plum = 0xDDA0DD, // rgb(221,160,221) + powder_blue = 0xB0E0E6, // rgb(176,224,230) + purple = 0x800080, // rgb(128,0,128) + rebecca_purple = 0x663399, // rgb(102,51,153) + red = 0xFF0000, // rgb(255,0,0) + rosy_brown = 0xBC8F8F, // rgb(188,143,143) + royal_blue = 0x4169E1, // rgb(65,105,225) + saddle_brown = 0x8B4513, // rgb(139,69,19) + salmon = 0xFA8072, // rgb(250,128,114) + sandy_brown = 0xF4A460, // rgb(244,164,96) + sea_green = 0x2E8B57, // rgb(46,139,87) + sea_shell = 0xFFF5EE, // rgb(255,245,238) + sienna = 0xA0522D, // rgb(160,82,45) + silver = 0xC0C0C0, // rgb(192,192,192) + sky_blue = 0x87CEEB, // rgb(135,206,235) + slate_blue = 0x6A5ACD, // rgb(106,90,205) + slate_gray = 0x708090, // rgb(112,128,144) + snow = 0xFFFAFA, // rgb(255,250,250) + spring_green = 0x00FF7F, // rgb(0,255,127) + steel_blue = 0x4682B4, // rgb(70,130,180) + tan = 0xD2B48C, // rgb(210,180,140) + teal = 0x008080, // rgb(0,128,128) + thistle = 0xD8BFD8, // rgb(216,191,216) + tomato = 0xFF6347, // rgb(255,99,71) + turquoise = 0x40E0D0, // rgb(64,224,208) + violet = 0xEE82EE, // rgb(238,130,238) + wheat = 0xF5DEB3, // rgb(245,222,179) + white = 0xFFFFFF, // rgb(255,255,255) + white_smoke = 0xF5F5F5, // rgb(245,245,245) + yellow = 0xFFFF00, // rgb(255,255,0) + yellow_green = 0x9ACD32, // rgb(154,205,50) +}; // enum class colors + +FMT_END_NAMESPACE + +#endif // FMT_COLORS_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/core.h b/spdlog_lib/spdlog/fmt/bundled/core.h new file mode 100644 index 0000000..19273a6 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/core.h @@ -0,0 +1,1578 @@ +// Formatting library for C++ - the core API +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_CORE_H_ +#define FMT_CORE_H_ + +#include +#include +#include +#include +#include +#include + +// The fmt library version in the form major * 10000 + minor * 100 + patch. +#define FMT_VERSION 50100 + +#ifdef __has_feature +#define FMT_HAS_FEATURE(x) __has_feature(x) +#else +#define FMT_HAS_FEATURE(x) 0 +#endif + +#ifdef __has_include +#define FMT_HAS_INCLUDE(x) __has_include(x) +#else +#define FMT_HAS_INCLUDE(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 + +#if defined(__GNUC__) && !defined(__clang__) +#define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#else +#define FMT_GCC_VERSION 0 +#endif + +#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) +#define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION +#else +#define FMT_HAS_GXX_CXX11 0 +#endif + +#ifdef _MSC_VER +#define FMT_MSC_VER _MSC_VER +#else +#define FMT_MSC_VER 0 +#endif + +// Check if relaxed c++14 constexpr is supported. +// GCC doesn't allow throw in constexpr until version 6 (bug 67371). +#ifndef FMT_USE_CONSTEXPR +#define FMT_USE_CONSTEXPR \ + (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) +#endif +#if FMT_USE_CONSTEXPR +#define FMT_CONSTEXPR constexpr +#define FMT_CONSTEXPR_DECL constexpr +#else +#define FMT_CONSTEXPR inline +#define FMT_CONSTEXPR_DECL +#endif + +#ifndef FMT_OVERRIDE +#if 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 + +#if FMT_HAS_FEATURE(cxx_explicit_conversions) || FMT_MSC_VER >= 1800 +#define FMT_EXPLICIT explicit +#else +#define FMT_EXPLICIT +#endif + +#ifndef FMT_NULL +#if FMT_HAS_FEATURE(cxx_nullptr) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600 +#define FMT_NULL nullptr +#define FMT_USE_NULLPTR 1 +#else +#define FMT_NULL NULL +#endif +#endif + +#ifndef FMT_USE_NULLPTR +#define FMT_USE_NULLPTR 0 +#endif + +#if FMT_HAS_CPP_ATTRIBUTE(noreturn) +#define FMT_NORETURN [[noreturn]] +#else +#define FMT_NORETURN +#endif + +// Check if exceptions are disabled. +#if defined(__GNUC__) && !defined(__EXCEPTIONS) +#define FMT_EXCEPTIONS 0 +#elif FMT_MSC_VER && !_HAS_EXCEPTIONS +#define FMT_EXCEPTIONS 0 +#endif +#ifndef FMT_EXCEPTIONS +#define FMT_EXCEPTIONS 1 +#endif + +// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature). +#ifndef FMT_USE_NOEXCEPT +#define FMT_USE_NOEXCEPT 0 +#endif + +#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900 +#define FMT_DETECTED_NOEXCEPT noexcept +#else +#define FMT_DETECTED_NOEXCEPT throw() +#endif + +#ifndef FMT_NOEXCEPT +#if FMT_EXCEPTIONS +#define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT +#else +#define FMT_NOEXCEPT +#endif +#endif + +// This is needed because GCC still uses throw() in its headers when exceptions +// are disabled. +#if FMT_GCC_VERSION +#define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT +#else +#define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT +#endif + +#ifndef FMT_BEGIN_NAMESPACE +#if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || FMT_MSC_VER >= 1900 +#define FMT_INLINE_NAMESPACE inline namespace +#define FMT_END_NAMESPACE \ + } \ + } +#else +#define FMT_INLINE_NAMESPACE namespace +#define FMT_END_NAMESPACE \ + } \ + using namespace v5; \ + } +#endif +#define FMT_BEGIN_NAMESPACE \ + namespace fmt { \ + FMT_INLINE_NAMESPACE v5 \ + { +#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 + +#ifndef FMT_ASSERT +#define FMT_ASSERT(condition, message) assert((condition) && message) +#endif + +#define FMT_DELETED = delete + +// A macro to disallow the copy construction and assignment. +#define FMT_DISALLOW_COPY_AND_ASSIGN(Type) \ + Type(const Type &) FMT_DELETED; \ + void operator=(const Type &) FMT_DELETED + +// libc++ supports string_view in pre-c++17. +#if (FMT_HAS_INCLUDE() && (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \ + (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910) +#include +#define FMT_USE_STD_STRING_VIEW +#elif (FMT_HAS_INCLUDE() && __cplusplus >= 201402L) +#include +#define FMT_USE_EXPERIMENTAL_STRING_VIEW +#endif + +// std::result_of is defined in in gcc 4.4. +#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404 +#include +#endif + +FMT_BEGIN_NAMESPACE + +namespace internal { + +// An implementation of declval for pre-C++11 compilers such as gcc 4. +template +typename std::add_rvalue_reference::type declval() FMT_NOEXCEPT; + +// Casts nonnegative integer to unsigned. +template +FMT_CONSTEXPR typename std::make_unsigned::type to_unsigned(Int value) +{ + FMT_ASSERT(value >= 0, "negative value"); + return static_cast::type>(value); +} + +} // namespace internal + +/** + An implementation of ``std::basic_string_view`` for pre-C++17. It provides a + subset of the API. ``fmt::basic_string_view`` is used for format strings even + if ``std::string_view`` is available to prevent issues when a library is + compiled with a different ``-std`` option than the client code (which is not + recommended). + */ +template +class basic_string_view +{ +private: + const Char *data_; + size_t size_; + +public: + typedef Char char_type; + typedef const Char *iterator; + +// Standard basic_string_view type. +#if defined(FMT_USE_STD_STRING_VIEW) + typedef std::basic_string_view type; +#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) + typedef std::experimental::basic_string_view type; +#else + struct type + { + const char *data() const + { + return FMT_NULL; + } + size_t size() const + { + return 0; + } + }; +#endif + + FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {} + + /** Constructs a string reference object from a C string and a size. */ + FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT : data_(s), size_(count) {} + + /** + \rst + Constructs a string reference object from a C string computing + the size with ``std::char_traits::length``. + \endrst + */ + basic_string_view(const Char *s) + : data_(s) + , size_(std::char_traits::length(s)) + { + } + + /** Constructs a string reference from a ``std::basic_string`` object. */ + template + FMT_CONSTEXPR basic_string_view(const std::basic_string &s) FMT_NOEXCEPT : data_(s.c_str()), size_(s.size()) + { + } + + FMT_CONSTEXPR basic_string_view(type s) FMT_NOEXCEPT : data_(s.data()), size_(s.size()) {} + + /** Returns a pointer to the string data. */ + const Char *data() const + { + return data_; + } + + /** Returns the string size. */ + FMT_CONSTEXPR size_t size() const + { + return size_; + } + + FMT_CONSTEXPR iterator begin() const + { + return data_; + } + FMT_CONSTEXPR iterator end() const + { + return data_ + size_; + } + + FMT_CONSTEXPR void remove_prefix(size_t n) + { + data_ += n; + size_ -= n; + } + + // Lexicographically compare this string reference to other. + int compare(basic_string_view other) const + { + size_t str_size = size_ < other.size_ ? size_ : other.size_; + int result = std::char_traits::compare(data_, other.data_, str_size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + friend bool operator==(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) == 0; + } + friend bool operator!=(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) != 0; + } + friend bool operator<(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) < 0; + } + friend bool operator<=(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) <= 0; + } + friend bool operator>(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) > 0; + } + friend bool operator>=(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) >= 0; + } +}; + +typedef basic_string_view string_view; +typedef basic_string_view wstring_view; + +template +class basic_format_arg; + +template +class basic_format_args; + +// A formatter for objects of type T. +template +struct formatter; + +namespace internal { + +/** A contiguous memory buffer with an optional growing ability. */ +template +class basic_buffer +{ +private: + FMT_DISALLOW_COPY_AND_ASSIGN(basic_buffer); + + T *ptr_; + std::size_t size_; + std::size_t capacity_; + +protected: + basic_buffer(T *p = FMT_NULL, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT : ptr_(p), size_(sz), capacity_(cap) {} + + /** Sets the buffer data and capacity. */ + void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT + { + ptr_ = buf_data; + capacity_ = buf_capacity; + } + + /** Increases the buffer capacity to hold at least *capacity* elements. */ + virtual void grow(std::size_t capacity) = 0; + +public: + typedef T value_type; + typedef const T &const_reference; + + virtual ~basic_buffer() {} + + T *begin() FMT_NOEXCEPT + { + return ptr_; + } + T *end() FMT_NOEXCEPT + { + return ptr_ + size_; + } + + /** Returns the size of this buffer. */ + std::size_t size() const FMT_NOEXCEPT + { + return size_; + } + + /** Returns the capacity of this buffer. */ + std::size_t capacity() const FMT_NOEXCEPT + { + return capacity_; + } + + /** Returns a pointer to the buffer data. */ + T *data() FMT_NOEXCEPT + { + return ptr_; + } + + /** Returns a pointer to the buffer data. */ + const T *data() const FMT_NOEXCEPT + { + return ptr_; + } + + /** + Resizes the buffer. If T is a POD type new elements may not be initialized. + */ + void resize(std::size_t new_size) + { + reserve(new_size); + size_ = new_size; + } + + /** Reserves space to store at least *capacity* elements. */ + void reserve(std::size_t new_capacity) + { + if (new_capacity > capacity_) + grow(new_capacity); + } + + void push_back(const T &value) + { + reserve(size_ + 1); + ptr_[size_++] = value; + } + + /** Appends data to the end of the buffer. */ + template + 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]; + } +}; + +typedef basic_buffer buffer; +typedef basic_buffer wbuffer; + +// A container-backed buffer. +template +class container_buffer : public basic_buffer +{ +private: + Container &container_; + +protected: + void grow(std::size_t capacity) FMT_OVERRIDE + { + container_.resize(capacity); + this->set(&container_[0], capacity); + } + +public: + explicit container_buffer(Container &c) + : basic_buffer(&c[0], c.size(), c.size()) + , container_(c) + { + } +}; + +struct error_handler +{ + FMT_CONSTEXPR error_handler() {} + FMT_CONSTEXPR error_handler(const error_handler &) {} + + // This function is intentionally not constexpr to give a compile-time error. + FMT_API void on_error(const char *message); +}; + +// Formatting of wide characters and strings into a narrow output is disallowed: +// fmt::format("{}", L"test"); // error +// To fix this, use a wide format string: +// fmt::format(L"{}", L"test"); +template +inline void require_wchar() +{ + static_assert(std::is_same::value, "formatting of wide characters into a narrow output is disallowed"); +} + +template +struct named_arg_base; + +template +struct named_arg; + +template +struct is_named_arg : std::false_type +{ +}; + +template +struct is_named_arg> : std::true_type +{ +}; + +enum type +{ + none_type, + named_arg_type, + // Integer types should go first, + int_type, + uint_type, + long_long_type, + ulong_long_type, + bool_type, + char_type, + last_integer_type = char_type, + // followed by floating-point types. + double_type, + long_double_type, + last_numeric_type = long_double_type, + cstring_type, + string_type, + pointer_type, + custom_type +}; + +FMT_CONSTEXPR bool is_integral(type t) +{ + FMT_ASSERT(t != internal::named_arg_type, "invalid argument type"); + return t > internal::none_type && t <= internal::last_integer_type; +} + +FMT_CONSTEXPR bool is_arithmetic(type t) +{ + FMT_ASSERT(t != internal::named_arg_type, "invalid argument type"); + return t > internal::none_type && t <= internal::last_numeric_type; +} + +template +struct convert_to_int +{ + enum + { + value = !std::is_arithmetic::value && std::is_convertible::value + }; +}; + +template +struct string_value +{ + const Char *value; + std::size_t size; +}; + +template +struct custom_value +{ + const void *value; + void (*format)(const void *arg, Context &ctx); +}; + +// A formatting argument value. +template +class value +{ +public: + typedef typename Context::char_type char_type; + + union + { + int int_value; + unsigned uint_value; + long long long_long_value; + unsigned long long ulong_long_value; + double double_value; + long double long_double_value; + const void *pointer; + string_value string; + string_value sstring; + string_value ustring; + custom_value custom; + }; + + FMT_CONSTEXPR value(int val = 0) + : int_value(val) + { + } + value(unsigned val) + { + uint_value = val; + } + value(long long val) + { + long_long_value = val; + } + value(unsigned long long val) + { + ulong_long_value = val; + } + value(double val) + { + double_value = val; + } + value(long double val) + { + long_double_value = val; + } + value(const char_type *val) + { + string.value = val; + } + value(const signed char *val) + { + static_assert(std::is_same::value, "incompatible string types"); + sstring.value = val; + } + value(const unsigned char *val) + { + static_assert(std::is_same::value, "incompatible string types"); + ustring.value = val; + } + value(basic_string_view val) + { + string.value = val.data(); + string.size = val.size(); + } + value(const void *val) + { + pointer = val; + } + + template + explicit value(const T &val) + { + custom.value = &val; + custom.format = &format_custom_arg; + } + + const named_arg_base &as_named_arg() + { + return *static_cast *>(pointer); + } + +private: + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg(const void *arg, Context &ctx) + { + // Get the formatter type through the context to allow different contexts + // have different extension points, e.g. `formatter` for `format` and + // `printf_formatter` for `printf`. + typename Context::template formatter_type::type f; + auto &&parse_ctx = ctx.parse_context(); + parse_ctx.advance_to(f.parse(parse_ctx)); + ctx.advance_to(f.format(*static_cast(arg), ctx)); + } +}; + +template +struct typed_value : value +{ + static const type type_tag = TYPE; + + template + FMT_CONSTEXPR typed_value(const T &val) + : value(val) + { + } +}; + +template +FMT_CONSTEXPR basic_format_arg make_arg(const T &value); + +#define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \ + template \ + FMT_CONSTEXPR typed_value make_value(ArgType val) \ + { \ + return static_cast(val); \ + } + +#define FMT_MAKE_VALUE_SAME(TAG, Type) \ + template \ + FMT_CONSTEXPR typed_value make_value(Type val) \ + { \ + return val; \ + } + +FMT_MAKE_VALUE(bool_type, bool, int) +FMT_MAKE_VALUE(int_type, short, int) +FMT_MAKE_VALUE(uint_type, unsigned short, unsigned) +FMT_MAKE_VALUE_SAME(int_type, int) +FMT_MAKE_VALUE_SAME(uint_type, unsigned) + +// 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. +typedef std::conditional::type long_type; +FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type) +typedef std::conditional::type ulong_type; +FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type), unsigned long, ulong_type) + +FMT_MAKE_VALUE_SAME(long_long_type, long long) +FMT_MAKE_VALUE_SAME(ulong_long_type, unsigned long long) +FMT_MAKE_VALUE(int_type, signed char, int) +FMT_MAKE_VALUE(uint_type, unsigned char, unsigned) +FMT_MAKE_VALUE(char_type, char, int) + +#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) +template +inline typed_value make_value(wchar_t val) +{ + require_wchar(); + return static_cast(val); +} +#endif + +FMT_MAKE_VALUE(double_type, float, double) +FMT_MAKE_VALUE_SAME(double_type, double) +FMT_MAKE_VALUE_SAME(long_double_type, long double) + +// Formatting of wide strings into a narrow buffer and multibyte strings +// into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606). +FMT_MAKE_VALUE(cstring_type, typename C::char_type *, const typename C::char_type *) +FMT_MAKE_VALUE(cstring_type, const typename C::char_type *, const typename C::char_type *) + +FMT_MAKE_VALUE(cstring_type, signed char *, const signed char *) +FMT_MAKE_VALUE_SAME(cstring_type, const signed char *) +FMT_MAKE_VALUE(cstring_type, unsigned char *, const unsigned char *) +FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char *) +FMT_MAKE_VALUE_SAME(string_type, basic_string_view) +FMT_MAKE_VALUE(string_type, typename basic_string_view::type, basic_string_view) +FMT_MAKE_VALUE(string_type, const std::basic_string &, basic_string_view) +FMT_MAKE_VALUE(pointer_type, void *, const void *) +FMT_MAKE_VALUE_SAME(pointer_type, const void *) + +#if FMT_USE_NULLPTR +FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void *) +#endif + +// Formatting of arbitrary pointers is disallowed. 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. +template +typename std::enable_if::value>::type make_value(const T *) +{ + static_assert(!sizeof(T), "formatting of non-void pointers is disallowed"); +} + +template +inline typename std::enable_if::value && convert_to_int::value, typed_value>::type +make_value(const T &val) +{ + return static_cast(val); +} + +template +inline typename std::enable_if::value && !std::is_convertible>::value, + // Implicit conversion to std::string is not handled here because it's + // unsafe: https://github.com/fmtlib/fmt/issues/729 + typed_value>::type +make_value(const T &val) +{ + return val; +} + +template +typed_value make_value(const named_arg &val) +{ + basic_format_arg arg = make_arg(val.value); + std::memcpy(val.data, &arg, sizeof(arg)); + return static_cast(&val); +} + +// Maximum number of arguments with packed types. +enum +{ + max_packed_args = 15 +}; + +template +class arg_map; + +template +struct result_of; + +template +struct result_of +{ + // A workaround for gcc 4.4 that doesn't allow F to be a reference. + typedef typename std::result_of::type(Args...)>::type type; +}; +} // namespace internal + +// A formatting argument. It is a trivially copyable/constructible type to +// allow storage in basic_memory_buffer. +template +class basic_format_arg +{ +private: + internal::value value_; + internal::type type_; + + template + friend FMT_CONSTEXPR basic_format_arg internal::make_arg(const T &value); + + template + friend FMT_CONSTEXPR typename internal::result_of::type visit(Visitor &&vis, basic_format_arg arg); + + friend class basic_format_args; + friend class internal::arg_map; + + typedef typename Context::char_type char_type; + +public: + class handle + { + public: + explicit handle(internal::custom_value custom) + : custom_(custom) + { + } + + void format(Context &ctx) const + { + custom_.format(custom_.value, ctx); + } + + private: + internal::custom_value custom_; + }; + + FMT_CONSTEXPR basic_format_arg() + : type_(internal::none_type) + { + } + + FMT_EXPLICIT operator bool() const FMT_NOEXCEPT + { + return type_ != internal::none_type; + } + + internal::type type() const + { + return type_; + } + + bool is_integral() const + { + return internal::is_integral(type_); + } + bool is_arithmetic() const + { + return internal::is_arithmetic(type_); + } +}; + +// Parsing context consisting of a format string range being parsed and an +// argument counter for automatic indexing. +template +class basic_parse_context : private ErrorHandler +{ +private: + basic_string_view format_str_; + int next_arg_id_; + +public: + typedef Char char_type; + typedef typename basic_string_view::iterator iterator; + + explicit FMT_CONSTEXPR basic_parse_context(basic_string_view format_str, ErrorHandler eh = ErrorHandler()) + : ErrorHandler(eh) + , format_str_(format_str) + , next_arg_id_(0) + { + } + + // Returns an iterator to the beginning of the format string range being + // parsed. + FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT + { + return format_str_.begin(); + } + + // Returns an iterator past the end of the format string range being parsed. + FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT + { + return format_str_.end(); + } + + // Advances the begin iterator to ``it``. + FMT_CONSTEXPR void advance_to(iterator it) + { + format_str_.remove_prefix(internal::to_unsigned(it - begin())); + } + + // Returns the next argument index. + FMT_CONSTEXPR unsigned next_arg_id(); + + FMT_CONSTEXPR bool check_arg_id(unsigned) + { + if (next_arg_id_ > 0) + { + on_error("cannot switch from automatic to manual argument indexing"); + return false; + } + next_arg_id_ = -1; + return true; + } + void check_arg_id(basic_string_view) {} + + FMT_CONSTEXPR void on_error(const char *message) + { + ErrorHandler::on_error(message); + } + + FMT_CONSTEXPR ErrorHandler error_handler() const + { + return *this; + } +}; + +typedef basic_parse_context parse_context; +typedef basic_parse_context wparse_context; + +namespace internal { +// A map from argument names to their values for named arguments. +template +class arg_map +{ +private: + FMT_DISALLOW_COPY_AND_ASSIGN(arg_map); + + typedef typename Context::char_type char_type; + + struct entry + { + basic_string_view name; + basic_format_arg arg; + }; + + entry *map_; + unsigned size_; + + void push_back(value val) + { + const internal::named_arg_base &named = val.as_named_arg(); + map_[size_] = entry{named.name, named.template deserialize()}; + ++size_; + } + +public: + arg_map() + : map_(FMT_NULL) + , size_(0) + { + } + void init(const basic_format_args &args); + ~arg_map() + { + delete[] map_; + } + + basic_format_arg find(basic_string_view name) const + { + // The list is unsorted, so just return the first matching name. + for (entry *it = map_, *end = map_ + size_; it != end; ++it) + { + if (it->name == name) + return it->arg; + } + return basic_format_arg(); + } +}; + +template +class context_base +{ +public: + typedef OutputIt iterator; + +private: + basic_parse_context parse_context_; + iterator out_; + basic_format_args args_; + +protected: + typedef Char char_type; + typedef basic_format_arg format_arg; + + context_base(OutputIt out, basic_string_view format_str, basic_format_args ctx_args) + : parse_context_(format_str) + , out_(out) + , args_(ctx_args) + { + } + + // Returns the argument with specified index. + format_arg do_get_arg(unsigned arg_id) + { + format_arg arg = args_.get(arg_id); + if (!arg) + parse_context_.on_error("argument index out of range"); + return arg; + } + + // Checks if manual indexing is used and returns the argument with + // specified index. + format_arg get_arg(unsigned arg_id) + { + return this->parse_context().check_arg_id(arg_id) ? this->do_get_arg(arg_id) : format_arg(); + } + +public: + basic_parse_context &parse_context() + { + return parse_context_; + } + + internal::error_handler error_handler() + { + return parse_context_.error_handler(); + } + + void on_error(const char *message) + { + parse_context_.on_error(message); + } + + // Returns an iterator to the beginning of the output range. + iterator out() + { + return out_; + } + iterator begin() + { + return out_; + } // deprecated + + // Advances the begin iterator to ``it``. + void advance_to(iterator it) + { + out_ = it; + } + + basic_format_args args() const + { + return args_; + } +}; + +// Extracts a reference to the container from back_insert_iterator. +template +inline Container &get_container(std::back_insert_iterator it) +{ + typedef std::back_insert_iterator bi_iterator; + struct accessor : bi_iterator + { + accessor(bi_iterator iter) + : bi_iterator(iter) + { + } + using bi_iterator::container; + }; + return *accessor(it).container; +} +} // namespace internal + +// Formatting context. +template +class basic_format_context : public internal::context_base, Char> +{ +public: + /** The character type for the output. */ + typedef Char char_type; + + // using formatter_type = formatter; + template + struct formatter_type + { + typedef formatter type; + }; + +private: + internal::arg_map map_; + + FMT_DISALLOW_COPY_AND_ASSIGN(basic_format_context); + + typedef internal::context_base base; + typedef typename base::format_arg format_arg; + using base::get_arg; + +public: + using typename base::iterator; + + /** + Constructs a ``basic_format_context`` object. References to the arguments are + stored in the object so make sure they have appropriate lifetimes. + */ + basic_format_context(OutputIt out, basic_string_view format_str, basic_format_args ctx_args) + : base(out, format_str, ctx_args) + { + } + + format_arg next_arg() + { + return this->do_get_arg(this->parse_context().next_arg_id()); + } + format_arg get_arg(unsigned arg_id) + { + return this->do_get_arg(arg_id); + } + + // Checks if manual indexing is used and returns the argument with the + // specified name. + format_arg get_arg(basic_string_view name); +}; + +template +struct buffer_context +{ + typedef basic_format_context>, Char> type; +}; +typedef buffer_context::type format_context; +typedef buffer_context::type wformat_context; + +namespace internal { +template +struct get_type +{ + typedef decltype(make_value(declval::type &>())) value_type; + static const type value = value_type::type_tag; +}; + +template +FMT_CONSTEXPR unsigned long long get_types() +{ + return 0; +} + +template +FMT_CONSTEXPR unsigned long long get_types() +{ + return get_type::value | (get_types() << 4); +} + +template +FMT_CONSTEXPR basic_format_arg make_arg(const T &value) +{ + basic_format_arg arg; + arg.type_ = get_type::value; + arg.value_ = make_value(value); + return arg; +} + +template +inline typename std::enable_if>::type make_arg(const T &value) +{ + return make_value(value); +} + +template +inline typename std::enable_if>::type make_arg(const T &value) +{ + return make_arg(value); +} +} // namespace internal + +/** + \rst + An array of references to arguments. It can be implicitly converted into + `~fmt::basic_format_args` for passing into type-erased formatting functions + such as `~fmt::vformat`. + \endrst + */ +template +class format_arg_store +{ +private: + static const size_t NUM_ARGS = sizeof...(Args); + + // Packed is a macro on MinGW so use IS_PACKED instead. + static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args; + + typedef typename std::conditional, basic_format_arg>::type value_type; + + // If the arguments are not packed, add one more element to mark the end. + static const size_t DATA_SIZE = NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1); + value_type data_[DATA_SIZE]; + + friend class basic_format_args; + + static FMT_CONSTEXPR long long get_types() + { + return IS_PACKED ? static_cast(internal::get_types()) : -static_cast(NUM_ARGS); + } + +public: +#if FMT_USE_CONSTEXPR + static constexpr long long TYPES = get_types(); +#else + static const long long TYPES; +#endif + +#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 405) || (FMT_MSC_VER && FMT_MSC_VER <= 1800) + // Workaround array initialization issues in gcc <= 4.5 and MSVC <= 2013. + format_arg_store(const Args &... args) + { + value_type init[DATA_SIZE] = {internal::make_arg(args)...}; + std::memcpy(data_, init, sizeof(init)); + } +#else + format_arg_store(const Args &... args) + : data_{internal::make_arg(args)...} + { + } +#endif +}; + +#if !FMT_USE_CONSTEXPR +template +const long long format_arg_store::TYPES = get_types(); +#endif + +/** + \rst + Constructs an `~fmt::format_arg_store` object that contains references to + arguments and can be implicitly converted to `~fmt::format_args`. `Context` + can + be omitted in which case it defaults to `~fmt::context`. + \endrst + */ +template +inline format_arg_store make_format_args(const Args &... args) +{ + return format_arg_store(args...); +} + +template +inline format_arg_store make_format_args(const Args &... args) +{ + return format_arg_store(args...); +} + +/** Formatting arguments. */ +template +class basic_format_args +{ +public: + typedef unsigned size_type; + typedef basic_format_arg format_arg; + +private: + // To reduce compiled code size per formatting function call, types of first + // max_packed_args arguments are passed in the types_ field. + unsigned long long 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 format_arg *args_; + }; + + typename internal::type type(unsigned index) const + { + unsigned shift = index * 4; + unsigned long long mask = 0xf; + return static_cast((types_ & (mask << shift)) >> shift); + } + + friend class internal::arg_map; + + void set_data(const internal::value *values) + { + values_ = values; + } + void set_data(const format_arg *args) + { + args_ = args; + } + + format_arg do_get(size_type index) const + { + long long signed_types = static_cast(types_); + if (signed_types < 0) + { + unsigned long long num_args = static_cast(-signed_types); + return index < num_args ? args_[index] : format_arg(); + } + format_arg arg; + if (index > internal::max_packed_args) + return arg; + arg.type_ = type(index); + if (arg.type_ == internal::none_type) + return arg; + internal::value &val = arg.value_; + val = values_[index]; + return arg; + } + +public: + basic_format_args() + : types_(0) + { + } + + /** + \rst + Constructs a `basic_format_args` object from `~fmt::format_arg_store`. + \endrst + */ + template + basic_format_args(const format_arg_store &store) + : types_(static_cast(store.TYPES)) + { + set_data(store.data_); + } + + /** Returns the argument at specified index. */ + format_arg get(size_type index) const + { + format_arg arg = do_get(index); + return arg.type_ == internal::named_arg_type ? arg.value_.as_named_arg().template deserialize() : arg; + } + + unsigned max_size() const + { + long long signed_types = static_cast(types_); + return static_cast(signed_types < 0 ? -signed_types : static_cast(internal::max_packed_args)); + } +}; + +/** An alias to ``basic_format_args``. */ +// It is a separate type rather than a typedef to make symbols readable. +struct format_args : basic_format_args +{ + template + format_args(Args &&... arg) + : basic_format_args(std::forward(arg)...) + { + } +}; +struct wformat_args : basic_format_args +{ + template + wformat_args(Args &&... arg) + : basic_format_args(std::forward(arg)...) + { + } +}; + +namespace internal { +template +struct named_arg_base +{ + basic_string_view name; + + // Serialized value. + mutable char data[sizeof(basic_format_arg)]; + + named_arg_base(basic_string_view nm) + : name(nm) + { + } + + template + basic_format_arg deserialize() const + { + basic_format_arg arg; + std::memcpy(&arg, data, sizeof(basic_format_arg)); + return arg; + } +}; + +template +struct named_arg : named_arg_base +{ + const T &value; + + named_arg(basic_string_view name, const T &val) + : named_arg_base(name) + , value(val) + { + } +}; +} // namespace internal + +/** + \rst + Returns a named argument to be used in a formatting function. + + **Example**:: + + fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); + \endrst + */ +template +inline internal::named_arg arg(string_view name, const T &arg) +{ + return internal::named_arg(name, arg); +} + +template +inline internal::named_arg arg(wstring_view name, const T &arg) +{ + return internal::named_arg(name, arg); +} + +// This function template is deleted intentionally to disable nested named +// arguments as in ``format("{}", arg("a", arg("b", 42)))``. +template +void arg(S, internal::named_arg) FMT_DELETED; + +#ifndef FMT_EXTENDED_COLORS +// color and (v)print_colored are deprecated. +enum color +{ + black, + red, + green, + yellow, + blue, + magenta, + cyan, + white +}; +FMT_API void vprint_colored(color c, string_view format, format_args args); +FMT_API void vprint_colored(color c, wstring_view format, wformat_args args); +template +inline void print_colored(color c, string_view format_str, const Args &... args) +{ + vprint_colored(c, format_str, make_format_args(args...)); +} +template +inline void print_colored(color c, wstring_view format_str, const Args &... args) +{ + vprint_colored(c, format_str, make_format_args(args...)); +} +#endif + +format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args); +wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args); + +template +struct is_contiguous : std::false_type +{ +}; + +template +struct is_contiguous> : std::true_type +{ +}; + +template +struct is_contiguous> : std::true_type +{ +}; + +/** Formats a string and writes the output to ``out``. */ +template +typename std::enable_if::value, std::back_insert_iterator>::type vformat_to( + std::back_insert_iterator out, string_view format_str, format_args args) +{ + auto &container = internal::get_container(out); + internal::container_buffer buf(container); + vformat_to(buf, format_str, args); + return std::back_inserter(container); +} + +template +typename std::enable_if::value, std::back_insert_iterator>::type vformat_to( + std::back_insert_iterator out, wstring_view format_str, wformat_args args) +{ + auto &container = internal::get_container(out); + internal::container_buffer buf(container); + vformat_to(buf, format_str, args); + return std::back_inserter(container); +} + +std::string vformat(string_view format_str, format_args args); +std::wstring vformat(wstring_view format_str, wformat_args args); + +/** + \rst + Formats arguments and returns the result as a string. + + **Example**:: + + #include + std::string message = fmt::format("The answer is {}", 42); + \endrst +*/ +template +inline std::string format(string_view format_str, const Args &... args) +{ + // This should be just + // return vformat(format_str, make_format_args(args...)); + // but gcc has trouble optimizing the latter, so break it down. + format_arg_store as{args...}; + return vformat(format_str, as); +} +template +inline std::wstring format(wstring_view format_str, const Args &... args) +{ + format_arg_store as{args...}; + return vformat(format_str, as); +} + +FMT_API void vprint(std::FILE *f, string_view format_str, format_args args); +FMT_API void vprint(std::FILE *f, wstring_view format_str, wformat_args args); + +/** + \rst + Prints formatted data to the file *f*. + + **Example**:: + + fmt::print(stderr, "Don't {}!", "panic"); + \endrst + */ +template +inline void print(std::FILE *f, string_view format_str, const Args &... args) +{ + format_arg_store as(args...); + vprint(f, format_str, as); +} +/** + Prints formatted data to the file *f* which should be in wide-oriented mode + set + via ``fwide(f, 1)`` or ``_setmode(_fileno(f), _O_U8TEXT)`` on Windows. + */ +template +inline void print(std::FILE *f, wstring_view format_str, const Args &... args) +{ + format_arg_store as(args...); + vprint(f, format_str, as); +} + +FMT_API void vprint(string_view format_str, format_args args); +FMT_API void vprint(wstring_view format_str, wformat_args args); + +/** + \rst + Prints formatted data to ``stdout``. + + **Example**:: + + fmt::print("Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ +template +inline void print(string_view format_str, const Args &... args) +{ + format_arg_store as{args...}; + vprint(format_str, as); +} + +template +inline void print(wstring_view format_str, const Args &... args) +{ + format_arg_store as(args...); + vprint(format_str, as); +} +FMT_END_NAMESPACE + +#endif // FMT_CORE_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/format-inl.h b/spdlog_lib/spdlog/fmt/bundled/format-inl.h new file mode 100644 index 0000000..1aba8c6 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/format-inl.h @@ -0,0 +1,578 @@ +// Formatting library for C++ +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_FORMAT_INL_H_ +#define FMT_FORMAT_INL_H_ + +#include "format.h" + +#include + +#include +#include +#include +#include +#include +#include // for std::ptrdiff_t +#include + +#if defined(_WIN32) && defined(__MINGW32__) +#include +#endif + +#if FMT_USE_WINDOWS_H +#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN) +#define WIN32_LEAN_AND_MEAN +#endif +#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX) +#include +#else +#define NOMINMAX +#include +#undef NOMINMAX +#endif +#endif + +#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. +inline fmt::internal::null<> strerror_r(int, char *, ...) +{ + return fmt::internal::null<>(); +} +inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) +{ + return fmt::internal::null<>(); +} + +FMT_BEGIN_NAMESPACE + +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) + +typedef void (*FormatFunc)(internal::buffer &, int, string_view); + +// 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 != FMT_NULL && buffer_size != 0, "invalid buffer"); + + class dispatcher + { + private: + int error_code_; + char *&buffer_; + std::size_t buffer_size_; + + // A noop assignment operator to avoid bogus warnings. + void operator=(const dispatcher &) {} + + // 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: + dispatcher(int err_code, char *&buf, std::size_t buf_size) + : error_code_(err_code) + , buffer_(buf) + , buffer_size_(buf_size) + { + } + + int run() + { + return handle(strerror_r(error_code_, buffer_, buffer_size_)); + } + }; + return dispatcher(error_code, buffer, buffer_size).run(); +} + +void format_error_code(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT +{ + // Report error code making sure that the output fits into + // inline_buffer_size to avoid dynamic memory allocation and potential + // bad_alloc. + out.resize(0); + 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::int_traits::main_type main_type; + main_type abs_value = static_cast(error_code); + if (internal::is_negative(error_code)) + { + abs_value = 0 - abs_value; + ++error_code_size; + } + error_code_size += internal::count_digits(abs_value); + writer w(out); + if (message.size() <= inline_buffer_size - error_code_size) + { + w.write(message); + w.write(SEP); + } + w.write(ERROR_STR); + w.write(error_code); + assert(out.size() <= inline_buffer_size); +} + +void report_error(FormatFunc func, int error_code, string_view message) FMT_NOEXCEPT +{ + memory_buffer full_message; + func(full_message, error_code, message); + // Use Writer::data instead of Writer::c_str to avoid potential memory + // allocation. + std::fwrite(full_message.data(), full_message.size(), 1, stderr); + std::fputc('\n', stderr); +} +} // namespace + +class locale +{ +private: + std::locale locale_; + +public: + explicit locale(std::locale loc = std::locale()) + : locale_(loc) + { + } + std::locale get() + { + return locale_; + } +}; + +template +FMT_FUNC Char internal::thousands_sep(locale_provider *lp) +{ + std::locale loc = lp ? lp->locale().get() : std::locale(); + return std::use_facet>(loc).thousands_sep(); +} + +FMT_FUNC void system_error::init(int err_code, string_view format_str, format_args args) +{ + error_code_ = err_code; + memory_buffer buffer; + format_system_error(buffer, err_code, vformat(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(to_string(buffer)); +} + +namespace internal { +template +int char_traits::format_float(char *buffer, std::size_t size, const char *format, int precision, T value) +{ + return precision < 0 ? FMT_SNPRINTF(buffer, size, format, value) : FMT_SNPRINTF(buffer, size, format, precision, value); +} + +template +int char_traits::format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value) +{ + return precision < 0 ? FMT_SWPRINTF(buffer, size, format, value) : FMT_SWPRINTF(buffer, size, format, precision, value); +} + +template +const char basic_data::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 +const uint32_t basic_data::POWERS_OF_10_32[] = {0, FMT_POWERS_OF_10(1)}; + +template +const uint64_t basic_data::POWERS_OF_10_64[] = {0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull}; + +// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340. +// These are generated by support/compute-powers.py. +template +const uint64_t basic_data::POW10_SIGNIFICANDS[] = {0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea, + 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, + 0xd3515c2831559a83, 0x9d71ac8fada6c9b5, 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637, + 0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, + 0xc5dd44271ad3cdba, 0x936b9fcebb25c996, 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8, + 0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, + 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3, + 0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, 0xe8d4a51000000000, + 0xad78ebc5ac620000, 0x813f3978f8940984, 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245, + 0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, 0xda01ee641a708dea, + 0xa26da3999aef774a, 0xf209787bb47d6b85, 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3, + 0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, + 0x98165af37b2153df, 0xe2a0b5dc971f303a, 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a, + 0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, + 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b}; + +// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding +// to significands above. +template +const int16_t basic_data::POW10_EXPONENTS[] = {-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901, + -874, -847, -821, -794, -768, -741, -715, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -343, -316, + -289, -263, -236, -210, -183, -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, 375, + 402, 428, 455, 481, 508, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066}; + +template +const char basic_data::RESET_COLOR[] = "\x1b[0m"; +template +const wchar_t basic_data::WRESET_COLOR[] = L"\x1b[0m"; + +FMT_FUNC fp operator*(fp x, fp y) +{ + // Multiply 32-bit parts of significands. + uint64_t mask = (1ULL << 32) - 1; + uint64_t a = x.f >> 32, b = x.f & mask; + uint64_t c = y.f >> 32, d = y.f & mask; + uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; + // Compute mid 64-bit of result and round. + uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); + return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64); +} + +FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) +{ + const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10) + int index = static_cast(std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10)); + // Decimal exponent of the first (smallest) cached power of 10. + const int first_dec_exp = -348; + // Difference between two consecutive decimal exponents in cached powers of + // 10. + const int dec_exp_step = 8; + index = (index - first_dec_exp - 1) / dec_exp_step + 1; + pow10_exponent = first_dec_exp + index * dec_exp_step; + return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]); +} +} // namespace internal + +#if FMT_USE_WINDOWS_H + +FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) +{ + static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; + if (s.size() > INT_MAX) + FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG)); + int s_size = static_cast(s.size()); + if (s_size == 0) + { + // MultiByteToWideChar does not support zero length, handle separately. + buffer_.resize(1); + buffer_[0] = 0; + return; + } + + int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0); + if (length == 0) + FMT_THROW(windows_error(GetLastError(), ERROR_MSG)); + buffer_.resize(length + 1); + length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length); + if (length == 0) + FMT_THROW(windows_error(GetLastError(), ERROR_MSG)); + buffer_[length] = 0; +} + +FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) +{ + if (int error_code = convert(s)) + { + FMT_THROW(windows_error(error_code, "cannot convert string from UTF-16 to UTF-8")); + } +} + +FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) +{ + if (s.size() > INT_MAX) + return ERROR_INVALID_PARAMETER; + int s_size = static_cast(s.size()); + if (s_size == 0) + { + // WideCharToMultiByte does not support zero length, handle separately. + buffer_.resize(1); + buffer_[0] = 0; + return 0; + } + + int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL); + if (length == 0) + return GetLastError(); + buffer_.resize(length + 1); + length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL); + if (length == 0) + return GetLastError(); + buffer_[length] = 0; + return 0; +} + +FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_args args) +{ + error_code_ = err_code; + memory_buffer buffer; + internal::format_windows_error(buffer, err_code, vformat(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(to_string(buffer)); +} + +FMT_FUNC void internal::format_windows_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT +{ + FMT_TRY + { + wmemory_buffer buf; + buf.resize(inline_buffer_size); + for (;;) + { + wchar_t *system_message = &buf[0]; + int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL, error_code, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message, static_cast(buf.size()), FMT_NULL); + if (result != 0) + { + utf16_to_utf8 utf8_message; + if (utf8_message.convert(system_message) == ERROR_SUCCESS) + { + writer w(out); + w.write(message); + w.write(": "); + w.write(utf8_message); + return; + } + break; + } + if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) + break; // Can't get error message, report error code instead. + buf.resize(buf.size() * 2); + } + } + FMT_CATCH(...) {} + format_error_code(out, error_code, message); +} + +#endif // FMT_USE_WINDOWS_H + +FMT_FUNC void format_system_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT +{ + FMT_TRY + { + memory_buffer buf; + buf.resize(inline_buffer_size); + for (;;) + { + char *system_message = &buf[0]; + int result = safe_strerror(error_code, system_message, buf.size()); + if (result == 0) + { + writer w(out); + w.write(message); + w.write(": "); + w.write(system_message); + return; + } + if (result != ERANGE) + break; // Can't get error message, report error code instead. + buf.resize(buf.size() * 2); + } + } + FMT_CATCH(...) {} + format_error_code(out, error_code, message); +} + +template +void basic_fixed_buffer::grow(std::size_t) +{ + FMT_THROW(std::runtime_error("buffer overflow")); +} + +FMT_FUNC void internal::error_handler::on_error(const char *message) +{ + FMT_THROW(format_error(message)); +} + +FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT +{ + report_error(format_system_error, error_code, message); +} + +#if FMT_USE_WINDOWS_H +FMT_FUNC void report_windows_error(int error_code, fmt::string_view message) FMT_NOEXCEPT +{ + report_error(internal::format_windows_error, error_code, message); +} +#endif + +FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) +{ + memory_buffer buffer; + vformat_to(buffer, format_str, args); + std::fwrite(buffer.data(), 1, buffer.size(), f); +} + +FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) +{ + wmemory_buffer buffer; + vformat_to(buffer, format_str, args); + std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f); +} + +FMT_FUNC void vprint(string_view format_str, format_args args) +{ + vprint(stdout, format_str, args); +} + +FMT_FUNC void vprint(wstring_view format_str, wformat_args args) +{ + vprint(stdout, format_str, args); +} + +#ifndef FMT_EXTENDED_COLORS +FMT_FUNC void vprint_colored(color c, string_view format, format_args args) +{ + char escape[] = "\x1b[30m"; + escape[3] = static_cast('0' + c); + std::fputs(escape, stdout); + vprint(format, args); + std::fputs(internal::data::RESET_COLOR, stdout); +} + +FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args) +{ + wchar_t escape[] = L"\x1b[30m"; + escape[3] = static_cast('0' + c); + std::fputws(escape, stdout); + vprint(format, args); + std::fputws(internal::data::WRESET_COLOR, stdout); +} +#else +namespace internal { +FMT_CONSTEXPR void to_esc(uint8_t c, char out[], int offset) +{ + out[offset + 0] = static_cast('0' + c / 100); + out[offset + 1] = static_cast('0' + c / 10 % 10); + out[offset + 2] = static_cast('0' + c % 10); +} +} // namespace internal + +FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) +{ + char escape_fd[] = "\x1b[38;2;000;000;000m"; + internal::to_esc(fd.r, escape_fd, 7); + internal::to_esc(fd.g, escape_fd, 11); + internal::to_esc(fd.b, escape_fd, 15); + + std::fputs(escape_fd, stdout); + vprint(format, args); + std::fputs(internal::data::RESET_COLOR, stdout); +} + +FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) +{ + char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color + char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color + internal::to_esc(fd.r, escape_fd, 7); + internal::to_esc(fd.g, escape_fd, 11); + internal::to_esc(fd.b, escape_fd, 15); + + internal::to_esc(bg.r, escape_bg, 7); + internal::to_esc(bg.g, escape_bg, 11); + internal::to_esc(bg.b, escape_bg, 15); + + std::fputs(escape_fd, stdout); + std::fputs(escape_bg, stdout); + vprint(format, args); + std::fputs(internal::data::RESET_COLOR, stdout); +} +#endif + +FMT_FUNC locale locale_provider::locale() +{ + return fmt::locale(); +} + +FMT_END_NAMESPACE + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif // FMT_FORMAT_INL_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/format.h b/spdlog_lib/spdlog/fmt/bundled/format.h new file mode 100644 index 0000000..60001f3 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/format.h @@ -0,0 +1,4716 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - present, 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 +#include +#include +#include +#include +#include +#include +#include + +#ifdef __clang__ +#define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +#else +#define FMT_CLANG_VERSION 0 +#endif + +#ifdef __INTEL_COMPILER +#define FMT_ICC_VERSION __INTEL_COMPILER +#elif defined(__ICL) +#define FMT_ICC_VERSION __ICL +#else +#define FMT_ICC_VERSION 0 +#endif + +#include "core.h" + +#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION +#pragma GCC diagnostic push + +// 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 + +#ifdef _SECURE_SCL +#define FMT_SECURE_SCL _SECURE_SCL +#else +#define FMT_SECURE_SCL 0 +#endif + +#if FMT_SECURE_SCL +#include +#endif + +#ifdef __has_builtin +#define FMT_HAS_BUILTIN(x) __has_builtin(x) +#else +#define FMT_HAS_BUILTIN(x) 0 +#endif + +#ifdef __GNUC_LIBSTD__ +#define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) +#endif + +#ifndef FMT_THROW +#if FMT_EXCEPTIONS +#if FMT_MSC_VER +FMT_BEGIN_NAMESPACE +namespace internal { +template +inline void do_throw(const Exception &x) +{ + // Silence unreachable code warnings in MSVC because these are nearly + // impossible to fix in a generic code. + volatile bool b = true; + if (b) + throw x; +} +} // namespace internal +FMT_END_NAMESPACE +#define FMT_THROW(x) fmt::internal::do_throw(x) +#else +#define FMT_THROW(x) throw x +#endif +#else +#define FMT_THROW(x) \ + do \ + { \ + static_cast(sizeof(x)); \ + assert(false); \ + } while (false); +#endif +#endif + +#ifndef FMT_USE_USER_DEFINED_LITERALS +// For Intel's compiler both it and the system gcc/msc must support UDLs. +#if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) && (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1500) +#define FMT_USE_USER_DEFINED_LITERALS 1 +#else +#define FMT_USE_USER_DEFINED_LITERALS 0 +#endif +#endif + +#if FMT_USE_USER_DEFINED_LITERALS && !defined(FMT_ICC_VERSION) && \ + ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304)) +#define FMT_UDL_TEMPLATE 1 +#else +#define FMT_UDL_TEMPLATE 0 +#endif + +#ifndef FMT_USE_EXTERN_TEMPLATES +#ifndef FMT_HEADER_ONLY +#define FMT_USE_EXTERN_TEMPLATES ((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11)) +#else +#define FMT_USE_EXTERN_TEMPLATES 0 +#endif +#endif + +#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || FMT_MSC_VER >= 1600 +#define FMT_USE_TRAILING_RETURN 1 +#else +#define FMT_USE_TRAILING_RETURN 0 +#endif + +#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_rvalue_references) || FMT_MSC_VER >= 1600 +#define FMT_USE_RVALUE_REFERENCES 1 +#else +#define FMT_USE_RVALUE_REFERENCES 0 +#endif + +#ifndef FMT_USE_GRISU +#define FMT_USE_GRISU 0 +#endif + +// __builtin_clz is broken in clang with Microsoft CodeGen: +// https://github.com/fmtlib/fmt/issues/519 +#ifndef _MSC_VER +#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 +#endif + +// A workaround for gcc 4.4 that doesn't support union members with ctors. +#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 404) || (FMT_MSC_VER && FMT_MSC_VER <= 1800) +#define FMT_UNION struct +#else +#define FMT_UNION union +#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) && !defined(_MANAGED) +#include // _BitScanReverse, _BitScanReverse64 + +FMT_BEGIN_NAMESPACE +namespace internal { +// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. +#ifndef __clang__ +#pragma intrinsic(_BitScanReverse) +#endif +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) + +#if defined(_WIN64) && !defined(__clang__) +#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(x >> 32))) + return 63 - (r + 32); + + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(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) +} // namespace internal +FMT_END_NAMESPACE +#endif + +FMT_BEGIN_NAMESPACE +namespace internal { + +// An equivalent of `*reinterpret_cast(&source)` that doesn't produce +// undefined behavior (e.g. due to type aliasing). +// Example: uint64_t d = bit_cast(2.718); +template +inline Dest bit_cast(const Source &source) +{ + static_assert(sizeof(Dest) == sizeof(Source), "size mismatch"); + Dest dest; + std::memcpy(&dest, &source, sizeof(dest)); + return dest; +} + +// An implementation of begin and end for pre-C++11 compilers such as gcc 4. +template +FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin()) +{ + return c.begin(); +} +template +FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT +{ + return array; +} +template +FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end()) +{ + return c.end(); +} +template +FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT +{ + return array + N; +} + +// For std::result_of in gcc 4.4. +template +struct function +{ + template + struct result + { + typedef Result type; + }; +}; + +struct dummy_int +{ + int data[2]; + operator int() const + { + return 0; + } +}; +typedef std::numeric_limits fputil; + +// Dummy implementations of system functions such as signbit and ecvt called +// if the latter are not available. +inline dummy_int signbit(...) +{ + return dummy_int(); +} +inline dummy_int _ecvt_s(...) +{ + return dummy_int(); +} +inline dummy_int isinf(...) +{ + return dummy_int(); +} +inline dummy_int _finite(...) +{ + return dummy_int(); +} +inline dummy_int isnan(...) +{ + return dummy_int(); +} +inline dummy_int _isnan(...) +{ + return dummy_int(); +} + +// A handmade floating-point number f * pow(2, e). +class fp +{ +private: + typedef uint64_t significand_type; + + // All sizes are in bits. + static FMT_CONSTEXPR_DECL const int char_size = std::numeric_limits::digits; + // Subtract 1 to account for an implicit most significant bit in the + // normalized form. + static FMT_CONSTEXPR_DECL const int double_significand_size = std::numeric_limits::digits - 1; + static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = 1ull << double_significand_size; + +public: + significand_type f; + int e; + + static FMT_CONSTEXPR_DECL const int significand_size = sizeof(significand_type) * char_size; + + fp(uint64_t f, int e) + : f(f) + , e(e) + { + } + + // Constructs fp from an IEEE754 double. It is a template to prevent compile + // errors on platforms where double is not IEEE754. + template + explicit fp(Double d) + { + // Assume double is in the format [sign][exponent][significand]. + typedef std::numeric_limits limits; + const int double_size = sizeof(Double) * char_size; + const int exponent_size = double_size - double_significand_size - 1; // -1 for sign + const uint64_t significand_mask = implicit_bit - 1; + const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask; + const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1; + auto u = bit_cast(d); + auto biased_e = (u & exponent_mask) >> double_significand_size; + f = u & significand_mask; + if (biased_e != 0) + f += implicit_bit; + else + biased_e = 1; // Subnormals use biased exponent 1 (min exponent). + e = static_cast(biased_e - exponent_bias - double_significand_size); + } + + // Normalizes the value converted from double and multiplied by (1 << SHIFT). + template + void normalize() + { + // Handle subnormals. + auto shifted_implicit_bit = implicit_bit << SHIFT; + while ((f & shifted_implicit_bit) == 0) + { + f <<= 1; + --e; + } + // Subtract 1 to account for hidden bit. + auto offset = significand_size - double_significand_size - SHIFT - 1; + f <<= offset; + e -= offset; + } +}; + +// Returns an fp number representing x - y. Result may not be normalized. +inline fp operator-(fp x, fp y) +{ + FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands"); + return fp(x.f - y.f, x.e); +} + +// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest +// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be +// normalized. +fp operator*(fp x, fp y); + +// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its +// (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 3. +fp get_cached_power(int min_exponent, int &pow10_exponent); + +template +typename Allocator::value_type *allocate(Allocator &alloc, std::size_t n) +{ +#if __cplusplus >= 201103L || FMT_MSC_VER >= 1700 + return std::allocator_traits::allocate(alloc, n); +#else + return alloc.allocate(n); +#endif +} + +// A helper function to suppress bogus "conditional expression is constant" +// warnings. +template +inline T const_check(T value) +{ + return value; +} +} // namespace internal +FMT_END_NAMESPACE + +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 : public std::numeric_limits +{ +public: + // Portable version of isinf. + template + 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(dummy_int))) + return isinf(x) != 0; + return !_finite(static_cast(x)); + } + + // Portable version of isnan. + template + static bool isnotanumber(T x) + { + using namespace fmt::internal; + if (const_check(sizeof(isnan(x)) != sizeof(fmt::internal::dummy_int))) + return isnan(x) != 0; + return _isnan(static_cast(x)) != 0; + } + + // Portable version of signbit. + static bool isnegative(double x) + { + using namespace fmt::internal; + if (const_check(sizeof(signbit(x)) != sizeof(fmt::internal::dummy_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 + +FMT_BEGIN_NAMESPACE +template +class basic_writer; + +template +class output_range +{ +private: + OutputIt it_; + + // Unused yet. + typedef void sentinel; + sentinel end() const; + +public: + typedef OutputIt iterator; + typedef T value_type; + + explicit output_range(OutputIt it) + : it_(it) + { + } + OutputIt begin() const + { + return it_; + } +}; + +// A range where begin() returns back_insert_iterator. +template +class back_insert_range : public output_range> +{ + typedef output_range> base; + +public: + typedef typename Container::value_type value_type; + + back_insert_range(Container &c) + : base(std::back_inserter(c)) + { + } + back_insert_range(typename base::iterator it) + : base(it) + { + } +}; + +typedef basic_writer> writer; +typedef basic_writer> wwriter; + +/** A formatting error such as invalid format string. */ +class format_error : public std::runtime_error +{ +public: + explicit format_error(const char *message) + : std::runtime_error(message) + { + } + + explicit format_error(const std::string &message) + : std::runtime_error(message) + { + } +}; + +namespace internal { + +#if FMT_SECURE_SCL +template +struct checked +{ + typedef stdext::checked_array_iterator type; +}; + +// Make a checked iterator to avoid warnings on MSVC. +template +inline stdext::checked_array_iterator make_checked(T *p, std::size_t size) +{ + return {p, size}; +} +#else +template +struct checked +{ + typedef T *type; +}; +template +inline T *make_checked(T *p, std::size_t) +{ + return p; +} +#endif + +template +template +void basic_buffer::append(const U *begin, const U *end) +{ + std::size_t new_size = size_ + internal::to_unsigned(end - begin); + reserve(new_size); + std::uninitialized_copy(begin, end, internal::make_checked(ptr_, capacity_) + size_); + size_ = new_size; +} +} // namespace internal + +// A wrapper around std::locale used to reduce compile times since +// is very heavy. +class locale; + +class locale_provider +{ +public: + virtual ~locale_provider() {} + virtual fmt::locale locale(); +}; + +// The number of characters to store in the basic_memory_buffer object itself +// to avoid dynamic memory allocation. +enum +{ + inline_buffer_size = 500 +}; + +/** + \rst + A dynamically growing memory buffer for trivially copyable/constructible types + with the first ``SIZE`` elements stored in the object itself. + + You can use one of the following typedefs for common character types: + + +----------------+------------------------------+ + | Type | Definition | + +================+==============================+ + | memory_buffer | basic_memory_buffer | + +----------------+------------------------------+ + | wmemory_buffer | basic_memory_buffer | + +----------------+------------------------------+ + + **Example**:: + + fmt::memory_buffer out; + format_to(out, "The answer is {}.", 42); + + This will write the following output to the ``out`` object: + + .. code-block:: none + + The answer is 42. + + The output can be converted to an ``std::string`` with ``to_string(out)``. + \endrst + */ +template> +class basic_memory_buffer : private Allocator, public internal::basic_buffer +{ +private: + T store_[SIZE]; + + // Deallocate memory allocated by the buffer. + void deallocate() + { + T *data = this->data(); + if (data != store_) + Allocator::deallocate(data, this->capacity()); + } + +protected: + void grow(std::size_t size) FMT_OVERRIDE; + +public: + explicit basic_memory_buffer(const Allocator &alloc = Allocator()) + : Allocator(alloc) + { + this->set(store_, SIZE); + } + ~basic_memory_buffer() + { + deallocate(); + } + +private: + // Move data from other to this buffer. + void move(basic_memory_buffer &other) + { + Allocator &this_alloc = *this, &other_alloc = other; + this_alloc = std::move(other_alloc); + T *data = other.data(); + std::size_t size = other.size(), capacity = other.capacity(); + if (data == other.store_) + { + this->set(store_, capacity); + std::uninitialized_copy(other.store_, other.store_ + size, internal::make_checked(store_, capacity)); + } + else + { + this->set(data, capacity); + // Set pointer to the inline array so that delete is not called + // when deallocating. + other.set(other.store_, 0); + } + this->resize(size); + } + +public: + /** + \rst + Constructs a :class:`fmt::basic_memory_buffer` object moving the content + of the other object to it. + \endrst + */ + basic_memory_buffer(basic_memory_buffer &&other) + { + move(other); + } + + /** + \rst + Moves the content of the other ``basic_memory_buffer`` object to this one. + \endrst + */ + basic_memory_buffer &operator=(basic_memory_buffer &&other) + { + assert(this != &other); + deallocate(); + move(other); + return *this; + } + + // Returns a copy of the allocator associated with this buffer. + Allocator get_allocator() const + { + return *this; + } +}; + +template +void basic_memory_buffer::grow(std::size_t size) +{ + std::size_t old_capacity = this->capacity(); + std::size_t new_capacity = old_capacity + old_capacity / 2; + if (size > new_capacity) + new_capacity = size; + T *old_data = this->data(); + T *new_data = internal::allocate(*this, new_capacity); + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::uninitialized_copy(old_data, old_data + this->size(), internal::make_checked(new_data, new_capacity)); + this->set(new_data, new_capacity); + // deallocate must not throw according to the standard, but even if it does, + // the buffer already uses the new storage and will deallocate it in + // destructor. + if (old_data != store_) + Allocator::deallocate(old_data, old_capacity); +} + +typedef basic_memory_buffer memory_buffer; +typedef basic_memory_buffer wmemory_buffer; + +/** + \rst + A fixed-size memory buffer. For a dynamically growing buffer use + :class:`fmt::basic_memory_buffer`. + + Trying to increase the buffer size past the initial capacity will throw + ``std::runtime_error``. + \endrst + */ +template +class basic_fixed_buffer : public internal::basic_buffer +{ +public: + /** + \rst + Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the + given size. + \endrst + */ + basic_fixed_buffer(Char *array, std::size_t size) + { + this->set(array, size); + } + + /** + \rst + Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the + size known at compile time. + \endrst + */ + template + explicit basic_fixed_buffer(Char (&array)[SIZE]) + { + this->set(array, SIZE); + } + +protected: + FMT_API void grow(std::size_t size) FMT_OVERRIDE; +}; + +namespace internal { + +template +struct char_traits; + +template<> +struct char_traits +{ + // Formats a floating-point number. + template + FMT_API static int format_float(char *buffer, std::size_t size, const char *format, int precision, T value); +}; + +template<> +struct char_traits +{ + template + FMT_API static int format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value); +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template int char_traits::format_float( + char *buffer, std::size_t size, const char *format, int precision, double value); +extern template int char_traits::format_float( + char *buffer, std::size_t size, const char *format, int precision, long double value); + +extern template int char_traits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, double value); +extern template int char_traits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, long double value); +#endif + +template +inline typename std::enable_if::value, typename checked::type>::type reserve( + std::back_insert_iterator &it, std::size_t n) +{ + Container &c = internal::get_container(it); + std::size_t size = c.size(); + c.resize(size + n); + return make_checked(&c[size], n); +} + +template +inline Iterator &reserve(Iterator &it, std::size_t) +{ + return it; +} + +template +class null_terminating_iterator; + +template +FMT_CONSTEXPR_DECL const Char *pointer_from(null_terminating_iterator it); + +// An iterator that produces a null terminator on *end. This simplifies parsing +// and allows comparing the performance of processing a null-terminated string +// vs string_view. +template +class null_terminating_iterator +{ +public: + typedef std::ptrdiff_t difference_type; + typedef Char value_type; + typedef const Char *pointer; + typedef const Char &reference; + typedef std::random_access_iterator_tag iterator_category; + + null_terminating_iterator() + : ptr_(0) + , end_(0) + { + } + + FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end) + : ptr_(ptr) + , end_(end) + { + } + + template + FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r) + : ptr_(r.begin()) + , end_(r.end()) + { + } + + null_terminating_iterator &operator=(const Char *ptr) + { + assert(ptr <= end_); + ptr_ = ptr; + return *this; + } + + FMT_CONSTEXPR Char operator*() const + { + return ptr_ != end_ ? *ptr_ : 0; + } + + FMT_CONSTEXPR null_terminating_iterator operator++() + { + ++ptr_; + return *this; + } + + FMT_CONSTEXPR null_terminating_iterator operator++(int) + { + null_terminating_iterator result(*this); + ++ptr_; + return result; + } + + FMT_CONSTEXPR null_terminating_iterator operator--() + { + --ptr_; + return *this; + } + + FMT_CONSTEXPR null_terminating_iterator operator+(difference_type n) + { + return null_terminating_iterator(ptr_ + n, end_); + } + + FMT_CONSTEXPR null_terminating_iterator operator-(difference_type n) + { + return null_terminating_iterator(ptr_ - n, end_); + } + + FMT_CONSTEXPR null_terminating_iterator operator+=(difference_type n) + { + ptr_ += n; + return *this; + } + + FMT_CONSTEXPR difference_type operator-(null_terminating_iterator other) const + { + return ptr_ - other.ptr_; + } + + FMT_CONSTEXPR bool operator!=(null_terminating_iterator other) const + { + return ptr_ != other.ptr_; + } + + bool operator>=(null_terminating_iterator other) const + { + return ptr_ >= other.ptr_; + } + + // This should be a friend specialization pointer_from but the latter + // doesn't compile by gcc 5.1 due to a compiler bug. + template + friend FMT_CONSTEXPR_DECL const CharT *pointer_from(null_terminating_iterator it); + +private: + const Char *ptr_; + const Char *end_; +}; + +template +FMT_CONSTEXPR const T *pointer_from(const T *p) +{ + return p; +} + +template +FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator it) +{ + return it.ptr_; +} + +// An output iterator that counts the number of objects written to it and +// discards them. +template +class counting_iterator +{ +private: + std::size_t count_; + mutable T blackhole_; + +public: + typedef std::output_iterator_tag iterator_category; + typedef T value_type; + typedef std::ptrdiff_t difference_type; + typedef T *pointer; + typedef T &reference; + typedef counting_iterator _Unchecked_type; // Mark iterator as checked. + + counting_iterator() + : count_(0) + { + } + + std::size_t count() const + { + return count_; + } + + counting_iterator &operator++() + { + ++count_; + return *this; + } + + counting_iterator operator++(int) + { + auto it = *this; + ++*this; + return it; + } + + T &operator*() const + { + return blackhole_; + } +}; + +// An output iterator that truncates the output and counts the number of objects +// written to it. +template +class truncating_iterator +{ +private: + typedef std::iterator_traits traits; + + OutputIt out_; + std::size_t limit_; + std::size_t count_; + mutable typename traits::value_type blackhole_; + +public: + typedef std::output_iterator_tag iterator_category; + typedef typename traits::value_type value_type; + typedef typename traits::difference_type difference_type; + typedef typename traits::pointer pointer; + typedef typename traits::reference reference; + typedef truncating_iterator _Unchecked_type; // Mark iterator as checked. + + truncating_iterator(OutputIt out, std::size_t limit) + : out_(out) + , limit_(limit) + , count_(0) + { + } + + OutputIt base() const + { + return out_; + } + std::size_t count() const + { + return count_; + } + + truncating_iterator &operator++() + { + if (count_++ < limit_) + ++out_; + return *this; + } + + truncating_iterator operator++(int) + { + auto it = *this; + ++*this; + return it; + } + + reference operator*() const + { + return count_ < limit_ ? *out_ : blackhole_; + } +}; + +// Returns true if value is negative, false otherwise. +// Same as (value < 0) but doesn't produce warnings if T is an unsigned type. +template +FMT_CONSTEXPR typename std::enable_if::is_signed, bool>::type is_negative(T value) +{ + return value < 0; +} +template +FMT_CONSTEXPR typename std::enable_if::is_signed, bool>::type is_negative(T) +{ + return false; +} + +template +struct int_traits +{ + // Smallest of uint32_t and uint64_t that is large enough to represent + // all values of T. + typedef typename std::conditional::digits <= 32, uint32_t, uint64_t>::type main_type; +}; + +// Static data is placed in this class template to allow header-only +// configuration. +template +struct FMT_API basic_data +{ + static const uint32_t POWERS_OF_10_32[]; + static const uint64_t POWERS_OF_10_64[]; + static const uint64_t POW10_SIGNIFICANDS[]; + static const int16_t POW10_EXPONENTS[]; + static const char DIGITS[]; + static const char RESET_COLOR[]; + static const wchar_t WRESET_COLOR[]; +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template struct basic_data; +#endif + +typedef basic_data<> 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 + +#if FMT_HAS_CPP_ATTRIBUTE(always_inline) +#define FMT_ALWAYS_INLINE __attribute__((always_inline)) +#else +#define FMT_ALWAYS_INLINE +#endif + +template +inline char *lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE; + +// Computes g = floor(log10(n)) and calls h.on(n); +template +inline char *lg(uint32_t n, Handler h) +{ + return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n) + : n < 1000000 ? n < 10000 ? n < 1000 ? h.template on<2>(n) : h.template on<3>(n) + : n < 100000 ? h.template on<4>(n) : h.template on<5>(n) + : n < 100000000 ? n < 10000000 ? h.template on<6>(n) : h.template on<7>(n) + : n < 1000000000 ? h.template on<8>(n) : h.template on<9>(n); +} + +// An lg handler that formats a decimal number. +// Usage: lg(n, decimal_formatter(buffer)); +class decimal_formatter +{ +private: + char *buffer_; + + void write_pair(unsigned N, uint32_t index) + { + std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2); + } + +public: + explicit decimal_formatter(char *buf) + : buffer_(buf) + { + } + + template + char *on(uint32_t u) + { + if (N == 0) + { + *buffer_ = static_cast(u) + '0'; + } + else if (N == 1) + { + write_pair(0, u); + } + else + { + // The idea of using 4.32 fixed-point numbers is based on + // https://github.com/jeaiii/itoa + unsigned n = N - 1; + unsigned a = n / 5 * n * 53 / 16; + uint64_t t = ((1ULL << (32 + a)) / data::POWERS_OF_10_32[n] + 1 - n / 9); + t = ((t * u) >> a) + n / 5 * 4; + write_pair(0, t >> 32); + for (unsigned i = 2; i < N; i += 2) + { + t = 100ULL * static_cast(t); + write_pair(i, t >> 32); + } + if (N % 2 == 0) + { + buffer_[N] = static_cast((10ULL * static_cast(t)) >> 32) + '0'; + } + } + return buffer_ += N + 1; + } +}; + +// An lg handler that formats a decimal number with a terminating null. +class decimal_formatter_null : public decimal_formatter +{ +public: + explicit decimal_formatter_null(char *buf) + : decimal_formatter(buf) + { + } + + template + char *on(uint32_t u) + { + char *buf = decimal_formatter::on(u); + *buf = '\0'; + return buf; + } +}; + +#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 no_thousands_sep +{ + typedef char char_type; + + template + void operator()(Char *) + { + } +}; + +// A functor that adds a thousands separator. +template +class add_thousands_sep +{ +private: + basic_string_view sep_; + + // Index of a decimal digit with the least significant digit having index 0. + unsigned digit_index_; + +public: + typedef Char char_type; + + explicit add_thousands_sep(basic_string_view sep) + : sep_(sep) + , digit_index_(0) + { + } + + void operator()(Char *&buffer) + { + if (++digit_index_ % 3 != 0) + return; + buffer -= sep_.size(); + std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), internal::make_checked(buffer, sep_.size())); + } +}; + +template +FMT_API Char thousands_sep(locale_provider *lp); + +// 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 +inline Char *format_decimal(Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep) +{ + buffer += num_digits; + Char *end = buffer; + 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((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('0' + value); + return end; + } + unsigned index = static_cast(value * 2); + *--buffer = data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = data::DIGITS[index]; + return end; +} + +template +inline Iterator format_decimal(Iterator out, UInt value, unsigned num_digits, ThousandsSep sep) +{ + typedef typename ThousandsSep::char_type char_type; + // Buffer should be large enough to hold all digits (digits10 + 1) and null. + char_type buffer[std::numeric_limits::digits10 + 2]; + format_decimal(buffer, value, num_digits, sep); + return std::copy_n(buffer, num_digits, out); +} + +template +inline It format_decimal(It out, UInt value, unsigned num_digits) +{ + return format_decimal(out, value, num_digits, no_thousands_sep()); +} + +template +inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits, bool upper = false) +{ + buffer += num_digits; + Char *end = buffer; + do + { + const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; + unsigned digit = (value & ((1 << BASE_BITS) - 1)); + *--buffer = BASE_BITS < 4 ? static_cast('0' + digit) : digits[digit]; + } while ((value >>= BASE_BITS) != 0); + return end; +} + +template +inline It format_uint(It out, UInt value, unsigned num_digits, bool upper = false) +{ + // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1) + // and null. + char buffer[std::numeric_limits::digits / BASE_BITS + 2]; + format_uint(buffer, value, num_digits, upper); + return std::copy_n(buffer, num_digits, out); +} + +#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 utf8_to_utf16 +{ +private: + wmemory_buffer buffer_; + +public: + FMT_API explicit utf8_to_utf16(string_view s); + operator wstring_view() const + { + return wstring_view(&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 utf16_to_utf8 +{ +private: + memory_buffer buffer_; + +public: + utf16_to_utf8() {} + FMT_API explicit utf16_to_utf8(wstring_view s); + operator string_view() const + { + return string_view(&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(wstring_view s); +}; + +FMT_API void format_windows_error(fmt::internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT; +#endif + +template +struct null +{ +}; +} // namespace internal + +struct monostate +{ +}; + +/** + \rst + Visits an argument dispatching to the appropriate visit method based on + the argument type. For example, if the argument type is ``double`` then + ``vis(value)`` will be called with the value of type ``double``. + \endrst + */ +template +FMT_CONSTEXPR typename internal::result_of::type visit(Visitor &&vis, basic_format_arg arg) +{ + typedef typename Context::char_type char_type; + switch (arg.type_) + { + case internal::none_type: + break; + case internal::named_arg_type: + FMT_ASSERT(false, "invalid argument type"); + break; + case internal::int_type: + return vis(arg.value_.int_value); + case internal::uint_type: + return vis(arg.value_.uint_value); + case internal::long_long_type: + return vis(arg.value_.long_long_value); + case internal::ulong_long_type: + return vis(arg.value_.ulong_long_value); + case internal::bool_type: + return vis(arg.value_.int_value != 0); + case internal::char_type: + return vis(static_cast(arg.value_.int_value)); + case internal::double_type: + return vis(arg.value_.double_value); + case internal::long_double_type: + return vis(arg.value_.long_double_value); + case internal::cstring_type: + return vis(arg.value_.string.value); + case internal::string_type: + return vis(basic_string_view(arg.value_.string.value, arg.value_.string.size)); + case internal::pointer_type: + return vis(arg.value_.pointer); + case internal::custom_type: + return vis(typename basic_format_arg::handle(arg.value_.custom)); + } + return vis(monostate()); +} + +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 +}; + +enum format_spec_tag +{ + fill_tag, + align_tag, + width_tag, + type_tag +}; + +// Format specifier. +template +class format_spec +{ +private: + T value_; + +public: + typedef T value_type; + + explicit format_spec(T value) + : value_(value) + { + } + + T value() const + { + return value_; + } +}; + +// template +// typedef format_spec fill_spec; +template +class fill_spec : public format_spec +{ +public: + explicit fill_spec(Char value) + : format_spec(value) + { + } +}; + +typedef format_spec width_spec; +typedef format_spec type_spec; + +// An empty format specifier. +struct empty_spec +{ +}; + +// An alignment specifier. +struct align_spec : empty_spec +{ + unsigned width_; + // Fill is always wchar_t and cast to char if necessary to avoid having + // two specialization of AlignSpec and its subclasses. + wchar_t fill_; + alignment align_; + + FMT_CONSTEXPR align_spec(unsigned width, wchar_t fill, alignment align = ALIGN_DEFAULT) + : width_(width) + , fill_(fill) + , align_(align) + { + } + + FMT_CONSTEXPR unsigned width() const + { + return width_; + } + FMT_CONSTEXPR wchar_t fill() const + { + return fill_; + } + FMT_CONSTEXPR alignment align() const + { + return align_; + } + + int precision() const + { + return -1; + } +}; + +// Format specifiers. +template +class basic_format_specs : public align_spec +{ +public: + unsigned flags_; + int precision_; + Char type_; + + FMT_CONSTEXPR basic_format_specs(unsigned width = 0, char type = 0, wchar_t fill = ' ') + : align_spec(width, fill) + , flags_(0) + , precision_(-1) + , type_(type) + { + } + + FMT_CONSTEXPR bool flag(unsigned f) const + { + return (flags_ & f) != 0; + } + FMT_CONSTEXPR int precision() const + { + return precision_; + } + FMT_CONSTEXPR Char type() const + { + return type_; + } +}; + +typedef basic_format_specs format_specs; + +template +FMT_CONSTEXPR unsigned basic_parse_context::next_arg_id() +{ + if (next_arg_id_ >= 0) + return internal::to_unsigned(next_arg_id_++); + on_error("cannot switch from manual to automatic argument indexing"); + return 0; +} + +struct format_string +{ +}; + +namespace internal { + +template +FMT_CONSTEXPR void handle_int_type_spec(Char spec, Handler &&handler) +{ + switch (spec) + { + case 0: + case 'd': + handler.on_dec(); + break; + case 'x': + case 'X': + handler.on_hex(); + break; + case 'b': + case 'B': + handler.on_bin(); + break; + case 'o': + handler.on_oct(); + break; + case 'n': + handler.on_num(); + break; + default: + handler.on_error(); + } +} + +template +FMT_CONSTEXPR void handle_float_type_spec(Char spec, Handler &&handler) +{ + switch (spec) + { + case 0: + case 'g': + case 'G': + handler.on_general(); + break; + case 'e': + case 'E': + handler.on_exp(); + break; + case 'f': + case 'F': + handler.on_fixed(); + break; + case 'a': + case 'A': + handler.on_hex(); + break; + default: + handler.on_error(); + break; + } +} + +template +FMT_CONSTEXPR void handle_char_specs(const basic_format_specs &specs, Handler &&handler) +{ + if (specs.type() && specs.type() != 'c') + { + handler.on_int(); + return; + } + if (specs.align() == ALIGN_NUMERIC || specs.flag(~0u) != 0) + handler.on_error("invalid format specifier for char"); + handler.on_char(); +} + +template +FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler) +{ + if (spec == 0 || spec == 's') + handler.on_string(); + else if (spec == 'p') + handler.on_pointer(); + else + handler.on_error("invalid type specifier"); +} + +template +FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh) +{ + if (spec != 0 && spec != 's') + eh.on_error("invalid type specifier"); +} + +template +FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh) +{ + if (spec != 0 && spec != 'p') + eh.on_error("invalid type specifier"); +} + +template +class int_type_checker : private ErrorHandler +{ +public: + FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) + : ErrorHandler(eh) + { + } + + FMT_CONSTEXPR void on_dec() {} + FMT_CONSTEXPR void on_hex() {} + FMT_CONSTEXPR void on_bin() {} + FMT_CONSTEXPR void on_oct() {} + FMT_CONSTEXPR void on_num() {} + + FMT_CONSTEXPR void on_error() + { + ErrorHandler::on_error("invalid type specifier"); + } +}; + +template +class float_type_checker : private ErrorHandler +{ +public: + FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh) + : ErrorHandler(eh) + { + } + + FMT_CONSTEXPR void on_general() {} + FMT_CONSTEXPR void on_exp() {} + FMT_CONSTEXPR void on_fixed() {} + FMT_CONSTEXPR void on_hex() {} + + FMT_CONSTEXPR void on_error() + { + ErrorHandler::on_error("invalid type specifier"); + } +}; + +template +class char_specs_checker : public ErrorHandler +{ +private: + CharType type_; + +public: + FMT_CONSTEXPR char_specs_checker(CharType type, ErrorHandler eh) + : ErrorHandler(eh) + , type_(type) + { + } + + FMT_CONSTEXPR void on_int() + { + handle_int_type_spec(type_, int_type_checker(*this)); + } + FMT_CONSTEXPR void on_char() {} +}; + +template +class cstring_type_checker : public ErrorHandler +{ +public: + FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh) + : ErrorHandler(eh) + { + } + + FMT_CONSTEXPR void on_string() {} + FMT_CONSTEXPR void on_pointer() {} +}; + +template +void arg_map::init(const basic_format_args &args) +{ + if (map_) + return; + map_ = new entry[args.max_size()]; + bool use_values = args.type(max_packed_args - 1) == internal::none_type; + if (use_values) + { + for (unsigned i = 0; /*nothing*/; ++i) + { + internal::type arg_type = args.type(i); + switch (arg_type) + { + case internal::none_type: + return; + case internal::named_arg_type: + push_back(args.values_[i]); + break; + default: + break; // Do nothing. + } + } + return; + } + for (unsigned i = 0;; ++i) + { + switch (args.args_[i].type_) + { + case internal::none_type: + return; + case internal::named_arg_type: + push_back(args.args_[i].value_); + break; + default: + break; // Do nothing. + } + } +} + +template +class arg_formatter_base +{ +public: + typedef typename Range::value_type char_type; + typedef decltype(internal::declval().begin()) iterator; + typedef basic_format_specs format_specs; + +private: + typedef basic_writer writer_type; + writer_type writer_; + format_specs &specs_; + + FMT_DISALLOW_COPY_AND_ASSIGN(arg_formatter_base); + + struct char_writer + { + char_type value; + template + void operator()(It &&it) const + { + *it++ = value; + } + }; + + void write_char(char_type value) + { + writer_.write_padded(1, specs_, char_writer{value}); + } + + void write_pointer(const void *p) + { + format_specs specs = specs_; + specs.flags_ = HASH_FLAG; + specs.type_ = 'x'; + writer_.write_int(reinterpret_cast(p), specs); + } + +protected: + writer_type &writer() + { + return writer_; + } + format_specs &spec() + { + return specs_; + } + iterator out() + { + return writer_.out(); + } + + void write(bool value) + { + writer_.write_str(string_view(value ? "true" : "false"), specs_); + } + + void write(const char_type *value) + { + if (!value) + FMT_THROW(format_error("string pointer is null")); + auto length = std::char_traits::length(value); + writer_.write_str(basic_string_view(value, length), specs_); + } + +public: + arg_formatter_base(Range r, format_specs &s) + : writer_(r) + , specs_(s) + { + } + + iterator operator()(monostate) + { + FMT_ASSERT(false, "invalid argument type"); + return out(); + } + + template + typename std::enable_if::value, iterator>::type operator()(T value) + { + // MSVC2013 fails to compile separate overloads for bool and char_type so + // use std::is_same instead. + if (std::is_same::value) + { + if (specs_.type_) + return (*this)(value ? 1 : 0); + write(value != 0); + } + else if (std::is_same::value) + { + internal::handle_char_specs(specs_, char_spec_handler(*this, static_cast(value))); + } + else + { + writer_.write_int(value, specs_); + } + return out(); + } + + template + typename std::enable_if::value, iterator>::type operator()(T value) + { + writer_.write_double(value, specs_); + return out(); + } + + struct char_spec_handler : internal::error_handler + { + arg_formatter_base &formatter; + char_type value; + + char_spec_handler(arg_formatter_base &f, char_type val) + : formatter(f) + , value(val) + { + } + + void on_int() + { + formatter.writer_.write_int(value, formatter.specs_); + } + void on_char() + { + formatter.write_char(value); + } + }; + + struct cstring_spec_handler : internal::error_handler + { + arg_formatter_base &formatter; + const char_type *value; + + cstring_spec_handler(arg_formatter_base &f, const char_type *val) + : formatter(f) + , value(val) + { + } + + void on_string() + { + formatter.write(value); + } + void on_pointer() + { + formatter.write_pointer(value); + } + }; + + iterator operator()(const char_type *value) + { + internal::handle_cstring_type_spec(specs_.type_, cstring_spec_handler(*this, value)); + return out(); + } + + iterator operator()(basic_string_view value) + { + internal::check_string_type_spec(specs_.type_, internal::error_handler()); + writer_.write_str(value, specs_); + return out(); + } + + iterator operator()(const void *value) + { + check_pointer_type_spec(specs_.type_, internal::error_handler()); + write_pointer(value); + return out(); + } +}; + +template +struct is_format_string : std::integral_constant::value> +{ +}; + +template +FMT_CONSTEXPR bool is_name_start(Char c) +{ + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; +} + +// Parses the input as an unsigned integer. This function assumes that the +// first character is a digit and presence of a non-digit character at the end. +// it: an iterator pointing to the beginning of the input range. +template +FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) +{ + assert('0' <= *it && *it <= '9'); + unsigned value = 0; + // Convert to unsigned to prevent a warning. + unsigned max_int = (std::numeric_limits::max)(); + unsigned big = max_int / 10; + do + { + // Check for overflow. + if (value > big) + { + value = max_int + 1; + break; + } + value = value * 10 + unsigned(*it - '0'); + // Workaround for MSVC "setup_exception stack overflow" error: + auto next = it; + ++next; + it = next; + } while ('0' <= *it && *it <= '9'); + if (value > max_int) + eh.on_error("number is too big"); + return value; +} + +template +class custom_formatter : public function +{ +private: + Context &ctx_; + +public: + explicit custom_formatter(Context &ctx) + : ctx_(ctx) + { + } + + bool operator()(typename basic_format_arg::handle h) const + { + h.format(ctx_); + return true; + } + + template + bool operator()(T) const + { + return false; + } +}; + +template +struct is_integer +{ + enum + { + value = + std::is_integral::value && !std::is_same::value && !std::is_same::value && !std::is_same::value + }; +}; + +template +class width_checker : public function +{ +public: + explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh) + : handler_(eh) + { + } + + template + FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T value) + { + if (is_negative(value)) + handler_.on_error("negative width"); + return static_cast(value); + } + + template + FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T) + { + handler_.on_error("width is not integer"); + return 0; + } + +private: + ErrorHandler &handler_; +}; + +template +class precision_checker : public function +{ +public: + explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh) + : handler_(eh) + { + } + + template + FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T value) + { + if (is_negative(value)) + handler_.on_error("negative precision"); + return static_cast(value); + } + + template + FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T) + { + handler_.on_error("precision is not integer"); + return 0; + } + +private: + ErrorHandler &handler_; +}; + +// A format specifier handler that sets fields in basic_format_specs. +template +class specs_setter +{ +public: + explicit FMT_CONSTEXPR specs_setter(basic_format_specs &specs) + : specs_(specs) + { + } + + FMT_CONSTEXPR specs_setter(const specs_setter &other) + : specs_(other.specs_) + { + } + + FMT_CONSTEXPR void on_align(alignment align) + { + specs_.align_ = align; + } + FMT_CONSTEXPR void on_fill(Char fill) + { + specs_.fill_ = fill; + } + FMT_CONSTEXPR void on_plus() + { + specs_.flags_ |= SIGN_FLAG | PLUS_FLAG; + } + FMT_CONSTEXPR void on_minus() + { + specs_.flags_ |= MINUS_FLAG; + } + FMT_CONSTEXPR void on_space() + { + specs_.flags_ |= SIGN_FLAG; + } + FMT_CONSTEXPR void on_hash() + { + specs_.flags_ |= HASH_FLAG; + } + + FMT_CONSTEXPR void on_zero() + { + specs_.align_ = ALIGN_NUMERIC; + specs_.fill_ = '0'; + } + + FMT_CONSTEXPR void on_width(unsigned width) + { + specs_.width_ = width; + } + FMT_CONSTEXPR void on_precision(unsigned precision) + { + specs_.precision_ = static_cast(precision); + } + FMT_CONSTEXPR void end_precision() {} + + FMT_CONSTEXPR void on_type(Char type) + { + specs_.type_ = type; + } + +protected: + basic_format_specs &specs_; +}; + +// A format specifier handler that checks if specifiers are consistent with the +// argument type. +template +class specs_checker : public Handler +{ +public: + FMT_CONSTEXPR specs_checker(const Handler &handler, internal::type arg_type) + : Handler(handler) + , arg_type_(arg_type) + { + } + + FMT_CONSTEXPR specs_checker(const specs_checker &other) + : Handler(other) + , arg_type_(other.arg_type_) + { + } + + FMT_CONSTEXPR void on_align(alignment align) + { + if (align == ALIGN_NUMERIC) + require_numeric_argument(); + Handler::on_align(align); + } + + FMT_CONSTEXPR void on_plus() + { + check_sign(); + Handler::on_plus(); + } + + FMT_CONSTEXPR void on_minus() + { + check_sign(); + Handler::on_minus(); + } + + FMT_CONSTEXPR void on_space() + { + check_sign(); + Handler::on_space(); + } + + FMT_CONSTEXPR void on_hash() + { + require_numeric_argument(); + Handler::on_hash(); + } + + FMT_CONSTEXPR void on_zero() + { + require_numeric_argument(); + Handler::on_zero(); + } + + FMT_CONSTEXPR void end_precision() + { + if (is_integral(arg_type_) || arg_type_ == pointer_type) + this->on_error("precision not allowed for this argument type"); + } + +private: + FMT_CONSTEXPR void require_numeric_argument() + { + if (!is_arithmetic(arg_type_)) + this->on_error("format specifier requires numeric argument"); + } + + FMT_CONSTEXPR void check_sign() + { + require_numeric_argument(); + if (is_integral(arg_type_) && arg_type_ != int_type && arg_type_ != long_long_type && arg_type_ != internal::char_type) + { + this->on_error("format specifier requires signed argument"); + } + } + + internal::type arg_type_; +}; + +template class Handler, typename T, typename Context, typename ErrorHandler> +FMT_CONSTEXPR void set_dynamic_spec(T &value, basic_format_arg arg, ErrorHandler eh) +{ + unsigned long long big_value = visit(Handler(eh), arg); + if (big_value > (std::numeric_limits::max)()) + eh.on_error("number is too big"); + value = static_cast(big_value); +} + +struct auto_id +{ +}; + +// The standard format specifier handler with checking. +template +class specs_handler : public specs_setter +{ +public: + typedef typename Context::char_type char_type; + + FMT_CONSTEXPR specs_handler(basic_format_specs &specs, Context &ctx) + : specs_setter(specs) + , context_(ctx) + { + } + + template + FMT_CONSTEXPR void on_dynamic_width(Id arg_id) + { + set_dynamic_spec(this->specs_.width_, get_arg(arg_id), context_.error_handler()); + } + + template + FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) + { + set_dynamic_spec(this->specs_.precision_, get_arg(arg_id), context_.error_handler()); + } + + void on_error(const char *message) + { + context_.on_error(message); + } + +private: + FMT_CONSTEXPR basic_format_arg get_arg(auto_id) + { + return context_.next_arg(); + } + + template + FMT_CONSTEXPR basic_format_arg get_arg(Id arg_id) + { + context_.parse_context().check_arg_id(arg_id); + return context_.get_arg(arg_id); + } + + Context &context_; +}; + +// An argument reference. +template +struct arg_ref +{ + enum Kind + { + NONE, + INDEX, + NAME + }; + + FMT_CONSTEXPR arg_ref() + : kind(NONE) + , index(0) + { + } + FMT_CONSTEXPR explicit arg_ref(unsigned index) + : kind(INDEX) + , index(index) + { + } + explicit arg_ref(basic_string_view name) + : kind(NAME) + , name(name) + { + } + + FMT_CONSTEXPR arg_ref &operator=(unsigned idx) + { + kind = INDEX; + index = idx; + return *this; + } + + Kind kind; + FMT_UNION + { + unsigned index; + basic_string_view name; + }; +}; + +// Format specifiers with width and precision resolved at formatting rather +// than parsing time to allow re-using the same parsed specifiers with +// differents sets of arguments (precompilation of format strings). +template +struct dynamic_format_specs : basic_format_specs +{ + arg_ref width_ref; + arg_ref precision_ref; +}; + +// Format spec handler that saves references to arguments representing dynamic +// width and precision to be resolved at formatting time. +template +class dynamic_specs_handler : public specs_setter +{ +public: + typedef typename ParseContext::char_type char_type; + + FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs &specs, ParseContext &ctx) + : specs_setter(specs) + , specs_(specs) + , context_(ctx) + { + } + + FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other) + : specs_setter(other) + , specs_(other.specs_) + , context_(other.context_) + { + } + + template + FMT_CONSTEXPR void on_dynamic_width(Id arg_id) + { + specs_.width_ref = make_arg_ref(arg_id); + } + + template + FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) + { + specs_.precision_ref = make_arg_ref(arg_id); + } + + FMT_CONSTEXPR void on_error(const char *message) + { + context_.on_error(message); + } + +private: + typedef arg_ref arg_ref_type; + + template + FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) + { + context_.check_arg_id(arg_id); + return arg_ref_type(arg_id); + } + + FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) + { + return arg_ref_type(context_.next_arg_id()); + } + + dynamic_format_specs &specs_; + ParseContext &context_; +}; + +template +FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler) +{ + typedef typename std::iterator_traits::value_type char_type; + char_type c = *it; + if (c == '}' || c == ':') + { + handler(); + return it; + } + if (c >= '0' && c <= '9') + { + unsigned index = parse_nonnegative_int(it, handler); + if (*it != '}' && *it != ':') + { + handler.on_error("invalid format string"); + return it; + } + handler(index); + return it; + } + if (!is_name_start(c)) + { + handler.on_error("invalid format string"); + return it; + } + auto start = it; + do + { + c = *++it; + } while (is_name_start(c) || ('0' <= c && c <= '9')); + handler(basic_string_view(pointer_from(start), to_unsigned(it - start))); + return it; +} + +// Adapts SpecHandler to IDHandler API for dynamic width. +template +struct width_adapter +{ + explicit FMT_CONSTEXPR width_adapter(SpecHandler &h) + : handler(h) + { + } + + FMT_CONSTEXPR void operator()() + { + handler.on_dynamic_width(auto_id()); + } + FMT_CONSTEXPR void operator()(unsigned id) + { + handler.on_dynamic_width(id); + } + FMT_CONSTEXPR void operator()(basic_string_view id) + { + handler.on_dynamic_width(id); + } + + FMT_CONSTEXPR void on_error(const char *message) + { + handler.on_error(message); + } + + SpecHandler &handler; +}; + +// Adapts SpecHandler to IDHandler API for dynamic precision. +template +struct precision_adapter +{ + explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h) + : handler(h) + { + } + + FMT_CONSTEXPR void operator()() + { + handler.on_dynamic_precision(auto_id()); + } + FMT_CONSTEXPR void operator()(unsigned id) + { + handler.on_dynamic_precision(id); + } + FMT_CONSTEXPR void operator()(basic_string_view id) + { + handler.on_dynamic_precision(id); + } + + FMT_CONSTEXPR void on_error(const char *message) + { + handler.on_error(message); + } + + SpecHandler &handler; +}; + +// Parses standard format specifiers and sends notifications about parsed +// components to handler. +// it: an iterator pointing to the beginning of a null-terminated range of +// characters, possibly emulated via null_terminating_iterator, representing +// format specifiers. +template +FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler) +{ + typedef typename std::iterator_traits::value_type char_type; + char_type c = *it; + if (c == '}' || !c) + return it; + + // Parse fill and alignment. + alignment align = ALIGN_DEFAULT; + int i = 1; + do + { + auto p = it + i; + switch (*p) + { + case '<': + align = ALIGN_LEFT; + break; + case '>': + align = ALIGN_RIGHT; + break; + case '=': + align = ALIGN_NUMERIC; + break; + case '^': + align = ALIGN_CENTER; + break; + } + if (align != ALIGN_DEFAULT) + { + if (p != it) + { + if (c == '{') + { + handler.on_error("invalid fill character '{'"); + return it; + } + it += 2; + handler.on_fill(c); + } + else + ++it; + handler.on_align(align); + break; + } + } while (--i >= 0); + + // Parse sign. + switch (*it) + { + case '+': + handler.on_plus(); + ++it; + break; + case '-': + handler.on_minus(); + ++it; + break; + case ' ': + handler.on_space(); + ++it; + break; + } + + if (*it == '#') + { + handler.on_hash(); + ++it; + } + + // Parse zero flag. + if (*it == '0') + { + handler.on_zero(); + ++it; + } + + // Parse width. + if ('0' <= *it && *it <= '9') + { + handler.on_width(parse_nonnegative_int(it, handler)); + } + else if (*it == '{') + { + it = parse_arg_id(it + 1, width_adapter(handler)); + if (*it++ != '}') + { + handler.on_error("invalid format string"); + return it; + } + } + + // Parse precision. + if (*it == '.') + { + ++it; + if ('0' <= *it && *it <= '9') + { + handler.on_precision(parse_nonnegative_int(it, handler)); + } + else if (*it == '{') + { + it = parse_arg_id(it + 1, precision_adapter(handler)); + if (*it++ != '}') + { + handler.on_error("invalid format string"); + return it; + } + } + else + { + handler.on_error("missing precision specifier"); + return it; + } + handler.end_precision(); + } + + // Parse type. + if (*it != '}' && *it) + handler.on_type(*it++); + return it; +} + +template +struct id_adapter +{ + FMT_CONSTEXPR explicit id_adapter(Handler &h) + : handler(h) + { + } + + FMT_CONSTEXPR void operator()() + { + handler.on_arg_id(); + } + FMT_CONSTEXPR void operator()(unsigned id) + { + handler.on_arg_id(id); + } + FMT_CONSTEXPR void operator()(basic_string_view id) + { + handler.on_arg_id(id); + } + + FMT_CONSTEXPR void on_error(const char *message) + { + handler.on_error(message); + } + + Handler &handler; +}; + +template +FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler) +{ + typedef typename std::iterator_traits::value_type char_type; + auto start = it; + while (*it) + { + char_type ch = *it++; + if (ch != '{' && ch != '}') + continue; + if (*it == ch) + { + handler.on_text(start, it); + start = ++it; + continue; + } + if (ch == '}') + { + handler.on_error("unmatched '}' in format string"); + return; + } + handler.on_text(start, it - 1); + + it = parse_arg_id(it, id_adapter(handler)); + if (*it == '}') + { + handler.on_replacement_field(it); + } + else if (*it == ':') + { + ++it; + it = handler.on_format_specs(it); + if (*it != '}') + { + handler.on_error("unknown format specifier"); + return; + } + } + else + { + handler.on_error("missing '}' in format string"); + return; + } + + start = ++it; + } + handler.on_text(start, it); +} + +template +FMT_CONSTEXPR const typename ParseContext::char_type *parse_format_specs(ParseContext &ctx) +{ + // GCC 7.2 requires initializer. + formatter f{}; + return f.parse(ctx); +} + +template +class format_string_checker +{ +public: + explicit FMT_CONSTEXPR format_string_checker(basic_string_view format_str, ErrorHandler eh) + : arg_id_(-1) + , context_(format_str, eh) + , parse_funcs_{&parse_format_specs...} + { + } + + FMT_CONSTEXPR void on_text(const Char *, const Char *) {} + + FMT_CONSTEXPR void on_arg_id() + { + arg_id_ = context_.next_arg_id(); + check_arg_id(); + } + FMT_CONSTEXPR void on_arg_id(unsigned id) + { + arg_id_ = id; + context_.check_arg_id(id); + check_arg_id(); + } + FMT_CONSTEXPR void on_arg_id(basic_string_view) {} + + FMT_CONSTEXPR void on_replacement_field(const Char *) {} + + FMT_CONSTEXPR const Char *on_format_specs(const Char *s) + { + context_.advance_to(s); + return to_unsigned(arg_id_) < NUM_ARGS ? parse_funcs_[arg_id_](context_) : s; + } + + FMT_CONSTEXPR void on_error(const char *message) + { + context_.on_error(message); + } + +private: + typedef basic_parse_context parse_context_type; + enum + { + NUM_ARGS = sizeof...(Args) + }; + + FMT_CONSTEXPR void check_arg_id() + { + if (internal::to_unsigned(arg_id_) >= NUM_ARGS) + context_.on_error("argument index out of range"); + } + + // Format specifier parsing function. + typedef const Char *(*parse_func)(parse_context_type &); + + int arg_id_; + parse_context_type context_; + parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1]; +}; + +template +FMT_CONSTEXPR bool check_format_string(basic_string_view s, ErrorHandler eh = ErrorHandler()) +{ + format_string_checker checker(s, eh); + parse_format_string(s.begin(), checker); + return true; +} + +template +void check_format_string(String format_str) +{ + FMT_CONSTEXPR_DECL bool invalid_format = + internal::check_format_string(string_view(format_str.data(), format_str.size())); + (void)invalid_format; +} + +// Specifies whether to format T using the standard formatter. +// It is not possible to use get_type in formatter specialization directly +// because of a bug in MSVC. +template +struct format_type : std::integral_constant::value != custom_type> +{ +}; + +// Specifies whether to format enums. +template +struct format_enum : std::integral_constant::value> +{ +}; + +template class Handler, typename Spec, typename Context> +void handle_dynamic_spec(Spec &value, arg_ref ref, Context &ctx) +{ + typedef typename Context::char_type char_type; + switch (ref.kind) + { + case arg_ref::NONE: + break; + case arg_ref::INDEX: + internal::set_dynamic_spec(value, ctx.get_arg(ref.index), ctx.error_handler()); + break; + case arg_ref::NAME: + internal::set_dynamic_spec(value, ctx.get_arg(ref.name), ctx.error_handler()); + break; + } +} +} // namespace internal + +/** The default argument formatter. */ +template +class arg_formatter : public internal::function::iterator>, + public internal::arg_formatter_base +{ +private: + typedef typename Range::value_type char_type; + typedef internal::arg_formatter_base base; + typedef basic_format_context context_type; + + context_type &ctx_; + +public: + typedef Range range; + typedef typename base::iterator iterator; + typedef typename base::format_specs format_specs; + + /** + \rst + Constructs an argument formatter object. + *ctx* is a reference to the formatting context, + *spec* contains format specifier information for standard argument types. + \endrst + */ + arg_formatter(context_type &ctx, format_specs &spec) + : base(Range(ctx.out()), spec) + , ctx_(ctx) + { + } + + using base::operator(); + + /** Formats an argument of a user-defined type. */ + iterator operator()(typename basic_format_arg::handle handle) + { + handle.format(ctx_); + return this->out(); + } +}; + +/** + An error returned by an operating system or a language runtime, + for example a file opening error. +*/ +class system_error : public std::runtime_error +{ +private: + FMT_API void init(int err_code, string_view format_str, format_args args); + +protected: + int error_code_; + + system_error() + : std::runtime_error("") + { + } + +public: + /** + \rst + Constructs a :class:`fmt::system_error` 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 system_error 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::system_error(errno, "cannot open file '{}'", filename); + \endrst + */ + template + system_error(int error_code, string_view message, const Args &... args) + : std::runtime_error("") + { + init(error_code, message, make_format_args(args...)); + } + + 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:: + **: ** + + where ** is the passed message and ** 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(internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT; + +/** + This template provides operations for formatting and writing data into a + character range. + */ +template +class basic_writer +{ +public: + typedef typename Range::value_type char_type; + typedef decltype(internal::declval().begin()) iterator; + typedef basic_format_specs format_specs; + +private: + // Output iterator. + iterator out_; + + std::unique_ptr locale_; + + FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer); + + iterator out() const + { + return out_; + } + + // Attempts to reserve space for n extra characters in the output range. + // Returns a pointer to the reserved range or a reference to out_. + auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) + { + return internal::reserve(out_, n); + } + + // Writes a value in the format + // + // where is written by f(it). + template + void write_padded(std::size_t size, const align_spec &spec, F f); + + template + struct padded_int_writer + { + string_view prefix; + char_type fill; + std::size_t padding; + F f; + + template + void operator()(It &&it) const + { + if (prefix.size() != 0) + it = std::copy_n(prefix.data(), prefix.size(), it); + it = std::fill_n(it, padding, fill); + f(it); + } + }; + + // Writes an integer in the format + // + // where are written by f(it). + template + void write_int(unsigned num_digits, string_view prefix, const Spec &spec, F f) + { + std::size_t size = prefix.size() + num_digits; + char_type fill = static_cast(spec.fill()); + std::size_t padding = 0; + if (spec.align() == ALIGN_NUMERIC) + { + if (spec.width() > size) + { + padding = spec.width() - size; + size = spec.width(); + } + } + else if (spec.precision() > static_cast(num_digits)) + { + size = prefix.size() + static_cast(spec.precision()); + padding = static_cast(spec.precision()) - num_digits; + fill = '0'; + } + align_spec as = spec; + if (spec.align() == ALIGN_DEFAULT) + as.align_ = ALIGN_RIGHT; + write_padded(size, as, padded_int_writer{prefix, fill, padding, f}); + } + + // Writes a decimal integer. + template + void write_decimal(Int value) + { + typedef typename internal::int_traits::main_type main_type; + main_type abs_value = static_cast(value); + bool is_negative = internal::is_negative(value); + if (is_negative) + abs_value = 0 - abs_value; + unsigned num_digits = internal::count_digits(abs_value); + auto &&it = reserve((is_negative ? 1 : 0) + num_digits); + if (is_negative) + *it++ = '-'; + internal::format_decimal(it, abs_value, num_digits); + } + + // The handle_int_type_spec handler that writes an integer. + template + struct int_writer + { + typedef typename internal::int_traits::main_type unsigned_type; + + basic_writer &writer; + const Spec &spec; + unsigned_type abs_value; + char prefix[4]; + unsigned prefix_size; + + string_view get_prefix() const + { + return string_view(prefix, prefix_size); + } + + // Counts the number of digits in abs_value. BITS = log2(radix). + template + unsigned count_digits() const + { + unsigned_type n = abs_value; + unsigned num_digits = 0; + do + { + ++num_digits; + } while ((n >>= BITS) != 0); + return num_digits; + } + + int_writer(basic_writer &w, Int value, const Spec &s) + : writer(w) + , spec(s) + , abs_value(static_cast(value)) + , prefix_size(0) + { + 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; + } + } + + struct dec_writer + { + unsigned_type abs_value; + unsigned num_digits; + + template + void operator()(It &&it) const + { + it = internal::format_decimal(it, abs_value, num_digits); + } + }; + + void on_dec() + { + unsigned num_digits = internal::count_digits(abs_value); + writer.write_int(num_digits, get_prefix(), spec, dec_writer{abs_value, num_digits}); + } + + struct hex_writer + { + int_writer &self; + unsigned num_digits; + + template + void operator()(It &&it) const + { + it = internal::format_uint<4>(it, self.abs_value, num_digits, self.spec.type() != 'x'); + } + }; + + void on_hex() + { + if (spec.flag(HASH_FLAG)) + { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = static_cast(spec.type()); + } + unsigned num_digits = count_digits<4>(); + writer.write_int(num_digits, get_prefix(), spec, hex_writer{*this, num_digits}); + } + + template + struct bin_writer + { + unsigned_type abs_value; + unsigned num_digits; + + template + void operator()(It &&it) const + { + it = internal::format_uint(it, abs_value, num_digits); + } + }; + + void on_bin() + { + if (spec.flag(HASH_FLAG)) + { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = static_cast(spec.type()); + } + unsigned num_digits = count_digits<1>(); + writer.write_int(num_digits, get_prefix(), spec, bin_writer<1>{abs_value, num_digits}); + } + + void on_oct() + { + unsigned num_digits = count_digits<3>(); + if (spec.flag(HASH_FLAG) && spec.precision() <= static_cast(num_digits)) + { + // Octal prefix '0' is counted as a digit, so only add it if precision + // is not greater than the number of digits. + prefix[prefix_size++] = '0'; + } + writer.write_int(num_digits, get_prefix(), spec, bin_writer<3>{abs_value, num_digits}); + } + + enum + { + SEP_SIZE = 1 + }; + + struct num_writer + { + unsigned_type abs_value; + unsigned size; + char_type sep; + + template + void operator()(It &&it) const + { + basic_string_view s(&sep, SEP_SIZE); + it = format_decimal(it, abs_value, size, internal::add_thousands_sep(s)); + } + }; + + void on_num() + { + unsigned num_digits = internal::count_digits(abs_value); + char_type sep = internal::thousands_sep(writer.locale_.get()); + unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3); + writer.write_int(size, get_prefix(), spec, num_writer{abs_value, size, sep}); + } + + void on_error() + { + FMT_THROW(format_error("invalid type specifier")); + } + }; + + // Writes a formatted integer. + template + void write_int(T value, const Spec &spec) + { + internal::handle_int_type_spec(spec.type(), int_writer(*this, value, spec)); + } + + enum + { + INF_SIZE = 3 + }; // This is an enum to workaround a bug in MSVC. + + struct inf_or_nan_writer + { + char sign; + const char *str; + + template + void operator()(It &&it) const + { + if (sign) + *it++ = sign; + it = std::copy_n(str, static_cast(INF_SIZE), it); + } + }; + + struct double_writer + { + size_t n; + char sign; + basic_memory_buffer &buffer; + + template + void operator()(It &&it) + { + if (sign) + { + *it++ = sign; + --n; + } + it = std::copy_n(buffer.begin(), n, it); + } + }; + + // Formats a floating-point number (double or long double). + template + void write_double(T value, const format_specs &spec); + template + void write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer &buffer); + + template + struct str_writer + { + const Char *s; + std::size_t size; + + template + void operator()(It &&it) const + { + it = std::copy_n(s, size, it); + } + }; + + // Writes a formatted string. + template + void write_str(const Char *s, std::size_t size, const align_spec &spec) + { + write_padded(size, spec, str_writer{s, size}); + } + + template + void write_str(basic_string_view str, const format_specs &spec); + + // Appends floating-point length specifier to the format string. + // The second argument is only used for overload resolution. + void append_float_length(char_type *&format_ptr, long double) + { + *format_ptr++ = 'L'; + } + + template + void append_float_length(char_type *&, T) + { + } + + template + friend class internal::arg_formatter_base; + +public: + /** Constructs a ``basic_writer`` object. */ + explicit basic_writer(Range out) + : out_(out.begin()) + { + } + + void write(int value) + { + write_decimal(value); + } + void write(long value) + { + write_decimal(value); + } + void write(long long value) + { + write_decimal(value); + } + + void write(unsigned value) + { + write_decimal(value); + } + void write(unsigned long value) + { + write_decimal(value); + } + void write(unsigned long long value) + { + write_decimal(value); + } + + /** + \rst + Formats *value* and writes it to the buffer. + \endrst + */ + template + typename std::enable_if::value, void>::type write(T value, FormatSpec spec, FormatSpecs... specs) + { + format_specs s(spec, specs...); + s.align_ = ALIGN_RIGHT; + write_int(value, s); + } + + void write(double value) + { + write_double(value, format_specs()); + } + + /** + \rst + Formats *value* using the general format for floating-point numbers + (``'g'``) and writes it to the buffer. + \endrst + */ + void write(long double value) + { + write_double(value, format_specs()); + } + + /** Writes a character to the buffer. */ + void write(char value) + { + *reserve(1) = value; + } + + void write(wchar_t value) + { + internal::require_wchar(); + *reserve(1) = value; + } + + /** + \rst + Writes *value* to the buffer. + \endrst + */ + void write(string_view value) + { + auto &&it = reserve(value.size()); + it = std::copy(value.begin(), value.end(), it); + } + + void write(wstring_view value) + { + internal::require_wchar(); + auto &&it = reserve(value.size()); + it = std::uninitialized_copy(value.begin(), value.end(), it); + } + + template + void write(basic_string_view str, FormatSpecs... specs) + { + write_str(str, format_specs(specs...)); + } + + template + typename std::enable_if::value>::type write(const T *p) + { + format_specs specs; + specs.flags_ = HASH_FLAG; + specs.type_ = 'x'; + write_int(reinterpret_cast(p), specs); + } +}; + +template +template +void basic_writer::write_padded(std::size_t size, const align_spec &spec, F f) +{ + unsigned width = spec.width(); + if (width <= size) + return f(reserve(size)); + auto &&it = reserve(width); + char_type fill = static_cast(spec.fill()); + std::size_t padding = width - size; + if (spec.align() == ALIGN_RIGHT) + { + it = std::fill_n(it, padding, fill); + f(it); + } + else if (spec.align() == ALIGN_CENTER) + { + std::size_t left_padding = padding / 2; + it = std::fill_n(it, left_padding, fill); + f(it); + it = std::fill_n(it, padding - left_padding, fill); + } + else + { + f(it); + it = std::fill_n(it, padding, fill); + } +} + +template +template +void basic_writer::write_str(basic_string_view s, const format_specs &spec) +{ + const Char *data = s.data(); + std::size_t size = s.size(); + std::size_t precision = static_cast(spec.precision_); + if (spec.precision_ >= 0 && precision < size) + size = precision; + write_str(data, size, spec); +} + +template +struct float_spec_handler +{ + Char type; + bool upper; + + explicit float_spec_handler(Char t) + : type(t) + , upper(false) + { + } + + void on_general() + { + if (type == 'G') + upper = true; + else + type = 'g'; + } + + void on_exp() + { + if (type == 'E') + upper = true; + } + + void on_fixed() + { + if (type == 'F') + { + upper = true; +#if FMT_MSC_VER + // MSVC's printf doesn't support 'F'. + type = 'f'; +#endif + } + } + + void on_hex() + { + if (type == 'A') + upper = true; + } + + void on_error() + { + FMT_THROW(format_error("invalid type specifier")); + } +}; + +template +template +void basic_writer::write_double(T value, const format_specs &spec) +{ + // Check type. + float_spec_handler handler(spec.type()); + internal::handle_float_type_spec(spec.type(), handler); + + char sign = 0; + // Use isnegative instead of value < 0 because the latter is always + // false for NaN. + if (internal::fputil::isnegative(static_cast(value))) + { + sign = '-'; + value = -value; + } + else if (spec.flag(SIGN_FLAG)) + { + sign = spec.flag(PLUS_FLAG) ? '+' : ' '; + } + + struct write_inf_or_nan_t + { + basic_writer &writer; + format_specs spec; + char sign; + void operator()(const char *str) const + { + writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec, inf_or_nan_writer{sign, str}); + } + } write_inf_or_nan = {*this, spec, sign}; + + // Format NaN and ininity ourselves because sprintf's output is not consistent + // across platforms. + if (internal::fputil::isnotanumber(value)) + return write_inf_or_nan(handler.upper ? "NAN" : "nan"); + if (internal::fputil::isinfinity(value)) + return write_inf_or_nan(handler.upper ? "INF" : "inf"); + + basic_memory_buffer buffer; + if (FMT_USE_GRISU && sizeof(T) <= sizeof(double) && std::numeric_limits::is_iec559) + { + internal::fp fp_value(static_cast(value)); + fp_value.normalize(); + // Find a cached power of 10 close to 1 / fp_value. + int dec_exp = 0; + const int min_exp = -60; + auto dec_pow = internal::get_cached_power(min_exp - (fp_value.e + internal::fp::significand_size), dec_exp); + internal::fp product = fp_value * dec_pow; + // Generate output. + internal::fp one(1ull << -product.e, product.e); + uint64_t hi = product.f >> -one.e; + uint64_t f = product.f & (one.f - 1); + typedef back_insert_range> range; + basic_writer w{range(buffer)}; + w.write(hi); + size_t digits = buffer.size(); + w.write('.'); + const unsigned max_digits = 18; + while (digits++ < max_digits) + { + f *= 10; + w.write(static_cast('0' + (f >> -one.e))); + f &= one.f - 1; + } + w.write('e'); + w.write(-dec_exp); + } + else + { + format_specs normalized_spec(spec); + normalized_spec.type_ = handler.type; + write_double_sprintf(value, normalized_spec, buffer); + } + size_t n = buffer.size(); + align_spec as = spec; + if (spec.align() == ALIGN_NUMERIC) + { + if (sign) + { + auto &&it = reserve(1); + *it++ = sign; + sign = 0; + if (as.width_) + --as.width_; + } + as.align_ = ALIGN_RIGHT; + } + else + { + if (spec.align() == ALIGN_DEFAULT) + as.align_ = ALIGN_RIGHT; + if (sign) + ++n; + } + write_padded(n, as, double_writer{n, sign, buffer}); +} + +template +template +void basic_writer::write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer &buffer) +{ + // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. + FMT_ASSERT(buffer.capacity() != 0, "empty buffer"); + + // Build format string. + enum + { + MAX_FORMAT_SIZE = 10 + }; // longest format: %#-*.*Lg + char_type format[MAX_FORMAT_SIZE]; + char_type *format_ptr = format; + *format_ptr++ = '%'; + if (spec.flag(HASH_FLAG)) + *format_ptr++ = '#'; + if (spec.precision() >= 0) + { + *format_ptr++ = '.'; + *format_ptr++ = '*'; + } + + append_float_length(format_ptr, value); + *format_ptr++ = spec.type(); + *format_ptr = '\0'; + + // Format using snprintf. + char_type *start = FMT_NULL; + for (;;) + { + std::size_t buffer_size = buffer.capacity(); + start = &buffer[0]; + int result = internal::char_traits::format_float(start, buffer_size, format, spec.precision(), value); + if (result >= 0) + { + unsigned n = internal::to_unsigned(result); + if (n < buffer.capacity()) + { + buffer.resize(n); + break; // The buffer is large enough - continue with formatting. + } + buffer.reserve(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); + } + } +} + +// 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, string_view message) FMT_NOEXCEPT; + +#if FMT_USE_WINDOWS_H + +/** A Windows error. */ +class windows_error : public system_error +{ +private: + FMT_API void init(int error_code, string_view format_str, format_args args); + +public: + /** + \rst + Constructs a :class:`fmt::windows_error` object with the description + of the form + + .. parsed-literal:: + **: ** + + where ** is the formatted message and ** 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 windows_error 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::windows_error(GetLastError(), + "cannot open file '{}'", filename); + } + \endrst + */ + template + windows_error(int error_code, string_view message, const Args &... args) + { + init(error_code, message, make_format_args(args...)); + } +}; + +// 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, string_view message) FMT_NOEXCEPT; + +#endif + +/** Fast integer formatter. */ +class format_int +{ +private: + // Buffer should be large enough to hold all digits (digits10 + 1), + // a sign and a null character. + enum + { + BUFFER_SIZE = std::numeric_limits::digits10 + 3 + }; + mutable char buffer_[BUFFER_SIZE]; + char *str_; + + // Formats value in reverse and returns a pointer to the beginning. + char *format_decimal(unsigned long long value) + { + char *ptr = 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((value % 100) * 2); + value /= 100; + *--ptr = internal::data::DIGITS[index + 1]; + *--ptr = internal::data::DIGITS[index]; + } + if (value < 10) + { + *--ptr = static_cast('0' + value); + return ptr; + } + unsigned index = static_cast(value * 2); + *--ptr = internal::data::DIGITS[index + 1]; + *--ptr = internal::data::DIGITS[index]; + return ptr; + } + + void format_signed(long long value) + { + unsigned long long abs_value = static_cast(value); + bool negative = value < 0; + if (negative) + abs_value = 0 - abs_value; + str_ = format_decimal(abs_value); + if (negative) + *--str_ = '-'; + } + +public: + explicit format_int(int value) + { + format_signed(value); + } + explicit format_int(long value) + { + format_signed(value); + } + explicit format_int(long long value) + { + format_signed(value); + } + explicit format_int(unsigned value) + : str_(format_decimal(value)) + { + } + explicit format_int(unsigned long value) + : str_(format_decimal(value)) + { + } + explicit format_int(unsigned long long 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 +inline void format_decimal(char *&buffer, T value) +{ + typedef typename internal::int_traits::main_type main_type; + main_type abs_value = static_cast(value); + if (internal::is_negative(value)) + { + *buffer++ = '-'; + abs_value = 0 - abs_value; + } + if (abs_value < 100) + { + if (abs_value < 10) + { + *buffer++ = static_cast('0' + abs_value); + return; + } + unsigned index = static_cast(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; +} + +// Formatter of objects of type T. +template +struct formatter::type, T>::value>::type> +{ + + // Parses format specifiers stopping either at the end of the range or at the + // terminating '}'. + template + FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) + { + auto it = internal::null_terminating_iterator(ctx); + typedef internal::dynamic_specs_handler handler_type; + auto type = internal::get_type::type, T>::value; + internal::specs_checker handler(handler_type(specs_, ctx), type); + it = parse_format_specs(it, handler); + auto type_spec = specs_.type(); + auto eh = ctx.error_handler(); + switch (type) + { + case internal::none_type: + case internal::named_arg_type: + FMT_ASSERT(false, "invalid argument type"); + break; + case internal::int_type: + case internal::uint_type: + case internal::long_long_type: + case internal::ulong_long_type: + case internal::bool_type: + handle_int_type_spec(type_spec, internal::int_type_checker(eh)); + break; + case internal::char_type: + handle_char_specs(specs_, internal::char_specs_checker(type_spec, eh)); + break; + case internal::double_type: + case internal::long_double_type: + handle_float_type_spec(type_spec, internal::float_type_checker(eh)); + break; + case internal::cstring_type: + internal::handle_cstring_type_spec(type_spec, internal::cstring_type_checker(eh)); + break; + case internal::string_type: + internal::check_string_type_spec(type_spec, eh); + break; + case internal::pointer_type: + internal::check_pointer_type_spec(type_spec, eh); + break; + case internal::custom_type: + // Custom format specifiers should be checked in parse functions of + // formatter specializations. + break; + } + return pointer_from(it); + } + + template + auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) + { + internal::handle_dynamic_spec(specs_.width_, specs_.width_ref, ctx); + internal::handle_dynamic_spec(specs_.precision_, specs_.precision_ref, ctx); + typedef output_range range_type; + return visit(arg_formatter(ctx, specs_), internal::make_arg(val)); + } + +private: + internal::dynamic_format_specs specs_; +}; + +template +struct formatter::value>::type> : public formatter +{ + template + auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return ctx.begin(); + } +}; + +// A formatter for types known only at run time such as variant alternatives. +// +// Usage: +// typedef std::variant variant; +// template <> +// struct formatter: dynamic_formatter<> { +// void format(buffer &buf, const variant &v, context &ctx) { +// visit([&](const auto &val) { format(buf, val, ctx); }, v); +// } +// }; +template +class dynamic_formatter +{ +private: + struct null_handler : internal::error_handler + { + void on_align(alignment) {} + void on_plus() {} + void on_minus() {} + void on_space() {} + void on_hash() {} + }; + +public: + template + auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + auto it = internal::null_terminating_iterator(ctx); + // Checks are deferred to formatting time when the argument type is known. + internal::dynamic_specs_handler handler(specs_, ctx); + it = parse_format_specs(it, handler); + return pointer_from(it); + } + + template + auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) + { + handle_specs(ctx); + internal::specs_checker checker(null_handler(), internal::get_type::value); + checker.on_align(specs_.align()); + if (specs_.flags_ == 0) + { + // Do nothing. + } + else if (specs_.flag(SIGN_FLAG)) + { + if (specs_.flag(PLUS_FLAG)) + checker.on_plus(); + else + checker.on_space(); + } + else if (specs_.flag(MINUS_FLAG)) + { + checker.on_minus(); + } + else if (specs_.flag(HASH_FLAG)) + { + checker.on_hash(); + } + if (specs_.precision_ != -1) + checker.end_precision(); + typedef output_range range; + visit(arg_formatter(ctx, specs_), internal::make_arg(val)); + return ctx.out(); + } + +private: + template + void handle_specs(Context &ctx) + { + internal::handle_dynamic_spec(specs_.width_, specs_.width_ref, ctx); + internal::handle_dynamic_spec(specs_.precision_, specs_.precision_ref, ctx); + } + + internal::dynamic_format_specs specs_; +}; + +template +typename basic_format_context::format_arg basic_format_context::get_arg(basic_string_view name) +{ + map_.init(this->args()); + format_arg arg = map_.find(name); + if (arg.type() == internal::none_type) + this->on_error("argument not found"); + return arg; +} + +template +struct format_handler : internal::error_handler +{ + typedef internal::null_terminating_iterator iterator; + typedef typename ArgFormatter::range range; + + format_handler(range r, basic_string_view str, basic_format_args format_args) + : context(r.begin(), str, format_args) + { + } + + void on_text(iterator begin, iterator end) + { + auto size = internal::to_unsigned(end - begin); + auto out = context.out(); + auto &&it = internal::reserve(out, size); + it = std::copy_n(begin, size, it); + context.advance_to(out); + } + + void on_arg_id() + { + arg = context.next_arg(); + } + void on_arg_id(unsigned id) + { + context.parse_context().check_arg_id(id); + arg = context.get_arg(id); + } + void on_arg_id(basic_string_view id) + { + arg = context.get_arg(id); + } + + void on_replacement_field(iterator it) + { + context.parse_context().advance_to(pointer_from(it)); + if (visit(internal::custom_formatter(context), arg)) + return; + basic_format_specs specs; + context.advance_to(visit(ArgFormatter(context, specs), arg)); + } + + iterator on_format_specs(iterator it) + { + auto &parse_ctx = context.parse_context(); + parse_ctx.advance_to(pointer_from(it)); + if (visit(internal::custom_formatter(context), arg)) + return iterator(parse_ctx); + basic_format_specs specs; + using internal::specs_handler; + internal::specs_checker> handler(specs_handler(specs, context), arg.type()); + it = parse_format_specs(it, handler); + if (*it != '}') + on_error("missing '}' in format string"); + parse_ctx.advance_to(pointer_from(it)); + context.advance_to(visit(ArgFormatter(context, specs), arg)); + return it; + } + + Context context; + basic_format_arg arg; +}; + +/** Formats arguments and writes the output to the range. */ +template +typename Context::iterator vformat_to(typename ArgFormatter::range out, basic_string_view format_str, basic_format_args args) +{ + typedef internal::null_terminating_iterator iterator; + format_handler h(out, format_str, args); + parse_format_string(iterator(format_str.begin(), format_str.end()), h); + return h.context.out(); +} + +// Casts ``p`` to ``const void*`` for pointer formatting. +// Example: +// auto s = format("{}", ptr(p)); +template +inline const void *ptr(const T *p) +{ + return p; +} + +template +struct arg_join +{ + It begin; + It end; + basic_string_view sep; + + arg_join(It begin, It end, basic_string_view sep) + : begin(begin) + , end(end) + , sep(sep) + { + } +}; + +template +struct formatter, Char> : formatter::value_type, Char> +{ + template + auto format(const arg_join &value, FormatContext &ctx) -> decltype(ctx.out()) + { + typedef formatter::value_type, Char> base; + auto it = value.begin; + auto out = ctx.out(); + if (it != value.end) + { + out = base::format(*it++, ctx); + while (it != value.end) + { + out = std::copy(value.sep.begin(), value.sep.end(), out); + ctx.advance_to(out); + out = base::format(*it++, ctx); + } + } + return out; + } +}; + +template +arg_join join(It begin, It end, string_view sep) +{ + return arg_join(begin, end, sep); +} + +template +arg_join join(It begin, It end, wstring_view sep) +{ + return arg_join(begin, end, sep); +} + +// The following causes ICE in gcc 4.4. +#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405) +template +auto join(const Range &range, string_view sep) -> arg_join +{ + return join(internal::begin(range), internal::end(range), sep); +} + +template +auto join(const Range &range, wstring_view sep) -> arg_join +{ + return join(internal::begin(range), internal::end(range), sep); +} +#endif + +/** + \rst + Converts *value* to ``std::string`` using the default format for type *T*. + + **Example**:: + + #include + + std::string answer = fmt::to_string(42); + \endrst + */ +template +std::string to_string(const T &value) +{ + std::string str; + internal::container_buffer buf(str); + writer(buf).write(value); + return str; +} + +/** + Converts *value* to ``std::wstring`` using the default format for type *T*. + */ +template +std::wstring to_wstring(const T &value) +{ + std::wstring str; + internal::container_buffer buf(str); + wwriter(buf).write(value); + return str; +} + +template +std::basic_string to_string(const basic_memory_buffer &buf) +{ + return std::basic_string(buf.data(), buf.size()); +} + +inline format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args) +{ + typedef back_insert_range range; + return vformat_to>(buf, format_str, args); +} + +inline wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args) +{ + typedef back_insert_range range; + return vformat_to>(buf, format_str, args); +} + +template +inline format_context::iterator format_to(basic_memory_buffer &buf, string_view format_str, const Args &... args) +{ + return vformat_to(buf, format_str, make_format_args(args...)); +} + +template +inline wformat_context::iterator format_to(basic_memory_buffer &buf, wstring_view format_str, const Args &... args) +{ + return vformat_to(buf, format_str, make_format_args(args...)); +} + +template +// using format_context_t = basic_format_context; +struct format_context_t +{ + typedef basic_format_context type; +}; + +template +// using format_args_t = basic_format_args>; +struct format_args_t +{ + typedef basic_format_args::type> type; +}; + +template +inline OutputIt vformat_to(OutputIt out, string_view format_str, typename format_args_t::type args) +{ + typedef output_range range; + return vformat_to>(range(out), format_str, args); +} +template +inline OutputIt vformat_to(OutputIt out, wstring_view format_str, typename format_args_t::type args) +{ + typedef output_range range; + return vformat_to>(range(out), format_str, args); +} + +/** + \rst + Formats arguments, writes the result to the output iterator ``out`` and returns + the iterator past the end of the output range. + + **Example**:: + + std::vector out; + fmt::format_to(std::back_inserter(out), "{}", 42); + \endrst + */ +template +inline OutputIt format_to(OutputIt out, string_view format_str, const Args &... args) +{ + return vformat_to(out, format_str, make_format_args::type>(args...)); +} + +template +inline typename std::enable_if::value, std::back_insert_iterator>::type format_to( + std::back_insert_iterator out, string_view format_str, const Args &... args) +{ + return vformat_to(out, format_str, make_format_args(args...)); +} + +template +inline typename std::enable_if::value, std::back_insert_iterator>::type format_to( + std::back_insert_iterator out, wstring_view format_str, const Args &... args) +{ + return vformat_to(out, format_str, make_format_args(args...)); +} + +template +struct format_to_n_result +{ + /** Iterator past the end of the output range. */ + OutputIt out; + /** Total (not truncated) output size. */ + std::size_t size; +}; + +template +using format_to_n_context = typename fmt::format_context_t>::type; + +template +using format_to_n_args = fmt::basic_format_args>; + +template +inline format_arg_store, Args...> make_format_to_n_args(const Args &... args) +{ + return format_arg_store, Args...>(args...); +} + +template +inline format_to_n_result vformat_to_n(OutputIt out, std::size_t n, string_view format_str, format_to_n_args args) +{ + typedef internal::truncating_iterator It; + auto it = vformat_to(It(out, n), format_str, args); + return {it.base(), it.count()}; +} + +/** + \rst + Formats arguments, writes up to ``n`` characters of the result to the output + iterator ``out`` and returns the total output size and the iterator past the + end + of the output range. + \endrst + */ +template +inline format_to_n_result format_to_n(OutputIt out, std::size_t n, string_view format_str, const Args &... args) +{ + return vformat_to_n(out, n, format_str, make_format_to_n_args(args...)); +} +template +inline format_to_n_result format_to_n(OutputIt out, std::size_t n, wstring_view format_str, const Args &... args) +{ + typedef internal::truncating_iterator It; + auto it = vformat_to(It(out, n), format_str, make_format_args::type>(args...)); + return {it.base(), it.count()}; +} + +inline std::string vformat(string_view format_str, format_args args) +{ + memory_buffer buffer; + vformat_to(buffer, format_str, args); + return fmt::to_string(buffer); +} + +inline std::wstring vformat(wstring_view format_str, wformat_args args) +{ + wmemory_buffer buffer; + vformat_to(buffer, format_str, args); + return to_string(buffer); +} + +template +inline typename std::enable_if::value, std::string>::type format(String format_str, const Args &... args) +{ + internal::check_format_string(format_str); + return vformat(format_str.data(), make_format_args(args...)); +} + +template +inline typename std::enable_if::value>::type print(String format_str, const Args &... args) +{ + internal::check_format_string(format_str); + return vprint(format_str.data(), make_format_args(args...)); +} + +/** + Returns the number of characters in the output of + ``format(format_str, args...)``. + */ +template +inline std::size_t formatted_size(string_view format_str, const Args &... args) +{ + auto it = format_to(internal::counting_iterator(), format_str, args...); + return it.count(); +} + +// Experimental color support. +#ifdef FMT_EXTENDED_COLORS +enum class color : uint32_t +{ + alice_blue = 0xF0F8FF, // rgb(240,248,255) + antique_white = 0xFAEBD7, // rgb(250,235,215) + aqua = 0x00FFFF, // rgb(0,255,255) + aquamarine = 0x7FFFD4, // rgb(127,255,212) + azure = 0xF0FFFF, // rgb(240,255,255) + beige = 0xF5F5DC, // rgb(245,245,220) + bisque = 0xFFE4C4, // rgb(255,228,196) + black = 0x000000, // rgb(0,0,0) + blanched_almond = 0xFFEBCD, // rgb(255,235,205) + blue = 0x0000FF, // rgb(0,0,255) + blue_violet = 0x8A2BE2, // rgb(138,43,226) + brown = 0xA52A2A, // rgb(165,42,42) + burly_wood = 0xDEB887, // rgb(222,184,135) + cadet_blue = 0x5F9EA0, // rgb(95,158,160) + chartreuse = 0x7FFF00, // rgb(127,255,0) + chocolate = 0xD2691E, // rgb(210,105,30) + coral = 0xFF7F50, // rgb(255,127,80) + cornflower_blue = 0x6495ED, // rgb(100,149,237) + cornsilk = 0xFFF8DC, // rgb(255,248,220) + crimson = 0xDC143C, // rgb(220,20,60) + cyan = 0x00FFFF, // rgb(0,255,255) + dark_blue = 0x00008B, // rgb(0,0,139) + dark_cyan = 0x008B8B, // rgb(0,139,139) + dark_golden_rod = 0xB8860B, // rgb(184,134,11) + dark_gray = 0xA9A9A9, // rgb(169,169,169) + dark_green = 0x006400, // rgb(0,100,0) + dark_khaki = 0xBDB76B, // rgb(189,183,107) + dark_magenta = 0x8B008B, // rgb(139,0,139) + dark_olive_green = 0x556B2F, // rgb(85,107,47) + dark_orange = 0xFF8C00, // rgb(255,140,0) + dark_orchid = 0x9932CC, // rgb(153,50,204) + dark_red = 0x8B0000, // rgb(139,0,0) + dark_salmon = 0xE9967A, // rgb(233,150,122) + dark_sea_green = 0x8FBC8F, // rgb(143,188,143) + dark_slate_blue = 0x483D8B, // rgb(72,61,139) + dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) + dark_turquoise = 0x00CED1, // rgb(0,206,209) + dark_violet = 0x9400D3, // rgb(148,0,211) + deep_pink = 0xFF1493, // rgb(255,20,147) + deep_sky_blue = 0x00BFFF, // rgb(0,191,255) + dim_gray = 0x696969, // rgb(105,105,105) + dodger_blue = 0x1E90FF, // rgb(30,144,255) + fire_brick = 0xB22222, // rgb(178,34,34) + floral_white = 0xFFFAF0, // rgb(255,250,240) + forest_green = 0x228B22, // rgb(34,139,34) + fuchsia = 0xFF00FF, // rgb(255,0,255) + gainsboro = 0xDCDCDC, // rgb(220,220,220) + ghost_white = 0xF8F8FF, // rgb(248,248,255) + gold = 0xFFD700, // rgb(255,215,0) + golden_rod = 0xDAA520, // rgb(218,165,32) + gray = 0x808080, // rgb(128,128,128) + green = 0x008000, // rgb(0,128,0) + green_yellow = 0xADFF2F, // rgb(173,255,47) + honey_dew = 0xF0FFF0, // rgb(240,255,240) + hot_pink = 0xFF69B4, // rgb(255,105,180) + indian_red = 0xCD5C5C, // rgb(205,92,92) + indigo = 0x4B0082, // rgb(75,0,130) + ivory = 0xFFFFF0, // rgb(255,255,240) + khaki = 0xF0E68C, // rgb(240,230,140) + lavender = 0xE6E6FA, // rgb(230,230,250) + lavender_blush = 0xFFF0F5, // rgb(255,240,245) + lawn_green = 0x7CFC00, // rgb(124,252,0) + lemon_chiffon = 0xFFFACD, // rgb(255,250,205) + light_blue = 0xADD8E6, // rgb(173,216,230) + light_coral = 0xF08080, // rgb(240,128,128) + light_cyan = 0xE0FFFF, // rgb(224,255,255) + light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) + light_gray = 0xD3D3D3, // rgb(211,211,211) + light_green = 0x90EE90, // rgb(144,238,144) + light_pink = 0xFFB6C1, // rgb(255,182,193) + light_salmon = 0xFFA07A, // rgb(255,160,122) + light_sea_green = 0x20B2AA, // rgb(32,178,170) + light_sky_blue = 0x87CEFA, // rgb(135,206,250) + light_slate_gray = 0x778899, // rgb(119,136,153) + light_steel_blue = 0xB0C4DE, // rgb(176,196,222) + light_yellow = 0xFFFFE0, // rgb(255,255,224) + lime = 0x00FF00, // rgb(0,255,0) + lime_green = 0x32CD32, // rgb(50,205,50) + linen = 0xFAF0E6, // rgb(250,240,230) + magenta = 0xFF00FF, // rgb(255,0,255) + maroon = 0x800000, // rgb(128,0,0) + medium_aquamarine = 0x66CDAA, // rgb(102,205,170) + medium_blue = 0x0000CD, // rgb(0,0,205) + medium_orchid = 0xBA55D3, // rgb(186,85,211) + medium_purple = 0x9370DB, // rgb(147,112,219) + medium_sea_green = 0x3CB371, // rgb(60,179,113) + medium_slate_blue = 0x7B68EE, // rgb(123,104,238) + medium_spring_green = 0x00FA9A, // rgb(0,250,154) + medium_turquoise = 0x48D1CC, // rgb(72,209,204) + medium_violet_red = 0xC71585, // rgb(199,21,133) + midnight_blue = 0x191970, // rgb(25,25,112) + mint_cream = 0xF5FFFA, // rgb(245,255,250) + misty_rose = 0xFFE4E1, // rgb(255,228,225) + moccasin = 0xFFE4B5, // rgb(255,228,181) + navajo_white = 0xFFDEAD, // rgb(255,222,173) + navy = 0x000080, // rgb(0,0,128) + old_lace = 0xFDF5E6, // rgb(253,245,230) + olive = 0x808000, // rgb(128,128,0) + olive_drab = 0x6B8E23, // rgb(107,142,35) + orange = 0xFFA500, // rgb(255,165,0) + orange_red = 0xFF4500, // rgb(255,69,0) + orchid = 0xDA70D6, // rgb(218,112,214) + pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) + pale_green = 0x98FB98, // rgb(152,251,152) + pale_turquoise = 0xAFEEEE, // rgb(175,238,238) + pale_violet_red = 0xDB7093, // rgb(219,112,147) + papaya_whip = 0xFFEFD5, // rgb(255,239,213) + peach_puff = 0xFFDAB9, // rgb(255,218,185) + peru = 0xCD853F, // rgb(205,133,63) + pink = 0xFFC0CB, // rgb(255,192,203) + plum = 0xDDA0DD, // rgb(221,160,221) + powder_blue = 0xB0E0E6, // rgb(176,224,230) + purple = 0x800080, // rgb(128,0,128) + rebecca_purple = 0x663399, // rgb(102,51,153) + red = 0xFF0000, // rgb(255,0,0) + rosy_brown = 0xBC8F8F, // rgb(188,143,143) + royal_blue = 0x4169E1, // rgb(65,105,225) + saddle_brown = 0x8B4513, // rgb(139,69,19) + salmon = 0xFA8072, // rgb(250,128,114) + sandy_brown = 0xF4A460, // rgb(244,164,96) + sea_green = 0x2E8B57, // rgb(46,139,87) + sea_shell = 0xFFF5EE, // rgb(255,245,238) + sienna = 0xA0522D, // rgb(160,82,45) + silver = 0xC0C0C0, // rgb(192,192,192) + sky_blue = 0x87CEEB, // rgb(135,206,235) + slate_blue = 0x6A5ACD, // rgb(106,90,205) + slate_gray = 0x708090, // rgb(112,128,144) + snow = 0xFFFAFA, // rgb(255,250,250) + spring_green = 0x00FF7F, // rgb(0,255,127) + steel_blue = 0x4682B4, // rgb(70,130,180) + tan = 0xD2B48C, // rgb(210,180,140) + teal = 0x008080, // rgb(0,128,128) + thistle = 0xD8BFD8, // rgb(216,191,216) + tomato = 0xFF6347, // rgb(255,99,71) + turquoise = 0x40E0D0, // rgb(64,224,208) + violet = 0xEE82EE, // rgb(238,130,238) + wheat = 0xF5DEB3, // rgb(245,222,179) + white = 0xFFFFFF, // rgb(255,255,255) + white_smoke = 0xF5F5F5, // rgb(245,245,245) + yellow = 0xFFFF00, // rgb(255,255,0) + yellow_green = 0x9ACD32, // rgb(154,205,50) +}; // enum class color + +// rgb is a struct for red, green and blue colors. +// We use rgb as name because some editors will show it as color direct in the +// editor. +struct rgb +{ + FMT_CONSTEXPR_DECL rgb() + : r(0) + , g(0) + , b(0) + { + } + FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_) + : r(r_) + , g(g_) + , b(b_) + { + } + FMT_CONSTEXPR_DECL rgb(uint32_t hex) + : r((hex >> 16) & 0xFF) + , g((hex >> 8) & 0xFF) + , b((hex)&0xFF) + { + } + FMT_CONSTEXPR_DECL rgb(color hex) + : r((uint32_t(hex) >> 16) & 0xFF) + , g((uint32_t(hex) >> 8) & 0xFF) + , b(uint32_t(hex) & 0xFF) + { + } + uint8_t r; + uint8_t g; + uint8_t b; +}; + +void vprint_rgb(rgb fd, string_view format, format_args args); +void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args); + +/** + Formats a string and prints it to stdout using ANSI escape sequences to + specify foreground color 'fd'. + Example: + fmt::print(fmt::color::red, "Elapsed time: {0:.2f} seconds", 1.23); + */ +template +inline void print(rgb fd, string_view format_str, const Args &... args) +{ + vprint_rgb(fd, format_str, make_format_args(args...)); +} + +/** + Formats a string and prints it to stdout using ANSI escape sequences to + specify foreground color 'fd' and background color 'bg'. + Example: + fmt::print(fmt::color::red, fmt::color::black, "Elapsed time: {0:.2f} + seconds", 1.23); + */ +template +inline void print(rgb fd, rgb bg, string_view format_str, const Args &... args) +{ + vprint_rgb(fd, bg, format_str, make_format_args(args...)); +} +#endif // FMT_EXTENDED_COLORS + +#if FMT_USE_USER_DEFINED_LITERALS +namespace internal { + +#if FMT_UDL_TEMPLATE +template +class udl_formatter +{ +public: + template + std::basic_string operator()(const Args &... args) const + { + FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'}; + FMT_CONSTEXPR_DECL bool invalid_format = + check_format_string(basic_string_view(s, sizeof...(CHARS))); + (void)invalid_format; + return format(s, args...); + } +}; +#else +template +struct udl_formatter +{ + const Char *str; + + template + auto operator()(Args &&... args) const -> decltype(format(str, std::forward(args)...)) + { + return format(str, std::forward(args)...); + } +}; +#endif // FMT_UDL_TEMPLATE + +template +struct udl_arg +{ + const Char *str; + + template + named_arg operator=(T &&value) const + { + return {str, std::forward(value)}; + } +}; + +} // namespace internal + +inline namespace literals { + +#if FMT_UDL_TEMPLATE +template +FMT_CONSTEXPR internal::udl_formatter operator""_format() +{ + return {}; +} +#else +/** + \rst + User-defined literal equivalent of :func:`fmt::format`. + + **Example**:: + + using namespace fmt::literals; + std::string message = "The answer is {}"_format(42); + \endrst + */ +inline internal::udl_formatter operator"" _format(const char *s, std::size_t) +{ + return {s}; +} +inline internal::udl_formatter operator"" _format(const wchar_t *s, std::size_t) +{ + return {s}; +} +#endif // FMT_UDL_TEMPLATE + +/** + \rst + User-defined literal equivalent of :func:`fmt::arg`. + + **Example**:: + + using namespace fmt::literals; + fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); + \endrst + */ +inline internal::udl_arg operator"" _a(const char *s, std::size_t) +{ + return {s}; +} +inline internal::udl_arg operator"" _a(const wchar_t *s, std::size_t) +{ + return {s}; +} +} // namespace literals +#endif // FMT_USE_USER_DEFINED_LITERALS +FMT_END_NAMESPACE + +#define FMT_STRING(s) \ + [] { \ + struct S : fmt::format_string \ + { \ + static FMT_CONSTEXPR decltype(s) data() \ + { \ + return s; \ + } \ + static FMT_CONSTEXPR size_t size() \ + { \ + return sizeof(s); \ + } \ + }; \ + return S{}; \ + }() + +#ifndef FMT_NO_FMT_STRING_ALIAS +/** + \rst + Constructs a compile-time format string. + + **Example**:: + + #include + // A compile-time error because 'd' is an invalid specifier for strings. + std::string s = format(fmt("{:d}"), "foo"); + \endrst + */ +#define fmt(s) FMT_STRING(s) +#endif + +#ifdef FMT_HEADER_ONLY +#define FMT_FUNC inline +#include "format-inl.h" +#else +#define FMT_FUNC +#endif + +// Restore warnings. +#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION +#pragma GCC diagnostic pop +#endif + +#endif // FMT_FORMAT_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/locale.h b/spdlog_lib/spdlog/fmt/bundled/locale.h new file mode 100644 index 0000000..0fa78c8 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/locale.h @@ -0,0 +1,27 @@ +// Formatting library for C++ - locale support +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "format.h" +#include + +namespace fmt { +class locale +{ +private: + std::locale locale_; + +public: + explicit locale(std::locale loc = std::locale()) + : locale_(loc) + { + } + std::locale get() + { + return locale_; + } +}; +} // namespace fmt diff --git a/spdlog_lib/spdlog/fmt/bundled/ostream.h b/spdlog_lib/spdlog/fmt/bundled/ostream.h new file mode 100644 index 0000000..439ded6 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/ostream.h @@ -0,0 +1,173 @@ +// 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_ + +#include "format.h" +#include + +FMT_BEGIN_NAMESPACE +namespace internal { + +template +class formatbuf : public std::basic_streambuf +{ +private: + typedef typename std::basic_streambuf::int_type int_type; + typedef typename std::basic_streambuf::traits_type traits_type; + + basic_buffer &buffer_; + +public: + formatbuf(basic_buffer &buffer) + : buffer_(buffer) + { + } + +protected: + // The put-area is actually always empty. This makes the implementation + // simpler and has the advantage that the streambuf and the buffer are always + // in sync and sputc never writes into uninitialized memory. The obvious + // disadvantage is that each call to sputc always results in a (virtual) call + // to overflow. There is no disadvantage here for sputn since this always + // results in a call to xsputn. + + int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE + { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast(ch)); + return ch; + } + + std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE + { + buffer_.append(s, s + count); + return count; + } +}; + +template +struct test_stream : std::basic_ostream +{ +private: + struct null; + // Hide all operator<< from std::basic_ostream. + void operator<<(null); +}; + +// Checks if T has a user-defined operator<< (e.g. not a member of +// std::ostream). +template +class is_streamable +{ +private: + template + static decltype(internal::declval &>() << internal::declval(), std::true_type()) test(int); + + template + static std::false_type test(...); + + typedef decltype(test(0)) result; + +public: + // std::string operator<< is not considered user-defined because we handle + // strings + // specially. + static const bool value = result::value && !std::is_same::value; +}; + +// Disable conversion to int if T has an overloaded operator<< which is a free +// function (not a member of std::ostream). +template +class convert_to_int +{ +public: + static const bool value = convert_to_int::value && !is_streamable::value; +}; + +// Write the content of buf to os. +template +void write(std::basic_ostream &os, basic_buffer &buf) +{ + const Char *data = buf.data(); + typedef std::make_unsigned::type UnsignedStreamSize; + UnsignedStreamSize size = buf.size(); + UnsignedStreamSize max_size = internal::to_unsigned((std::numeric_limits::max)()); + do + { + UnsignedStreamSize n = size <= max_size ? size : max_size; + os.write(data, static_cast(n)); + data += n; + size -= n; + } while (size != 0); +} + +template +void format_value(basic_buffer &buffer, const T &value) +{ + internal::formatbuf format_buf(buffer); + std::basic_ostream output(&format_buf); + output.exceptions(std::ios_base::failbit | std::ios_base::badbit); + output << value; + buffer.resize(buffer.size()); +} + +// Disable builtin formatting of enums and use operator<< instead. +template +struct format_enum::value>::type> : std::false_type +{ +}; +} // namespace internal + +// Formats an object of type T that has an overloaded ostream operator<<. +template +struct formatter::value>::type> : formatter, Char> +{ + + template + auto format(const T &value, Context &ctx) -> decltype(ctx.out()) + { + basic_memory_buffer buffer; + internal::format_value(buffer, value); + basic_string_view str(buffer.data(), buffer.size()); + formatter, Char>::format(str, ctx); + return ctx.out(); + } +}; + +template +inline void vprint( + std::basic_ostream &os, basic_string_view format_str, basic_format_args::type> args) +{ + basic_memory_buffer buffer; + vformat_to(buffer, format_str, args); + internal::write(os, buffer); +} +/** + \rst + Prints formatted data to the stream *os*. + + **Example**:: + + fmt::print(cerr, "Don't {}!", "panic"); + \endrst + */ +template +inline void print(std::ostream &os, string_view format_str, const Args &... args) +{ + vprint(os, format_str, make_format_args(args...)); +} + +template +inline void print(std::wostream &os, wstring_view format_str, const Args &... args) +{ + vprint(os, format_str, make_format_args(args...)); +} +FMT_END_NAMESPACE + +#endif // FMT_OSTREAM_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/posix.h b/spdlog_lib/spdlog/fmt/bundled/posix.h new file mode 100644 index 0000000..20c7589 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/posix.h @@ -0,0 +1,484 @@ +// A C++ interface to POSIX functions. +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_POSIX_H_ +#define FMT_POSIX_H_ + +#if defined(__MINGW32__) || defined(__CYGWIN__) +// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/. +#undef __STRICT_ANSI__ +#endif + +#include +#include // for O_RDONLY +#include // for locale_t +#include +#include // for strtod_l + +#include + +#if defined __APPLE__ || defined(__FreeBSD__) +#include // for LC_NUMERIC_MASK on OS X +#endif + +#include "format.h" + +#ifndef FMT_POSIX +#if defined(_WIN32) && !defined(__MINGW32__) +// Fix warnings about deprecated symbols. +#define FMT_POSIX(call) _##call +#else +#define FMT_POSIX(call) call +#endif +#endif + +// Calls to system functions are wrapped in FMT_SYSTEM for testability. +#ifdef FMT_SYSTEM +#define FMT_POSIX_CALL(call) FMT_SYSTEM(call) +#else +#define FMT_SYSTEM(call) call +#ifdef _WIN32 +// Fix warnings about deprecated symbols. +#define FMT_POSIX_CALL(call) ::_##call +#else +#define FMT_POSIX_CALL(call) ::call +#endif +#endif + +// Retries the expression while it evaluates to error_result and errno +// equals to EINTR. +#ifndef _WIN32 +#define FMT_RETRY_VAL(result, expression, error_result) \ + do \ + { \ + result = (expression); \ + } while (result == error_result && errno == EINTR) +#else +#define FMT_RETRY_VAL(result, expression, error_result) result = (expression) +#endif + +#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) + +FMT_BEGIN_NAMESPACE + +/** + \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 | + +===============+=============================+ + | cstring_view | basic_cstring_view | + +---------------+-----------------------------+ + | wcstring_view | basic_cstring_view | + +---------------+-----------------------------+ + + This class is most useful as a parameter type to allow passing + different types of strings to a function, for example:: + + template + std::string format(cstring_view format_str, const Args & ... args); + + format("{}", 42); + format(std::string("{}"), 42); + \endrst + */ +template +class basic_cstring_view +{ +private: + const Char *data_; + +public: + /** Constructs a string reference object from a C string. */ + basic_cstring_view(const Char *s) + : data_(s) + { + } + + /** + \rst + Constructs a string reference from an ``std::string`` object. + \endrst + */ + basic_cstring_view(const std::basic_string &s) + : data_(s.c_str()) + { + } + + /** Returns the pointer to a C string. */ + const Char *c_str() const + { + return data_; + } +}; + +typedef basic_cstring_view cstring_view; +typedef basic_cstring_view wcstring_view; + +// An error code. +class error_code +{ +private: + int value_; + +public: + explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {} + + int get() const FMT_NOEXCEPT + { + return value_; + } +}; + +// A buffered file. +class buffered_file +{ +private: + FILE *file_; + + friend class file; + + explicit buffered_file(FILE *f) + : file_(f) + { + } + +public: + // Constructs a buffered_file object which doesn't represent any file. + buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {} + + // Destroys the object closing the file it represents if any. + FMT_API ~buffered_file() FMT_DTOR_NOEXCEPT; + +#if !FMT_USE_RVALUE_REFERENCES + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. + +private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy + { + FILE *file; + }; + +public: + // A "move constructor" for moving from a temporary. + buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {} + + // A "move constructor" for moving from an lvalue. + buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_) + { + f.file_ = FMT_NULL; + } + + // A "move assignment operator" for moving from a temporary. + buffered_file &operator=(Proxy p) + { + close(); + file_ = p.file; + return *this; + } + + // A "move assignment operator" for moving from an lvalue. + buffered_file &operator=(buffered_file &other) + { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } + + // Returns a proxy object for moving from a temporary: + // buffered_file file = buffered_file(...); + operator Proxy() FMT_NOEXCEPT + { + Proxy p = {file_}; + file_ = FMT_NULL; + return p; + } + +#else +private: + FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file); + +public: + buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) + { + other.file_ = FMT_NULL; + } + + buffered_file &operator=(buffered_file &&other) + { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } +#endif + + // Opens a file. + FMT_API buffered_file(cstring_view filename, cstring_view mode); + + // Closes the file. + FMT_API void close(); + + // Returns the pointer to a FILE object representing this file. + FILE *get() const FMT_NOEXCEPT + { + return file_; + } + + // We place parentheses around fileno to workaround a bug in some versions + // of MinGW that define fileno as a macro. + FMT_API int(fileno)() const; + + void vprint(string_view format_str, format_args args) + { + fmt::vprint(file_, format_str, args); + } + + template + inline void print(string_view format_str, const Args &... args) + { + vprint(format_str, make_format_args(args...)); + } +}; + +// A file. Closed file is represented by a file object with descriptor -1. +// Methods that are not declared with FMT_NOEXCEPT may throw +// fmt::system_error in case of failure. Note that some errors such as +// closing the file multiple times will cause a crash on Windows rather +// than an exception. You can get standard behavior by overriding the +// invalid parameter handler with _set_invalid_parameter_handler. +class file +{ +private: + int fd_; // File descriptor. + + // Constructs a file object with a given descriptor. + explicit file(int fd) + : fd_(fd) + { + } + +public: + // Possible values for the oflag argument to the constructor. + enum + { + RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. + WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. + RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing. + }; + + // Constructs a file object which doesn't represent any file. + file() FMT_NOEXCEPT : fd_(-1) {} + + // Opens a file and constructs a file object representing this file. + FMT_API file(cstring_view path, int oflag); + +#if !FMT_USE_RVALUE_REFERENCES + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. + +private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy + { + int fd; + }; + +public: + // A "move constructor" for moving from a temporary. + file(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {} + + // A "move constructor" for moving from an lvalue. + file(file &other) FMT_NOEXCEPT : fd_(other.fd_) + { + other.fd_ = -1; + } + + // A "move assignment operator" for moving from a temporary. + file &operator=(Proxy p) + { + close(); + fd_ = p.fd; + return *this; + } + + // A "move assignment operator" for moving from an lvalue. + file &operator=(file &other) + { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } + + // Returns a proxy object for moving from a temporary: + // file f = file(...); + operator Proxy() FMT_NOEXCEPT + { + Proxy p = {fd_}; + fd_ = -1; + return p; + } + +#else +private: + FMT_DISALLOW_COPY_AND_ASSIGN(file); + +public: + file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) + { + other.fd_ = -1; + } + + file &operator=(file &&other) + { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } +#endif + + // Destroys the object closing the file it represents if any. + FMT_API ~file() FMT_DTOR_NOEXCEPT; + + // Returns the file descriptor. + int descriptor() const FMT_NOEXCEPT + { + return fd_; + } + + // Closes the file. + FMT_API void close(); + + // Returns the file size. The size has signed type for consistency with + // stat::st_size. + FMT_API long long size() const; + + // Attempts to read count bytes from the file into the specified buffer. + FMT_API std::size_t read(void *buffer, std::size_t count); + + // Attempts to write count bytes from the specified buffer to the file. + FMT_API std::size_t write(const void *buffer, std::size_t count); + + // Duplicates a file descriptor with the dup function and returns + // the duplicate as a file object. + FMT_API static file dup(int fd); + + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + FMT_API void dup2(int fd); + + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT; + + // Creates a pipe setting up read_end and write_end file objects for reading + // and writing respectively. + FMT_API static void pipe(file &read_end, file &write_end); + + // Creates a buffered_file object associated with this file and detaches + // this file object from the file. + FMT_API buffered_file fdopen(const char *mode); +}; + +// Returns the memory page size. +long getpagesize(); + +#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__) +#define FMT_LOCALE +#endif + +#ifdef FMT_LOCALE +// A "C" numeric locale. +class Locale +{ +private: +#ifdef _MSC_VER + typedef _locale_t locale_t; + + enum + { + LC_NUMERIC_MASK = LC_NUMERIC + }; + + static locale_t newlocale(int category_mask, const char *locale, locale_t) + { + return _create_locale(category_mask, locale); + } + + static void freelocale(locale_t locale) + { + _free_locale(locale); + } + + static double strtod_l(const char *nptr, char **endptr, _locale_t locale) + { + return _strtod_l(nptr, endptr, locale); + } +#endif + + locale_t locale_; + + FMT_DISALLOW_COPY_AND_ASSIGN(Locale); + +public: + typedef locale_t Type; + + Locale() + : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) + { + if (!locale_) + FMT_THROW(system_error(errno, "cannot create locale")); + } + ~Locale() + { + freelocale(locale_); + } + + Type get() const + { + return locale_; + } + + // Converts string to floating-point number and advances str past the end + // of the parsed input. + double strtod(const char *&str) const + { + char *end = FMT_NULL; + double result = strtod_l(str, &end, locale_); + str = end; + return result; + } +}; +#endif // FMT_LOCALE +FMT_END_NAMESPACE + +#if !FMT_USE_RVALUE_REFERENCES +namespace std { +// For compatibility with C++98. +inline fmt::buffered_file &move(fmt::buffered_file &f) +{ + return f; +} +inline fmt::file &move(fmt::file &f) +{ + return f; +} +} // namespace std +#endif + +#endif // FMT_POSIX_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/printf.h b/spdlog_lib/spdlog/fmt/bundled/printf.h new file mode 100644 index 0000000..1782c2e --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/printf.h @@ -0,0 +1,807 @@ +// 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 // std::fill_n +#include // std::numeric_limits + +#include "ostream.h" + +FMT_BEGIN_NAMESPACE +namespace internal { + +// Checks if a value fits in int - used to avoid warnings about comparing +// signed and unsigned integers. +template +struct int_checker +{ + template + static bool fits_in_int(T value) + { + unsigned max = std::numeric_limits::max(); + return value <= max; + } + static bool fits_in_int(bool) + { + return true; + } +}; + +template<> +struct int_checker +{ + template + static bool fits_in_int(T value) + { + return value >= std::numeric_limits::min() && value <= std::numeric_limits::max(); + } + static bool fits_in_int(int) + { + return true; + } +}; + +class printf_precision_handler : public function +{ +public: + template + typename std::enable_if::value, int>::type operator()(T value) + { + if (!int_checker::is_signed>::fits_in_int(value)) + FMT_THROW(format_error("number is too big")); + return static_cast(value); + } + + template + typename std::enable_if::value, int>::type operator()(T) + { + FMT_THROW(format_error("precision is not integer")); + return 0; + } +}; + +// An argument visitor that returns true iff arg is a zero integer. +class is_zero_int : public function +{ +public: + template + typename std::enable_if::value, bool>::type operator()(T value) + { + return value == 0; + } + + template + typename std::enable_if::value, bool>::type operator()(T) + { + return false; + } +}; + +template +struct make_unsigned_or_bool : std::make_unsigned +{ +}; + +template<> +struct make_unsigned_or_bool +{ + typedef bool type; +}; + +template +class arg_converter : public function +{ +private: + typedef typename Context::char_type Char; + + basic_format_arg &arg_; + typename Context::char_type type_; + +public: + arg_converter(basic_format_arg &arg, Char type) + : arg_(arg) + , type_(type) + { + } + + void operator()(bool value) + { + if (type_ != 's') + operator()(value); + } + + template + typename std::enable_if::value>::type operator()(U value) + { + bool is_signed = type_ == 'd' || type_ == 'i'; + typedef typename std::conditional::value, U, T>::type TargetType; + if (const_check(sizeof(TargetType) <= sizeof(int))) + { + // Extra casts are used to silence warnings. + if (is_signed) + { + arg_ = internal::make_arg(static_cast(static_cast(value))); + } + else + { + typedef typename make_unsigned_or_bool::type Unsigned; + arg_ = internal::make_arg(static_cast(static_cast(value))); + } + } + else + { + if (is_signed) + { + // glibc's printf doesn't sign extend arguments of smaller types: + // std::printf("%lld", -42); // prints "4294967254" + // but we don't have to do the same because it's a UB. + arg_ = internal::make_arg(static_cast(value)); + } + else + { + arg_ = internal::make_arg(static_cast::type>(value)); + } + } + } + + template + typename std::enable_if::value>::type operator()(U) + { + // No coversion needed for non-integral types. + } +}; + +// 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 +void convert_arg(basic_format_arg &arg, Char type) +{ + visit(arg_converter(arg, type), arg); +} + +// Converts an integer argument to char for printf. +template +class char_converter : public function +{ +private: + basic_format_arg &arg_; + + FMT_DISALLOW_COPY_AND_ASSIGN(char_converter); + +public: + explicit char_converter(basic_format_arg &arg) + : arg_(arg) + { + } + + template + typename std::enable_if::value>::type operator()(T value) + { + typedef typename Context::char_type Char; + arg_ = internal::make_arg(static_cast(value)); + } + + template + typename std::enable_if::value>::type operator()(T) + { + // No coversion needed for non-integral types. + } +}; + +// Checks if an argument is a valid printf width specifier and sets +// left alignment if it is negative. +template +class printf_width_handler : public function +{ +private: + typedef basic_format_specs format_specs; + + format_specs &spec_; + + FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler); + +public: + explicit printf_width_handler(format_specs &spec) + : spec_(spec) + { + } + + template + typename std::enable_if::value, unsigned>::type operator()(T value) + { + typedef typename internal::int_traits::main_type UnsignedType; + UnsignedType width = static_cast(value); + if (internal::is_negative(value)) + { + spec_.align_ = ALIGN_LEFT; + width = 0 - width; + } + unsigned int_max = std::numeric_limits::max(); + if (width > int_max) + FMT_THROW(format_error("number is too big")); + return static_cast(width); + } + + template + typename std::enable_if::value, unsigned>::type operator()(T) + { + FMT_THROW(format_error("width is not integer")); + return 0; + } +}; +} // namespace internal + +template +class printf_arg_formatter; + +template>>> +class basic_printf_context; + +/** + \rst + The ``printf`` argument formatter. + \endrst + */ +template +class printf_arg_formatter : public internal::function::iterator>, + public internal::arg_formatter_base +{ +private: + typedef typename Range::value_type char_type; + typedef decltype(internal::declval().begin()) iterator; + typedef internal::arg_formatter_base base; + typedef basic_printf_context context_type; + + context_type &context_; + + void write_null_pointer(char) + { + this->spec().type_ = 0; + this->write("(nil)"); + } + + void write_null_pointer(wchar_t) + { + this->spec().type_ = 0; + this->write(L"(nil)"); + } + +public: + typedef typename base::format_specs format_specs; + + /** + \rst + Constructs an argument formatter object. + *buffer* is a reference to the output buffer and *spec* contains format + specifier information for standard argument types. + \endrst + */ + printf_arg_formatter(internal::basic_buffer &buffer, format_specs &spec, context_type &ctx) + : base(back_insert_range>(buffer), spec) + , context_(ctx) + { + } + + template + typename std::enable_if::value, iterator>::type operator()(T value) + { + // MSVC2013 fails to compile separate overloads for bool and char_type so + // use std::is_same instead. + if (std::is_same::value) + { + format_specs &fmt_spec = this->spec(); + if (fmt_spec.type_ != 's') + return base::operator()(value ? 1 : 0); + fmt_spec.type_ = 0; + this->write(value != 0); + } + else if (std::is_same::value) + { + format_specs &fmt_spec = this->spec(); + if (fmt_spec.type_ && fmt_spec.type_ != 'c') + return (*this)(static_cast(value)); + fmt_spec.flags_ = 0; + fmt_spec.align_ = ALIGN_RIGHT; + return base::operator()(value); + } + else + { + return base::operator()(value); + } + return this->out(); + } + + template + typename std::enable_if::value, iterator>::type operator()(T value) + { + return base::operator()(value); + } + + /** Formats a null-terminated C string. */ + iterator operator()(const char *value) + { + if (value) + base::operator()(value); + else if (this->spec().type_ == 'p') + write_null_pointer(char_type()); + else + this->write("(null)"); + return this->out(); + } + + /** Formats a null-terminated wide C string. */ + iterator operator()(const wchar_t *value) + { + if (value) + base::operator()(value); + else if (this->spec().type_ == 'p') + write_null_pointer(char_type()); + else + this->write(L"(null)"); + return this->out(); + } + + iterator operator()(basic_string_view value) + { + return base::operator()(value); + } + + iterator operator()(monostate value) + { + return base::operator()(value); + } + + /** Formats a pointer. */ + iterator operator()(const void *value) + { + if (value) + return base::operator()(value); + this->spec().type_ = 0; + write_null_pointer(char_type()); + return this->out(); + } + + /** Formats an argument of a custom (user-defined) type. */ + iterator operator()(typename basic_format_arg::handle handle) + { + handle.format(context_); + return this->out(); + } +}; + +template +struct printf_formatter +{ + template + auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return ctx.begin(); + } + + template + auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) + { + internal::format_value(internal::get_container(ctx.out()), value); + return ctx.out(); + } +}; + +/** This template formats data and writes the output to a writer. */ +template +class basic_printf_context : private internal::context_base, Char> +{ +public: + /** The character type for the output. */ + typedef Char char_type; + + template + struct formatter_type + { + typedef printf_formatter type; + }; + +private: + typedef internal::context_base base; + typedef typename base::format_arg format_arg; + typedef basic_format_specs format_specs; + typedef internal::null_terminating_iterator iterator; + + void parse_flags(format_specs &spec, iterator &it); + + // Returns the argument with specified index or, if arg_index is equal + // to the maximum unsigned value, the next argument. + format_arg get_arg(iterator it, unsigned arg_index = (std::numeric_limits::max)()); + + // Parses argument index, flags and width and returns the argument index. + unsigned parse_header(iterator &it, format_specs &spec); + +public: + /** + \rst + Constructs a ``printf_context`` object. References to the arguments and + the writer are stored in the context object so make sure they have + appropriate lifetimes. + \endrst + */ + basic_printf_context(OutputIt out, basic_string_view format_str, basic_format_args args) + : base(out, format_str, args) + { + } + + using base::advance_to; + using base::out; + using base::parse_context; + + /** Formats stored arguments and writes the output to the range. */ + void format(); +}; + +template +void basic_printf_context::parse_flags(format_specs &spec, iterator &it) +{ + for (;;) + { + switch (*it++) + { + 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: + --it; + return; + } + } +} + +template +typename basic_printf_context::format_arg basic_printf_context::get_arg( + iterator it, unsigned arg_index) +{ + (void)it; + if (arg_index == std::numeric_limits::max()) + return this->do_get_arg(this->parse_context().next_arg_id()); + return base::get_arg(arg_index - 1); +} + +template +unsigned basic_printf_context::parse_header(iterator &it, format_specs &spec) +{ + unsigned arg_index = std::numeric_limits::max(); + char_type c = *it; + if (c >= '0' && c <= '9') + { + // Parse an argument index (if followed by '$') or a width possibly + // preceded with '0' flag(s). + internal::error_handler eh; + unsigned value = parse_nonnegative_int(it, eh); + if (*it == '$') + { // value is an argument index + ++it; + 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, it); + // Parse width. + if (*it >= '0' && *it <= '9') + { + internal::error_handler eh; + spec.width_ = parse_nonnegative_int(it, eh); + } + else if (*it == '*') + { + ++it; + spec.width_ = visit(internal::printf_width_handler(spec), get_arg(it)); + } + return arg_index; +} + +template +void basic_printf_context::format() +{ + auto &buffer = internal::get_container(this->out()); + auto start = iterator(this->parse_context()); + auto it = start; + using internal::pointer_from; + while (*it) + { + char_type c = *it++; + if (c != '%') + continue; + if (*it == c) + { + buffer.append(pointer_from(start), pointer_from(it)); + start = ++it; + continue; + } + buffer.append(pointer_from(start), pointer_from(it) - 1); + + format_specs spec; + spec.align_ = ALIGN_RIGHT; + + // Parse argument index, flags and width. + unsigned arg_index = parse_header(it, spec); + + // Parse precision. + if (*it == '.') + { + ++it; + if ('0' <= *it && *it <= '9') + { + internal::error_handler eh; + spec.precision_ = static_cast(parse_nonnegative_int(it, eh)); + } + else if (*it == '*') + { + ++it; + spec.precision_ = visit(internal::printf_precision_handler(), get_arg(it)); + } + else + { + spec.precision_ = 0; + } + } + + format_arg arg = get_arg(it, arg_index); + if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg)) + spec.flags_ &= ~internal::to_unsigned(HASH_FLAG); + if (spec.fill_ == '0') + { + if (arg.is_arithmetic()) + 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::convert_arg; + switch (*it++) + { + case 'h': + if (*it == 'h') + convert_arg(arg, *++it); + else + convert_arg(arg, *it); + break; + case 'l': + if (*it == 'l') + convert_arg(arg, *++it); + else + convert_arg(arg, *it); + break; + case 'j': + convert_arg(arg, *it); + break; + case 'z': + convert_arg(arg, *it); + break; + case 't': + convert_arg(arg, *it); + break; + case 'L': + // printf produces garbage when 'L' is omitted for long double, no + // need to do the same. + break; + default: + --it; + convert_arg(arg, *it); + } + + // Parse type. + if (!*it) + FMT_THROW(format_error("invalid format string")); + spec.type_ = static_cast(*it++); + if (arg.is_integral()) + { + // Normalize type. + switch (spec.type_) + { + case 'i': + case 'u': + spec.type_ = 'd'; + break; + case 'c': + // TODO: handle wchar_t better? + visit(internal::char_converter(arg), arg); + break; + } + } + + start = it; + + // Format argument. + visit(AF(buffer, spec, *this), arg); + } + buffer.append(pointer_from(start), pointer_from(it)); +} + +template +void printf(internal::basic_buffer &buf, basic_string_view format, basic_format_args args) +{ + Context(std::back_inserter(buf), format, args).format(); +} + +template +struct printf_context +{ + typedef basic_printf_context, typename Buffer::value_type> type; +}; + +template +inline format_arg_store::type, Args...> make_printf_args(const Args &... args) +{ + return format_arg_store::type, Args...>(args...); +} +typedef basic_format_args::type> printf_args; +typedef basic_format_args::type> wprintf_args; + +inline std::string vsprintf(string_view format, printf_args args) +{ + memory_buffer buffer; + printf(buffer, format, args); + return to_string(buffer); +} + +/** + \rst + Formats arguments and returns the result as a string. + + **Example**:: + + std::string message = fmt::sprintf("The answer is %d", 42); + \endrst +*/ +template +inline std::string sprintf(string_view format_str, const Args &... args) +{ + return vsprintf(format_str, make_format_args::type>(args...)); +} + +inline std::wstring vsprintf(wstring_view format, wprintf_args args) +{ + wmemory_buffer buffer; + printf(buffer, format, args); + return to_string(buffer); +} + +template +inline std::wstring sprintf(wstring_view format_str, const Args &... args) +{ + return vsprintf(format_str, make_format_args::type>(args...)); +} + +template +inline int vfprintf( + std::FILE *f, basic_string_view format, basic_format_args>::type> args) +{ + basic_memory_buffer buffer; + printf(buffer, format, args); + std::size_t size = buffer.size(); + return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast(size); +} + +/** + \rst + Prints formatted data to the file *f*. + + **Example**:: + + fmt::fprintf(stderr, "Don't %s!", "panic"); + \endrst + */ +template +inline int fprintf(std::FILE *f, string_view format_str, const Args &... args) +{ + auto vargs = make_format_args::type>(args...); + return vfprintf(f, format_str, vargs); +} + +template +inline int fprintf(std::FILE *f, wstring_view format_str, const Args &... args) +{ + return vfprintf(f, format_str, make_format_args::type>(args...)); +} + +inline int vprintf(string_view format, printf_args args) +{ + return vfprintf(stdout, format, args); +} + +inline int vprintf(wstring_view format, wprintf_args args) +{ + return vfprintf(stdout, format, args); +} + +/** + \rst + Prints formatted data to ``stdout``. + + **Example**:: + + fmt::printf("Elapsed time: %.2f seconds", 1.23); + \endrst + */ +template +inline int printf(string_view format_str, const Args &... args) +{ + return vprintf(format_str, make_format_args::type>(args...)); +} + +template +inline int printf(wstring_view format_str, const Args &... args) +{ + return vprintf(format_str, make_format_args::type>(args...)); +} + +inline int vfprintf(std::ostream &os, string_view format_str, printf_args args) +{ + memory_buffer buffer; + printf(buffer, format_str, args); + internal::write(os, buffer); + return static_cast(buffer.size()); +} + +inline int vfprintf(std::wostream &os, wstring_view format_str, wprintf_args args) +{ + wmemory_buffer buffer; + printf(buffer, format_str, args); + internal::write(os, buffer); + return static_cast(buffer.size()); +} + +/** + \rst + Prints formatted data to the stream *os*. + + **Example**:: + + fmt::fprintf(cerr, "Don't %s!", "panic"); + \endrst + */ +template +inline int fprintf(std::ostream &os, string_view format_str, const Args &... args) +{ + auto vargs = make_format_args::type>(args...); + return vfprintf(os, format_str, vargs); +} + +template +inline int fprintf(std::wostream &os, wstring_view format_str, const Args &... args) +{ + auto vargs = make_format_args::type>(args...); + return vfprintf(os, format_str, vargs); +} +FMT_END_NAMESPACE + +#endif // FMT_PRINTF_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/ranges.h b/spdlog_lib/spdlog/fmt/bundled/ranges.h new file mode 100644 index 0000000..ba2a979 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/ranges.h @@ -0,0 +1,344 @@ +// Formatting library for C++ - the core API +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. +// +// Copyright (c) 2018 - present, Remotion (Igor Schulz) +// All Rights Reserved +// {fmt} support for ranges, containers and types tuple interface. + +#ifndef FMT_RANGES_H_ +#define FMT_RANGES_H_ + +#include "format.h" +#include + +// output only up to N items from the range. +#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT +#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256 +#endif + +FMT_BEGIN_NAMESPACE + +template +struct formatting_base +{ + template + FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return ctx.begin(); + } +}; + +template +struct formatting_range : formatting_base +{ + static FMT_CONSTEXPR_DECL const std::size_t range_length_limit = FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the + // range. + Char prefix; + Char delimiter; + Char postfix; + formatting_range() + : prefix('{') + , delimiter(',') + , postfix('}') + { + } + static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true; + static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false; +}; + +template +struct formatting_tuple : formatting_base +{ + Char prefix; + Char delimiter; + Char postfix; + formatting_tuple() + : prefix('(') + , delimiter(',') + , postfix(')') + { + } + static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true; + static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false; +}; + +namespace internal { + +template +void copy(const RangeT &range, OutputIterator out) +{ + for (auto it = range.begin(), end = range.end(); it != end; ++it) + *out++ = *it; +} + +template +void copy(const char *str, OutputIterator out) +{ + const char *p_curr = str; + while (*p_curr) + { + *out++ = *p_curr++; + } +} + +template +void copy(char ch, OutputIterator out) +{ + *out++ = ch; +} + +/// Return true value if T has std::string interface, like std::string_view. +template +class is_like_std_string +{ + template + static auto check(U *p) -> decltype(p->find('a'), p->length(), p->data(), int()); + template + static void check(...); + +public: + static FMT_CONSTEXPR_DECL const bool value = !std::is_void(FMT_NULL))>::value; +}; + +template +struct conditional_helper +{ +}; + +template +struct is_range_ : std::false_type +{ +}; + +#if !FMT_MSC_VER || FMT_MSC_VER > 1800 +template +struct is_range_().begin()), decltype(internal::declval().end())>, void>::type> + : std::true_type +{ +}; +#endif + +/// tuple_size and tuple_element check. +template +class is_tuple_like_ +{ + template + static auto check(U *p) -> decltype(std::tuple_size::value, internal::declval::type>(), int()); + template + static void check(...); + +public: + static FMT_CONSTEXPR_DECL const bool value = !std::is_void(FMT_NULL))>::value; +}; + +// Check for integer_sequence +#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900 +template +using integer_sequence = std::integer_sequence; +template +using index_sequence = std::index_sequence; +template +using make_index_sequence = std::make_index_sequence; +#else +template +struct integer_sequence +{ + typedef T value_type; + + static FMT_CONSTEXPR std::size_t size() + { + return sizeof...(N); + } +}; + +template +using index_sequence = integer_sequence; + +template +struct make_integer_sequence : make_integer_sequence +{ +}; +template +struct make_integer_sequence : integer_sequence +{ +}; + +template +using make_index_sequence = make_integer_sequence; +#endif + +template +void for_each(index_sequence, Tuple &&tup, F &&f) FMT_NOEXCEPT +{ + using std::get; + // using free function get(T) now. + const int _[] = {0, ((void)f(get(tup)), 0)...}; + (void)_; // blocks warnings +} + +template +FMT_CONSTEXPR make_index_sequence::value> get_indexes(T const &) +{ + return {}; +} + +template +void for_each(Tuple &&tup, F &&f) +{ + const auto indexes = get_indexes(tup); + for_each(indexes, std::forward(tup), std::forward(f)); +} + +template +FMT_CONSTEXPR const char *format_str_quoted( + bool add_space, const Arg &, typename std::enable_if::type>::value>::type * = nullptr) +{ + return add_space ? " {}" : "{}"; +} + +template +FMT_CONSTEXPR const char *format_str_quoted( + bool add_space, const Arg &, typename std::enable_if::type>::value>::type * = nullptr) +{ + return add_space ? " \"{}\"" : "\"{}\""; +} + +FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *) +{ + return add_space ? " \"{}\"" : "\"{}\""; +} +FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *) +{ + return add_space ? L" \"{}\"" : L"\"{}\""; +} + +FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char) +{ + return add_space ? " '{}'" : "'{}'"; +} +FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t) +{ + return add_space ? L" '{}'" : L"'{}'"; +} + +} // namespace internal + +template +struct is_tuple_like +{ + static FMT_CONSTEXPR_DECL const bool value = internal::is_tuple_like_::value && !internal::is_range_::value; +}; + +template +struct formatter::value>::type> +{ +private: + // C++11 generic lambda for format() + template + struct format_each + { + template + void operator()(const T &v) + { + if (i > 0) + { + if (formatting.add_prepostfix_space) + { + *out++ = ' '; + } + internal::copy(formatting.delimiter, out); + } + format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v); + ++i; + } + + formatting_tuple &formatting; + std::size_t &i; + typename std::add_lvalue_reference().out())>::type out; + }; + +public: + formatting_tuple formatting; + + template + FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return formatting.parse(ctx); + } + + template + auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) + { + auto out = ctx.out(); + std::size_t i = 0; + internal::copy(formatting.prefix, out); + + internal::for_each(values, format_each{formatting, i, out}); + if (formatting.add_prepostfix_space) + { + *out++ = ' '; + } + internal::copy(formatting.postfix, out); + + return ctx.out(); + } +}; + +template +struct is_range +{ + static FMT_CONSTEXPR_DECL const bool value = internal::is_range_::value && !internal::is_like_std_string::value; +}; + +template +struct formatter::value>::type> +{ + + formatting_range formatting; + + template + FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return formatting.parse(ctx); + } + + template + typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx) + { + auto out = ctx.out(); + internal::copy(formatting.prefix, out); + std::size_t i = 0; + for (auto it = values.begin(), end = values.end(); it != end; ++it) + { + if (i > 0) + { + if (formatting.add_prepostfix_space) + { + *out++ = ' '; + } + internal::copy(formatting.delimiter, out); + } + format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it); + if (++i > formatting.range_length_limit) + { + format_to(out, " ... "); + break; + } + } + if (formatting.add_prepostfix_space) + { + *out++ = ' '; + } + internal::copy(formatting.postfix, out); + return ctx.out(); + } +}; + +FMT_END_NAMESPACE + +#endif // FMT_RANGES_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/time.h b/spdlog_lib/spdlog/fmt/bundled/time.h new file mode 100644 index 0000000..3e1443b --- /dev/null +++ b/spdlog_lib/spdlog/fmt/bundled/time.h @@ -0,0 +1,199 @@ +// Formatting library for C++ - time formatting +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_TIME_H_ +#define FMT_TIME_H_ + +#include "format.h" +#include + +FMT_BEGIN_NAMESPACE + +namespace internal { +inline null<> localtime_r(...) +{ + return null<>(); +} +inline null<> localtime_s(...) +{ + return null<>(); +} +inline null<> gmtime_r(...) +{ + return null<>(); +} +inline null<> gmtime_s(...) +{ + return null<>(); +} +} // namespace internal + +// Thread-safe replacement for std::localtime +inline std::tm localtime(std::time_t time) +{ + struct dispatcher + { + std::time_t time_; + std::tm tm_; + + dispatcher(std::time_t t) + : time_(t) + { + } + + bool run() + { + using namespace fmt::internal; + return handle(localtime_r(&time_, &tm_)); + } + + bool handle(std::tm *tm) + { + return tm != FMT_NULL; + } + + bool handle(internal::null<>) + { + using namespace fmt::internal; + return fallback(localtime_s(&tm_, &time_)); + } + + bool fallback(int res) + { + return res == 0; + } + + bool fallback(internal::null<>) + { + using namespace fmt::internal; + std::tm *tm = std::localtime(&time_); + if (tm) + tm_ = *tm; + return tm != FMT_NULL; + } + }; + dispatcher lt(time); + if (lt.run()) + return lt.tm_; + // Too big time values may be unsupported. + FMT_THROW(format_error("time_t value out of range")); +} + +// Thread-safe replacement for std::gmtime +inline std::tm gmtime(std::time_t time) +{ + struct dispatcher + { + std::time_t time_; + std::tm tm_; + + dispatcher(std::time_t t) + : time_(t) + { + } + + bool run() + { + using namespace fmt::internal; + return handle(gmtime_r(&time_, &tm_)); + } + + bool handle(std::tm *tm) + { + return tm != FMT_NULL; + } + + bool handle(internal::null<>) + { + using namespace fmt::internal; + return fallback(gmtime_s(&tm_, &time_)); + } + + bool fallback(int res) + { + return res == 0; + } + + bool fallback(internal::null<>) + { + std::tm *tm = std::gmtime(&time_); + if (tm) + tm_ = *tm; + return tm != FMT_NULL; + } + }; + dispatcher gt(time); + if (gt.run()) + return gt.tm_; + // Too big time values may be unsupported. + FMT_THROW(format_error("time_t value out of range")); +} + +namespace internal { +inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time) +{ + return std::strftime(str, count, format, time); +} + +inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format, const std::tm *time) +{ + return std::wcsftime(str, count, format, time); +} +} // namespace internal + +template +struct formatter +{ + template + auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + auto it = internal::null_terminating_iterator(ctx); + if (*it == ':') + ++it; + auto end = it; + while (*end && *end != '}') + ++end; + tm_format.reserve(end - it + 1); + using internal::pointer_from; + tm_format.append(pointer_from(it), pointer_from(end)); + tm_format.push_back('\0'); + return pointer_from(end); + } + + template + auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) + { + internal::basic_buffer &buf = internal::get_container(ctx.out()); + std::size_t start = buf.size(); + for (;;) + { + std::size_t size = buf.capacity() - start; + std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm); + if (count != 0) + { + buf.resize(start + count); + break; + } + if (size >= tm_format.size() * 256) + { + // If the buffer is 256 times larger than the format string, assume + // that `strftime` gives an empty result. There doesn't seem to be a + // better way to distinguish the two cases: + // https://github.com/fmtlib/fmt/issues/367 + break; + } + const std::size_t MIN_GROWTH = 10; + buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH)); + } + return ctx.out(); + } + + basic_memory_buffer tm_format; +}; +FMT_END_NAMESPACE + +#endif // FMT_TIME_H_ diff --git a/spdlog_lib/spdlog/fmt/fmt.h b/spdlog_lib/spdlog/fmt/fmt.h new file mode 100644 index 0000000..616af0c --- /dev/null +++ b/spdlog_lib/spdlog/fmt/fmt.h @@ -0,0 +1,25 @@ +// +// Copyright(c) 2016-2018 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 "bundled/core.h" +#include "bundled/format.h" +#else // external fmtlib +#include +#include +#endif diff --git a/spdlog_lib/spdlog/fmt/ostr.h b/spdlog_lib/spdlog/fmt/ostr.h new file mode 100644 index 0000000..9902898 --- /dev/null +++ b/spdlog_lib/spdlog/fmt/ostr.h @@ -0,0 +1,18 @@ +// +// Copyright(c) 2016 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once +// +// include bundled or external copy of fmtlib's ostream support +// +#if !defined(SPDLOG_FMT_EXTERNAL) +#ifndef FMT_HEADER_ONLY +#define FMT_HEADER_ONLY +#endif +#include "bundled/ostream.h" +#include "fmt.h" +#else +#include +#endif diff --git a/spdlog_lib/spdlog/formatter.h b/spdlog_lib/spdlog/formatter.h new file mode 100644 index 0000000..a7ef6b8 --- /dev/null +++ b/spdlog_lib/spdlog/formatter.h @@ -0,0 +1,20 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "fmt/fmt.h" +#include "spdlog/details/log_msg.h" + +namespace spdlog { + +class formatter +{ +public: + virtual ~formatter() = default; + virtual void format(const details::log_msg &msg, fmt::memory_buffer &dest) = 0; + virtual std::unique_ptr clone() const = 0; +}; +} // namespace spdlog diff --git a/spdlog_lib/spdlog/logger.h b/spdlog_lib/spdlog/logger.h new file mode 100644 index 0000000..91eec4b --- /dev/null +++ b/spdlog_lib/spdlog/logger.h @@ -0,0 +1,162 @@ +// +// Copyright(c) 2015-2108 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +// Thread safe logger (except for set_pattern(..), set_formatter(..) and +// set_error_handler()) +// 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 and if yes: +// 2. Call the underlying sinks to do the job. +// 3. Each sink use its own private copy of a formatter to format the message +// and send to its destination. +// +// The use of private formatter per sink provides the opportunity to cache some +// formatted data, +// and support customize format per each sink. + +#include "spdlog/common.h" +#include "spdlog/formatter.h" +#include "spdlog/sinks/sink.h" + +#include +#include +#include + +namespace spdlog { + +class logger +{ +public: + logger(std::string name, sink_ptr single_sink); + logger(std::string name, sinks_init_list sinks); + + template + logger(std::string name, const It &begin, const It &end); + + virtual ~logger(); + + logger(const logger &) = delete; + logger &operator=(const logger &) = delete; + + template + void log(level::level_enum lvl, const char *fmt, const Args &... args); + + template + void log(level::level_enum lvl, const char *msg); + + template + void trace(const char *fmt, const Args &... args); + + template + void debug(const char *fmt, const Args &... args); + + template + void info(const char *fmt, const Args &... args); + + template + void warn(const char *fmt, const Args &... args); + + template + void error(const char *fmt, const Args &... args); + + template + void critical(const char *fmt, const Args &... args); + +#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT + template + void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args); + + template + void trace(const wchar_t *fmt, const Args &... args); + + template + void debug(const wchar_t *fmt, const Args &... args); + + template + void info(const wchar_t *fmt, const Args &... args); + + template + void warn(const wchar_t *fmt, const Args &... args); + + template + void error(const wchar_t *fmt, const Args &... args); + + template + void critical(const wchar_t *fmt, const Args &... args); +#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT + + template + void log(level::level_enum lvl, const T &); + + template + void trace(const T &msg); + + template + void debug(const T &msg); + + template + void info(const T &msg); + + template + void warn(const T &msg); + + template + void error(const T &msg); + + template + void critical(const T &msg); + + bool should_log(level::level_enum msg_level) const; + void set_level(level::level_enum log_level); + level::level_enum level() const; + const std::string &name() const; + + // set formatting for the sinks in this logger. + // each sink will get a seperate instance of the formatter object. + void set_formatter(std::unique_ptr formatter); + void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); + + void flush(); + void flush_on(level::level_enum log_level); + + const std::vector &sinks() const; + + std::vector &sinks(); + + void set_error_handler(log_err_handler err_handler); + log_err_handler error_handler(); + +protected: + virtual void sink_it_(details::log_msg &msg); + virtual void flush_(); + + bool should_flush_(const details::log_msg &msg); + + // default error handler: print the error to stderr with the max rate of 1 + // message/minute + void default_err_handler_(const std::string &msg); + + // increment the message count (only if + // defined(SPDLOG_ENABLE_MESSAGE_COUNTER)) + void incr_msg_counter_(details::log_msg &msg); + + const std::string name_; + std::vector sinks_; + spdlog::level_t level_; + spdlog::level_t flush_level_; + log_err_handler err_handler_; + std::atomic last_err_time_; + std::atomic msg_counter_; + +#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT + std::wstring_convert> wstring_converter_; + std::mutex wstring_converter_mutex_; +#endif +}; +} // namespace spdlog + +#include "details/logger_impl.h" diff --git a/spdlog_lib/spdlog/sinks/android_sink.h b/spdlog_lib/spdlog/sinks/android_sink.h new file mode 100644 index 0000000..be70db0 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/android_sink.h @@ -0,0 +1,117 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "spdlog/details/fmt_helper.h" +#include "spdlog/details/null_mutex.h" +#include "spdlog/details/os.h" +#include "spdlog/sinks/base_sink.h" + +#include +#include +#include +#include +#include + +#if !defined(SPDLOG_ANDROID_RETRIES) +#define SPDLOG_ANDROID_RETRIES 2 +#endif + +namespace spdlog { +namespace sinks { + +/* + * Android sink (logging using __android_log_write) + */ +template +class android_sink SPDLOG_FINAL : public base_sink +{ +public: + explicit android_sink(const std::string &tag = "spdlog", bool use_raw_msg = false) + : tag_(tag) + , use_raw_msg_(use_raw_msg) + { + } + +protected: + void sink_it_(const details::log_msg &msg) override + { + const android_LogPriority priority = convert_to_android_(msg.level); + fmt::memory_buffer formatted; + if (use_raw_msg_) + { + fmt_helper::append_buf(msg.raw, formatted); + } + else + { + formatter_->format(msg, formatted); + } + formatted.push_back('\0'); + const char *msg_output = formatted.data(); + + // See system/core/liblog/logger_write.c for explanation of return value + int ret = __android_log_write(priority, tag_.c_str(), msg_output); + int retry_count = 0; + while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) + { + details::os::sleep_for_millis(5); + ret = __android_log_write(priority, tag_.c_str(), msg_output); + retry_count++; + } + + 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_; + bool use_raw_msg_; +}; + +using android_sink_mt = android_sink; +using android_sink_st = android_sink; +} // namespace sinks + +// Create and register android syslog logger + +template +inline std::shared_ptr android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog") +{ + return Factory::template create(logger_name, tag); +} + +template +inline std::shared_ptr android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog") +{ + return Factory::template create(logger_name, tag); +} + +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/ansicolor_sink.h b/spdlog_lib/spdlog/sinks/ansicolor_sink.h new file mode 100644 index 0000000..3b79976 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/ansicolor_sink.h @@ -0,0 +1,156 @@ +// +// Copyright(c) 2017 spdlog authors. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "spdlog/details/console_globals.h" +#include "spdlog/details/null_mutex.h" +#include "spdlog/details/os.h" + +#include +#include +#include +#include + +namespace spdlog { +namespace sinks { + +/** + * This sink prefixes the output with an ANSI escape sequence color code + * depending on the severity + * of the message. + * If no color terminal detected, omit the escape codes. + */ +template +class ansicolor_sink : public sink +{ +public: + using mutex_t = typename ConsoleMutex::mutex_t; + ansicolor_sink() + : target_file_(TargetStream::stream()) + , mutex_(ConsoleMutex::mutex()) + + { + should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal(); + colors_[level::trace] = white; + colors_[level::debug] = cyan; + colors_[level::info] = green; + colors_[level::warn] = yellow + bold; + colors_[level::err] = red + bold; + colors_[level::critical] = bold + on_red; + colors_[level::off] = reset; + } + + ~ansicolor_sink() override = default; + + ansicolor_sink(const ansicolor_sink &other) = delete; + ansicolor_sink &operator=(const ansicolor_sink &other) = delete; + + void set_color(level::level_enum color_level, const std::string &color) + { + std::lock_guard lock(mutex_); + colors_[color_level] = color; + } + + /// Formatting codes + const std::string reset = "\033[m"; + 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"; + const std::string clear_line = "\033[K"; + + // Foreground colors + const std::string black = "\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_black = "\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"; + + void log(const details::log_msg &msg) SPDLOG_FINAL override + { + // Wrap the originally formatted message in color codes. + // If color is not supported in the terminal, log as is instead. + std::lock_guard lock(mutex_); + + fmt::memory_buffer formatted; + formatter_->format(msg, formatted); + if (should_do_colors_ && msg.color_range_end > msg.color_range_start) + { + // before color range + print_range_(formatted, 0, msg.color_range_start); + // in color range + print_ccode_(colors_[msg.level]); + print_range_(formatted, msg.color_range_start, msg.color_range_end); + print_ccode_(reset); + // after color range + print_range_(formatted, msg.color_range_end, formatted.size()); + } + else // no color + { + print_range_(formatted, 0, formatted.size()); + } + fflush(target_file_); + } + + void flush() SPDLOG_FINAL override + { + std::lock_guard lock(mutex_); + fflush(target_file_); + } + + void set_pattern(const std::string &pattern) override SPDLOG_FINAL + { + std::lock_guard lock(mutex_); + formatter_ = std::unique_ptr(new pattern_formatter(pattern)); + } + + void set_formatter(std::unique_ptr sink_formatter) override SPDLOG_FINAL + { + std::lock_guard lock(mutex_); + formatter_ = std::move(sink_formatter); + } + +private: + void print_ccode_(const std::string &color_code) + { + fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); + } + void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end) + { + fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); + } + + FILE *target_file_; + mutex_t &mutex_; + + bool should_do_colors_; + std::unordered_map colors_; +}; + +using ansicolor_stdout_sink_mt = ansicolor_sink; +using ansicolor_stdout_sink_st = ansicolor_sink; + +using ansicolor_stderr_sink_mt = ansicolor_sink; +using ansicolor_stderr_sink_st = ansicolor_sink; + +} // namespace sinks + +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/base_sink.h b/spdlog_lib/spdlog/sinks/base_sink.h new file mode 100644 index 0000000..5a3821b --- /dev/null +++ b/spdlog_lib/spdlog/sinks/base_sink.h @@ -0,0 +1,63 @@ +// +// 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 real) +// concrete implementation should override the sink_it_() and flush_() methods. +// locking is taken care of in this class - no locking needed by the +// implementers.. +// + +#include "spdlog/common.h" +#include "spdlog/details/log_msg.h" +#include "spdlog/formatter.h" +#include "spdlog/sinks/sink.h" + +namespace spdlog { +namespace sinks { +template +class base_sink : public sink +{ +public: + base_sink() + : sink() + { + } + + base_sink(const base_sink &) = delete; + base_sink &operator=(const base_sink &) = delete; + + void log(const details::log_msg &msg) SPDLOG_FINAL override + { + std::lock_guard lock(mutex_); + sink_it_(msg); + } + + void flush() SPDLOG_FINAL override + { + std::lock_guard lock(mutex_); + flush_(); + } + + void set_pattern(const std::string &pattern) SPDLOG_FINAL override + { + std::lock_guard lock(mutex_); + formatter_ = std::unique_ptr(new pattern_formatter(pattern)); + } + + void set_formatter(std::unique_ptr sink_formatter) SPDLOG_FINAL override + { + std::lock_guard lock(mutex_); + formatter_ = std::move(sink_formatter); + } + +protected: + virtual void sink_it_(const details::log_msg &msg) = 0; + virtual void flush_() = 0; + Mutex mutex_; +}; +} // namespace sinks +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/basic_file_sink.h b/spdlog_lib/spdlog/sinks/basic_file_sink.h new file mode 100644 index 0000000..5db38e8 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/basic_file_sink.h @@ -0,0 +1,66 @@ +// +// Copyright(c) 2015-2018 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once +#include "spdlog/details/file_helper.h" +#include "spdlog/details/null_mutex.h" +#include "spdlog/sinks/base_sink.h" +#include "spdlog/spdlog.h" + +#include +#include + +namespace spdlog { +namespace sinks { +/* + * Trivial file sink with single file as target + */ +template +class basic_file_sink SPDLOG_FINAL : public base_sink +{ +public: + explicit basic_file_sink(const filename_t &filename, bool truncate = false) + { + file_helper_.open(filename, truncate); + } + +protected: + void sink_it_(const details::log_msg &msg) override + { + fmt::memory_buffer formatted; + sink::formatter_->format(msg, formatted); + file_helper_.write(formatted); + } + + void flush_() override + { + file_helper_.flush(); + } + +private: + details::file_helper file_helper_; +}; + +using basic_file_sink_mt = basic_file_sink; +using basic_file_sink_st = basic_file_sink; + +} // namespace sinks + +// +// factory functions +// +template +inline std::shared_ptr basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false) +{ + return Factory::template create(logger_name, filename, truncate); +} + +template +inline std::shared_ptr basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false) +{ + return Factory::template create(logger_name, filename, truncate); +} + +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/daily_file_sink.h b/spdlog_lib/spdlog/sinks/daily_file_sink.h new file mode 100644 index 0000000..940d55d --- /dev/null +++ b/spdlog_lib/spdlog/sinks/daily_file_sink.h @@ -0,0 +1,132 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once +#include "spdlog/details/file_helper.h" +#include "spdlog/details/null_mutex.h" +#include "spdlog/fmt/fmt.h" +#include "spdlog/sinks/base_sink.h" +#include "spdlog/spdlog.h" + +#include +#include +#include +#include +#include + +namespace spdlog { +namespace sinks { + +/* + * Generator of daily log file names in format basename.YYYY-MM-DD.ext + */ +struct daily_filename_calculator +{ + // Create filename for the form basename.YYYY-MM-DD + static filename_t calc_filename(const filename_t &filename, const tm &now_tm) + { + filename_t basename, ext; + std::tie(basename, ext) = details::file_helper::split_by_extenstion(filename); + std::conditional::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w; + fmt::format_to( + w, SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext); + return fmt::to_string(w); + } +}; + +/* + * Rotating file sink based on date. rotates at midnight + */ +template +class daily_file_sink SPDLOG_FINAL : public base_sink +{ +public: + // create daily file sink which rotates on given time + daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false) + : base_filename_(std::move(base_filename)) + , rotation_h_(rotation_hour) + , rotation_m_(rotation_minute) + , truncate_(truncate) + { + if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) + { + throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); + } + auto now = log_clock::now(); + file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(now)), truncate_); + rotation_tp_ = next_rotation_tp_(); + } + +protected: + void sink_it_(const details::log_msg &msg) override + { + + if (msg.time >= rotation_tp_) + { + file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(msg.time)), truncate_); + rotation_tp_ = next_rotation_tp_(); + } + fmt::memory_buffer formatted; + sink::formatter_->format(msg, formatted); + file_helper_.write(formatted); + } + + void flush_() override + { + file_helper_.flush(); + } + +private: + tm now_tm(log_clock::time_point tp) + { + time_t tnow = log_clock::to_time_t(tp); + return spdlog::details::os::localtime(tnow); + } + + log_clock::time_point next_rotation_tp_() + { + auto now = log_clock::now(); + tm date = now_tm(now); + date.tm_hour = rotation_h_; + date.tm_min = rotation_m_; + date.tm_sec = 0; + auto rotation_time = log_clock::from_time_t(std::mktime(&date)); + if (rotation_time > now) + { + return rotation_time; + } + return {rotation_time + std::chrono::hours(24)}; + } + + filename_t base_filename_; + int rotation_h_; + int rotation_m_; + log_clock::time_point rotation_tp_; + details::file_helper file_helper_; + bool truncate_; +}; + +using daily_file_sink_mt = daily_file_sink; +using daily_file_sink_st = daily_file_sink; + +} // namespace sinks + +// +// factory functions +// +template +inline std::shared_ptr daily_logger_mt( + const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false) +{ + return Factory::template create(logger_name, filename, hour, minute, truncate); +} + +template +inline std::shared_ptr daily_logger_st( + const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false) +{ + return Factory::template create(logger_name, filename, hour, minute, truncate); +} +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/dist_sink.h b/spdlog_lib/spdlog/sinks/dist_sink.h new file mode 100644 index 0000000..8d2f6f9 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/dist_sink.h @@ -0,0 +1,68 @@ +// +// Copyright (c) 2015 David Schury, Gabi Melman +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "base_sink.h" +#include "spdlog/details/log_msg.h" +#include "spdlog/details/null_mutex.h" + +#include +#include +#include +#include + +// Distribution sink (mux). Stores a vector of sinks which get called when log +// is called + +namespace spdlog { +namespace sinks { + +template +class dist_sink : public base_sink +{ +public: + dist_sink() = default; + dist_sink(const dist_sink &) = delete; + dist_sink &operator=(const dist_sink &) = delete; + + void add_sink(std::shared_ptr sink) + { + std::lock_guard lock(base_sink::mutex_); + sinks_.push_back(sink); + } + + void remove_sink(std::shared_ptr sink) + { + std::lock_guard lock(base_sink::mutex_); + sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end()); + } + +protected: + void sink_it_(const details::log_msg &msg) override + { + + for (auto &sink : sinks_) + { + if (sink->should_log(msg.level)) + { + sink->log(msg); + } + } + } + + void flush_() override + { + for (auto &sink : sinks_) + sink->flush(); + } + std::vector> sinks_; +}; + +using dist_sink_mt = dist_sink; +using dist_sink_st = dist_sink; + +} // namespace sinks +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/msvc_sink.h b/spdlog_lib/spdlog/sinks/msvc_sink.h new file mode 100644 index 0000000..a028496 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/msvc_sink.h @@ -0,0 +1,50 @@ +// +// Copyright(c) 2016 Alexander Dalshov. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#if defined(_WIN32) + +#include "spdlog/details/null_mutex.h" +#include "spdlog/sinks/base_sink.h" + +#include + +#include +#include + +namespace spdlog { +namespace sinks { +/* + * MSVC sink (logging using OutputDebugStringA) + */ +template +class msvc_sink : public base_sink +{ +public: + explicit msvc_sink() {} + +protected: + void sink_it_(const details::log_msg &msg) override + { + + fmt::memory_buffer formatted; + sink::formatter_->format(msg, formatted); + OutputDebugStringA(fmt::to_string(formatted).c_str()); + } + + void flush_() override {} +}; + +using msvc_sink_mt = msvc_sink; +using msvc_sink_st = msvc_sink; + +using windebug_sink_mt = msvc_sink_mt; +using windebug_sink_st = msvc_sink_st; + +} // namespace sinks +} // namespace spdlog + +#endif diff --git a/spdlog_lib/spdlog/sinks/null_sink.h b/spdlog_lib/spdlog/sinks/null_sink.h new file mode 100644 index 0000000..73b8c2b --- /dev/null +++ b/spdlog_lib/spdlog/sinks/null_sink.h @@ -0,0 +1,28 @@ +// +// 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 + +namespace spdlog { +namespace sinks { + +template +class null_sink : public base_sink +{ +protected: + void sink_it_(const details::log_msg &) override {} + void flush_() override {} +}; + +using null_sink_mt = null_sink; +using null_sink_st = null_sink; + +} // namespace sinks +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/ostream_sink.h b/spdlog_lib/spdlog/sinks/ostream_sink.h new file mode 100644 index 0000000..5f31993 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/ostream_sink.h @@ -0,0 +1,51 @@ +// +// 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 +#include + +namespace spdlog { +namespace sinks { +template +class ostream_sink SPDLOG_FINAL : public base_sink +{ +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; + +protected: + void sink_it_(const details::log_msg &msg) override + { + fmt::memory_buffer formatted; + sink::formatter_->format(msg, formatted); + ostream_.write(formatted.data(), formatted.size()); + if (force_flush_) + ostream_.flush(); + } + + void flush_() override + { + ostream_.flush(); + } + + std::ostream &ostream_; + bool force_flush_; +}; + +using ostream_sink_mt = ostream_sink; +using ostream_sink_st = ostream_sink; + +} // namespace sinks +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/rotating_file_sink.h b/spdlog_lib/spdlog/sinks/rotating_file_sink.h new file mode 100644 index 0000000..7ed2385 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/rotating_file_sink.h @@ -0,0 +1,144 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once +#include "spdlog/details/file_helper.h" +#include "spdlog/details/null_mutex.h" +#include "spdlog/fmt/fmt.h" +#include "spdlog/sinks/base_sink.h" +#include "spdlog/spdlog.h" + +#include +#include +#include +#include +#include +#include + +namespace spdlog { +namespace sinks { + +// +// Rotating file sink based on size +// +template +class rotating_file_sink SPDLOG_FINAL : public base_sink +{ +public: + rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files) + : base_filename_(std::move(base_filename)) + , max_size_(max_size) + , max_files_(max_files) + { + file_helper_.open(calc_filename(base_filename_, 0)); + current_size_ = file_helper_.size(); // expensive. called only once + } + + // calc filename according to index and file extension if exists. + // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". + static filename_t calc_filename(const filename_t &filename, std::size_t index) + { + typename std::conditional::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w; + if (index != 0u) + { + filename_t basename, ext; + std::tie(basename, ext) = details::file_helper::split_by_extenstion(filename); + fmt::format_to(w, SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext); + } + else + { + fmt::format_to(w, SPDLOG_FILENAME_T("{}"), filename); + } + return fmt::to_string(w); + } + +protected: + void sink_it_(const details::log_msg &msg) override + { + fmt::memory_buffer formatted; + sink::formatter_->format(msg, formatted); + current_size_ += formatted.size(); + if (current_size_ > max_size_) + { + rotate_(); + current_size_ = formatted.size(); + } + file_helper_.write(formatted); + } + + void flush_() override + { + file_helper_.flush(); + } + +private: + // Rotate files: + // log.txt -> log.1.txt + // log.1.txt -> log.2.txt + // log.2.txt -> log.3.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); + filename_t target = calc_filename(base_filename_, i); + + 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) != 0) + { + // if failed try again after small delay. + // this is a workaround to a windows issue, where very high rotation + // rates sometimes fail (because of antivirus?). + details::os::sleep_for_millis(20); + details::os::remove(target); + if (details::os::rename(src, target) != 0) + { + throw spdlog_ex( + "rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno); + } + } + } + file_helper_.reopen(true); + } + + filename_t base_filename_; + std::size_t max_size_; + std::size_t max_files_; + std::size_t current_size_; + details::file_helper file_helper_; +}; + +using rotating_file_sink_mt = rotating_file_sink; +using rotating_file_sink_st = rotating_file_sink; + +} // namespace sinks + +// +// factory functions +// + +template +inline std::shared_ptr rotating_logger_mt( + const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files) +{ + return Factory::template create(logger_name, filename, max_file_size, max_files); +} + +template +inline std::shared_ptr rotating_logger_st( + const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files) +{ + return Factory::template create(logger_name, filename, max_file_size, max_files); +} +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/sink.h b/spdlog_lib/spdlog/sinks/sink.h new file mode 100644 index 0000000..288d543 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/sink.h @@ -0,0 +1,57 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "spdlog/details/log_msg.h" +#include "spdlog/details/pattern_formatter.h" +#include "spdlog/formatter.h" + +namespace spdlog { +namespace sinks { +class sink +{ +public: + sink() + : level_(level::trace) + , formatter_(new pattern_formatter("%+")) + { + } + + sink(std::unique_ptr formatter) + : level_(level::trace) + , formatter_(std::move(formatter)){}; + + virtual ~sink() = default; + virtual void log(const details::log_msg &msg) = 0; + virtual void flush() = 0; + virtual void set_pattern(const std::string &pattern) = 0; + virtual void set_formatter(std::unique_ptr sink_formatter) = 0; + + bool should_log(level::level_enum msg_level) const + { + return msg_level >= level_.load(std::memory_order_relaxed); + } + + void set_level(level::level_enum log_level) + { + level_.store(log_level); + } + + level::level_enum level() const + { + return static_cast(level_.load(std::memory_order_relaxed)); + } + +protected: + // sink log level - default is all + level_t level_; + + // sink formatter - default is full format + std::unique_ptr formatter_; +}; + +} // namespace sinks +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/stdout_color_sinks.h b/spdlog_lib/spdlog/sinks/stdout_color_sinks.h new file mode 100644 index 0000000..761e32a --- /dev/null +++ b/spdlog_lib/spdlog/sinks/stdout_color_sinks.h @@ -0,0 +1,53 @@ +// +// Copyright(c) 2018 spdlog +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "spdlog/spdlog.h" +#ifdef _WIN32 +#include "spdlog/sinks/wincolor_sink.h" +#else +#include "spdlog/sinks/ansicolor_sink.h" +#endif + +namespace spdlog { +namespace sinks { +#ifdef _WIN32 +using stdout_color_sink_mt = wincolor_stdout_sink_mt; +using stdout_color_sink_st = wincolor_stdout_sink_st; +using stderr_color_sink_mt = wincolor_stderr_sink_mt; +using stderr_color_sink_st = wincolor_stderr_sink_st; +#else +using stdout_color_sink_mt = ansicolor_stdout_sink_mt; +using stdout_color_sink_st = ansicolor_stdout_sink_st; +using stderr_color_sink_mt = ansicolor_stderr_sink_mt; +using stderr_color_sink_st = ansicolor_stderr_sink_st; +#endif +} // namespace sinks + +template +inline std::shared_ptr stdout_color_mt(const std::string &logger_name) +{ + return Factory::template create(logger_name); +} + +template +inline std::shared_ptr stdout_color_st(const std::string &logger_name) +{ + return Factory::template create(logger_name); +} + +template +inline std::shared_ptr stderr_color_mt(const std::string &logger_name) +{ + return Factory::template create(logger_name); +} + +template +inline std::shared_ptr stderr_color_st(const std::string &logger_name) +{ + return Factory::template create(logger_name); +} +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/stdout_sinks.h b/spdlog_lib/spdlog/sinks/stdout_sinks.h new file mode 100644 index 0000000..64c0ab7 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/stdout_sinks.h @@ -0,0 +1,100 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "spdlog/details/console_globals.h" +#include "spdlog/details/null_mutex.h" +#include "spdlog/spdlog.h" + +#include +#include +#include +#include + +namespace spdlog { + +namespace sinks { + +template +class stdout_sink : public sink +{ +public: + using mutex_t = typename ConsoleMutex::mutex_t; + stdout_sink() + : mutex_(ConsoleMutex::mutex()) + , file_(TargetStream::stream()) + { + } + ~stdout_sink() = default; + + stdout_sink(const stdout_sink &other) = delete; + stdout_sink &operator=(const stdout_sink &other) = delete; + + void log(const details::log_msg &msg) override + { + std::lock_guard lock(mutex_); + fmt::memory_buffer formatted; + formatter_->format(msg, formatted); + fwrite(formatted.data(), sizeof(char), formatted.size(), file_); + fflush(TargetStream::stream()); + } + + void flush() override + { + std::lock_guard lock(mutex_); + fflush(file_); + } + + void set_pattern(const std::string &pattern) override SPDLOG_FINAL + { + std::lock_guard lock(mutex_); + formatter_ = std::unique_ptr(new pattern_formatter(pattern)); + } + + void set_formatter(std::unique_ptr sink_formatter) override SPDLOG_FINAL + { + std::lock_guard lock(mutex_); + formatter_ = std::move(sink_formatter); + } + +private: + mutex_t &mutex_; + FILE *file_; +}; + +using stdout_sink_mt = stdout_sink; +using stdout_sink_st = stdout_sink; + +using stderr_sink_mt = stdout_sink; +using stderr_sink_st = stdout_sink; + +} // namespace sinks + +// factory methods +template +inline std::shared_ptr stdout_logger_mt(const std::string &logger_name) +{ + return Factory::template create(logger_name); +} + +template +inline std::shared_ptr stdout_logger_st(const std::string &logger_name) +{ + return Factory::template create(logger_name); +} + +template +inline std::shared_ptr stderr_logger_mt(const std::string &logger_name) +{ + return Factory::template create(logger_name); +} + +template +inline std::shared_ptr stderr_logger_st(const std::string &logger_name) +{ + return Factory::template create(logger_name); +} +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/syslog_sink.h b/spdlog_lib/spdlog/sinks/syslog_sink.h new file mode 100644 index 0000000..e171bf9 --- /dev/null +++ b/spdlog_lib/spdlog/sinks/syslog_sink.h @@ -0,0 +1,91 @@ +// +// 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/spdlog.h" + +#include +#include +#include + +namespace spdlog { +namespace sinks { +/** + * Sink that write to syslog using the `syscall()` library call. + * + * Locking is not needed, as `syslog()` itself is thread-safe. + */ +template +class syslog_sink : public base_sink +{ +public: + // + syslog_sink(const std::string &ident = "", int syslog_option = 0, int syslog_facility = LOG_USER) + : ident_(ident) + { + priorities_[static_cast(level::trace)] = LOG_DEBUG; + priorities_[static_cast(level::debug)] = LOG_DEBUG; + priorities_[static_cast(level::info)] = LOG_INFO; + priorities_[static_cast(level::warn)] = LOG_WARNING; + priorities_[static_cast(level::err)] = LOG_ERR; + priorities_[static_cast(level::critical)] = LOG_CRIT; + priorities_[static_cast(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() override + { + ::closelog(); + } + + syslog_sink(const syslog_sink &) = delete; + syslog_sink &operator=(const syslog_sink &) = delete; + +protected: + void sink_it_(const details::log_msg &msg) override + { + ::syslog(syslog_prio_from_level(msg), "%s", fmt::to_string(msg.raw).c_str()); + } + + void flush_() override {} + +private: + std::array 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(msg.level)]; + } +}; + +using syslog_sink_mt = syslog_sink; +using syslog_sink_st = syslog_sink; +} // namespace sinks + +// Create and register a syslog logger +template +inline std::shared_ptr syslog_logger_mt( + const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = (1 << 3)) +{ + return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility); +} + +template +inline std::shared_ptr syslog_logger_st( + const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = (1 << 3)) +{ + return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility); +} +} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/wincolor_sink.h b/spdlog_lib/spdlog/sinks/wincolor_sink.h new file mode 100644 index 0000000..8c63e7f --- /dev/null +++ b/spdlog_lib/spdlog/sinks/wincolor_sink.h @@ -0,0 +1,139 @@ +// +// Copyright(c) 2016 spdlog +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#include "spdlog/common.h" +#include "spdlog/details/console_globals.h" +#include "spdlog/details/null_mutex.h" +#include "spdlog/sinks/sink.h" + +#include +#include +#include +#include +#include + +namespace spdlog { +namespace sinks { +/* + * Windows color console sink. Uses WriteConsoleA to write to the console with + * colors + */ +template +class wincolor_sink : public sink +{ +public: + const WORD BOLD = FOREGROUND_INTENSITY; + const WORD RED = FOREGROUND_RED; + const WORD GREEN = FOREGROUND_GREEN; + 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() + : out_handle_(OutHandle::handle()) + , mutex_(ConsoleMutex::mutex()) + { + colors_[level::trace] = WHITE; + colors_[level::debug] = CYAN; + colors_[level::info] = GREEN; + 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; + } + + ~wincolor_sink() override + { + this->flush(); + } + + wincolor_sink(const wincolor_sink &other) = delete; + wincolor_sink &operator=(const wincolor_sink &other) = delete; + + // change the color for the given level + void set_color(level::level_enum level, WORD color) + { + std::lock_guard lock(mutex_); + colors_[level] = color; + } + + void log(const details::log_msg &msg) SPDLOG_FINAL override + { + std::lock_guard lock(mutex_); + fmt::memory_buffer formatted; + formatter_->format(msg, formatted); + if (msg.color_range_end > msg.color_range_start) + { + // before color range + print_range_(formatted, 0, msg.color_range_start); + + // in color range + auto orig_attribs = set_console_attribs(colors_[msg.level]); + print_range_(formatted, msg.color_range_start, msg.color_range_end); + ::SetConsoleTextAttribute(out_handle_, + orig_attribs); // reset to orig colors + // after color range + print_range_(formatted, msg.color_range_end, formatted.size()); + } + else // print without colors if color range is invalid + { + print_range_(formatted, 0, formatted.size()); + } + } + + void flush() SPDLOG_FINAL override + { + // windows console always flushed? + } + + void set_pattern(const std::string &pattern) override SPDLOG_FINAL + { + std::lock_guard lock(mutex_); + formatter_ = std::unique_ptr(new pattern_formatter(pattern)); + } + + void set_formatter(std::unique_ptr sink_formatter) override SPDLOG_FINAL + { + std::lock_guard lock(mutex_); + formatter_ = std::move(sink_formatter); + } + +private: + using mutex_t = typename ConsoleMutex::mutex_t; + // 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); + WORD back_color = orig_buffer_info.wAttributes; + // retrieve the current background color + back_color &= static_cast(~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY)); + // keep the background color unchanged + ::SetConsoleTextAttribute(out_handle_, attribs | back_color); + return orig_buffer_info.wAttributes; // return orig attribs + } + + // print a range of formatted message to console + void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end) + { + auto size = static_cast(end - start); + ::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr, nullptr); + } + + HANDLE out_handle_; + mutex_t &mutex_; + std::unordered_map colors_; +}; + +using wincolor_stdout_sink_mt = wincolor_sink; +using wincolor_stdout_sink_st = wincolor_sink; + +using wincolor_stderr_sink_mt = wincolor_sink; +using wincolor_stderr_sink_st = wincolor_sink; + +} // namespace sinks +} // namespace spdlog diff --git a/spdlog_lib/spdlog/spdlog.h b/spdlog_lib/spdlog/spdlog.h new file mode 100644 index 0000000..2963a2a --- /dev/null +++ b/spdlog_lib/spdlog/spdlog.h @@ -0,0 +1,161 @@ +// +// Copyright(c) 2015-2018 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/common.h" +#include "spdlog/details/registry.h" +#include "spdlog/logger.h" +#include "spdlog/version.h" + +#include +#include +#include +#include + +namespace spdlog { + +// Default logger factory- creates synchronous loggers +struct synchronous_factory +{ + template + + static std::shared_ptr create(std::string logger_name, SinkArgs &&... args) + { + auto sink = std::make_shared(std::forward(args)...); + auto new_logger = std::make_shared(std::move(logger_name), std::move(sink)); + details::registry::instance().register_and_init(new_logger); + return new_logger; + } +}; + +using default_factory = synchronous_factory; + +// Create and register a logger with a templated sink type +// The logger's level, formatter and flush level will be set according the +// global settings. +// Example: +// spdlog::create("logger_name", "dailylog_filename", 11, 59); +template +inline std::shared_ptr create(std::string logger_name, SinkArgs &&... sink_args) +{ + return default_factory::create(std::move(logger_name), std::forward(sink_args)...); +} + +// Return an existing logger or nullptr if a logger with such name doesn't +// exist. +// example: spdlog::get("my_logger")->info("hello {}", "world"); +inline std::shared_ptr get(const std::string &name) +{ + return details::registry::instance().get(name); +} + +// Set global formatter. Each sink in each logger will get a clone of this object +inline void set_formatter(std::unique_ptr formatter) +{ + details::registry::instance().set_formatter(std::move(formatter)); +} + +// Set global format string. +// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); +inline void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local) +{ + set_formatter(std::unique_ptr(new pattern_formatter(pattern, time_type))); +} + +// Set global logging level +inline void set_level(level::level_enum log_level) +{ + details::registry::instance().set_level(log_level); +} + +// Set global flush level +inline void flush_on(level::level_enum log_level) +{ + details::registry::instance().flush_on(log_level); +} + +// Start/Restart a periodic flusher thread +// Warning: Use only if all your loggers are thread safe! +inline void flush_every(std::chrono::seconds interval) +{ + details::registry::instance().flush_every(interval); +} + +// Set global error handler +inline void set_error_handler(log_err_handler handler) +{ + details::registry::instance().set_error_handler(std::move(handler)); +} + +// Register the given logger with the given name +inline void register_logger(std::shared_ptr logger) +{ + details::registry::instance().register_logger(std::move(logger)); +} + +// Apply a user defined function on all registered loggers +// Example: +// spdlog::apply_all([&](std::shared_ptr l) {l->flush();}); +inline void apply_all(std::function)> fun) +{ + details::registry::instance().apply_all(std::move(fun)); +} + +// Drop the reference to the given logger +inline void drop(const std::string &name) +{ + details::registry::instance().drop(name); +} + +// Drop all references from the registry +inline void drop_all() +{ + details::registry::instance().drop_all(); +} + +// stop any running threads started by spdlog and clean registry loggers +inline void shutdown() +{ + details::registry::instance().shutdown(); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Trace & Debug can be switched on/off at compile time for zero cost debug +// statements. +// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in tweakme.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) +#ifdef _MSC_VER +#define SPDLOG_TRACE(logger, ...) logger->trace("[ " __FILE__ "(" SPDLOG_STR_HELPER(__LINE__) ") ] " __VA_ARGS__) +#else +#define SPDLOG_TRACE(logger, ...) \ + logger->trace("[ " __FILE__ ":" SPDLOG_STR_HELPER(__LINE__) " ]" \ + " " __VA_ARGS__) +#endif +#else +#define SPDLOG_TRACE(logger, ...) (void)0 +#endif + +#ifdef SPDLOG_DEBUG_ON +#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__) +#else +#define SPDLOG_DEBUG(logger, ...) (void)0 +#endif + +} // namespace spdlog diff --git a/spdlog_lib/spdlog/tweakme.h b/spdlog_lib/spdlog/tweakme.h new file mode 100644 index 0000000..5325645 --- /dev/null +++ b/spdlog_lib/spdlog/tweakme.h @@ -0,0 +1,132 @@ +// +// 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 querying 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 querying 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 to prevent spdlog from caching thread ids in thread local storage. +// By default spdlog saves thread ids in tls to gain a few micros for each call. +// +// WARNING: if your program forks, UNCOMMENT this flag to prevent undefined +// thread ids in the children logs. +// +// #define SPDLOG_DISABLE_TID_CACHING +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// 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 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 so set your -I flag +// accordingly. +// +// #define SPDLOG_FMT_EXTERNAL +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment to enable wchar_t support (convert to utf8) +// +// #define SPDLOG_WCHAR_TO_UTF8_SUPPORT +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment to prevent child processes from inheriting log file descriptors +// +// #define SPDLOG_PREVENT_CHILD_FD +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment if your compiler doesn't support the "final" keyword. +// The final keyword allows more optimizations in release +// mode with recent compilers. See GCC's documentation for -Wsuggest-final-types +// for instance. +// +// #define SPDLOG_NO_FINAL +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment to enable message counting feature. +// Use the %i in the logger pattern to display log message sequence id. +// +// #define SPDLOG_ENABLE_MESSAGE_COUNTER +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment to customize level names (e.g. "MT TRACE") +// +// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", +// "MY ERROR", "MY CRITICAL", "OFF" } +/////////////////////////////////////////////////////////////////////////////// diff --git a/spdlog_lib/spdlog/version.h b/spdlog_lib/spdlog/version.h new file mode 100644 index 0000000..729fcba --- /dev/null +++ b/spdlog_lib/spdlog/version.h @@ -0,0 +1,12 @@ +// +// Copyright(c) 2015 Gabi Melman. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) +// + +#pragma once + +#define SPDLOG_VER_MAJOR 1 +#define SPDLOG_VER_MINOR 0 +#define SPDLOG_VER_PATCH 0 + +#define SPDLOG_VERSION (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH) From 5452e882432befb466193b4d78d5fe8eae02f2fc Mon Sep 17 00:00:00 2001 From: cks Date: Tue, 7 Aug 2018 17:18:40 +0700 Subject: [PATCH 02/11] add logs --- logs/basic-log.txt | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 logs/basic-log.txt diff --git a/logs/basic-log.txt b/logs/basic-log.txt new file mode 100644 index 0000000..73b5037 --- /dev/null +++ b/logs/basic-log.txt @@ -0,0 +1,24 @@ +[2018-08-07 17:18:01.153] [test] [info] INFO of WALRUS and its total animal = "walrus" total = 100 +[2018-08-07 17:18:01.155] [test] [info] No Walrus +[2018-08-07 17:18:01.155] [test] [debug] DEBUG of HORSE and its total animal = "horse" total = 90 +[2018-08-07 17:18:01.155] [test] [debug] No Horse +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "trace" , "message" : "TRACE of BIRD and its total" , "animal" : "bird" , "total" : 40.500000 } +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "trace" , "message" : "No Bird" } +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "warning" , "message" : "WARN of DOG and its total" , "animal" : "dog" , "total" : 2.800000 } +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "warning" , "message" : "No Dog" } +[2018-08-07 17:18:01.156] [test] [critical] CRITICAL of CAT and its total animal = "cat" total = 100 +[2018-08-07 17:18:01.156] [test] [critical] No Cat +[2018-08-07 17:18:01.156] [test] [error] ERROR of FALCON and its total animal = "falcon" total = 10 +[2018-08-07 17:18:01.156] [test] [error] No Falcon +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "info" , "message" : "This is INFO with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "debug" , "message" : "This is DEBUG with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "trace" , "message" : "This is TRACE with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "warning" , "message" : "This is WARN with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "critical" , "message" : "This is CRITICAL with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "error" , "message" : "This is ERROR with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +[2018-08-07 17:18:01.156] [test] [info] This is INFO with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:18:01.156] [test] [debug] This is DEBUG with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:18:01.156] [test] [trace] This is TRACE with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:18:01.156] [test] [warning] This is WARN with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:18:01.156] [test] [critical] This is CRITICAL with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:18:01.156] [test] [error] This is ERROR with custom key animal = "griffin" rider = "azure" weapon = "spear" From 20bdf83b8f0ec3a5dbc240585730e03c21a9661c Mon Sep 17 00:00:00 2001 From: cks Date: Wed, 8 Aug 2018 17:51:11 +0700 Subject: [PATCH 03/11] change CustomLogger into logfmt --- .gitmodules | 3 + example.cpp | 6 +- external/spdlog | 1 + logfmt.cpp | 307 +++++++++++++++++++++++++++++++++++++++++++++ logfmt.h | 60 +++++++++ logs/basic-log.txt | 24 ++++ 6 files changed, 398 insertions(+), 3 deletions(-) create mode 100644 .gitmodules create mode 160000 external/spdlog create mode 100644 logfmt.cpp create mode 100644 logfmt.h diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..6c66587 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "external/spdlog"] + path = external/spdlog + url = https://github.com/gabime/spdlog.git diff --git a/example.cpp b/example.cpp index bb6dd8c..d34f0fe 100644 --- a/example.cpp +++ b/example.cpp @@ -1,8 +1,8 @@ -#include "CustomLogger.h" +#include "logfmt.h" #define toFile false -// Compile with "g++ example.cpp CustomLogger.cpp -o example -Wall -Wextra -pedantic -std=c++17 -pthread -Ispdlog_lib -fmax-errors=1 -O3 -march=native" +// Compile with "g++ example.cpp logfmt.cpp -o example -Wall -Wextra -pedantic -std=c++17 -pthread -Iexternal/spdlog/include -fmax-errors=1 -O3 -march=native" // dont forget to create logs folder if logging to file int main() @@ -10,7 +10,7 @@ int main() std::string a ="testing"; float float_test = 2.8; long long_test = 100; - CustomLogger log("test", toFile); + logfmt log("test", toFile); spdlog::set_level(spdlog::level::trace); log.WithField(log.custom_field={{"animal", "walrus"}, {"total", 100}}).info("INFO of WALRUS and its total"); diff --git a/external/spdlog b/external/spdlog new file mode 160000 index 0000000..8179b26 --- /dev/null +++ b/external/spdlog @@ -0,0 +1 @@ +Subproject commit 8179b26388d118fa887030f2609560ec287531dd diff --git a/logfmt.cpp b/logfmt.cpp new file mode 100644 index 0000000..25161ce --- /dev/null +++ b/logfmt.cpp @@ -0,0 +1,307 @@ +#include "logfmt.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////////// + +//class Entry + +//private +std::string logfmt::Entry::AddQuotation(std::string msg) //return quotation in message input +{ + return "\"" + msg + "\""; +} + +std::string logfmt::Entry::JSONformatter() //return json formatter +{ + return "\"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : \"%v\" "; +} + +std::string logfmt::Entry::processPattern(std::string pattern) +{ + if(JSON) //jsonform is true + { + return "{ " + JSONformatter() + pattern + "}"; + } + else //jsonform is false + { + return "%+ " + pattern; + } +} + +std::string logfmt::Entry::processKey() +{ + std::string pattern =""; + + for (auto& [key,val] : entry_field) + { + pattern = pattern + casting(key, val); + } + return processPattern(pattern); +} + +std::string logfmt::Entry::casting(std::string key, std::any val) //casting the value in map into string +{ + std::string custom_string; + if(JSON) + { + custom_string = custom_string + ", " + AddQuotation(key) + " : " ; + //check type for any_cast + if (val.type() == typeid(char)) //char + { + custom_string = custom_string + "\""; + custom_string += (std::any_cast(val)); + custom_string = custom_string + "\" "; + } + else if (val.type() == typeid(const char *)) //array of char + { + std::string temp(std::any_cast(val)); + custom_string = custom_string + AddQuotation(temp) + " "; + } + else if (val.type() == typeid(int)) //integer + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(float)) //float + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(double)) //double + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(bool)) //boolean + { + if (std::any_cast(val) == 1) + { + custom_string = custom_string + "true "; + } + else if (std::any_cast(val) == 0) + { + custom_string = custom_string + "false "; + } + } + else if (val.type() == typeid(std::string)) //string + { + custom_string = custom_string + AddQuotation(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(long)) //long + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + } + else + { + custom_string = custom_string + key + " = " ; + if (val.type() == typeid(char)) + { + custom_string = custom_string + "\""; + custom_string += (std::any_cast(val)); + custom_string = custom_string + "\" "; + } + else if (val.type() == typeid(const char *)) + { + std::string temp(std::any_cast(val)); + custom_string = custom_string + AddQuotation(temp) + " "; + } + else if (val.type() == typeid(int)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(float)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(double)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(bool)) + { + if (std::any_cast(val) == 1) + { + custom_string = custom_string + "true "; + } + else if (std::any_cast(val) == 0) + { + custom_string = custom_string + "false "; + } + } + else if (val.type() == typeid(std::string)) + { + custom_string = custom_string + AddQuotation(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(long)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + } + + return custom_string; +} + +//public +logfmt::Entry::Entry() +{ + //default ctor (not used) +} + +logfmt::Entry::Entry(std::shared_ptr& log, bool JSON ) //ctor +{ + entry_log = log; + this -> JSON = JSON; +} + +logfmt::Entry& logfmt::Entry::WithField(std::map& keyMap) +{ + entry_field = keyMap; + return *this; +} +void logfmt::Entry::info(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> info(msg); +} + +void logfmt::Entry::trace(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> trace(msg); +} + +void logfmt::Entry::debug(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> debug(msg); +} + +void logfmt::Entry::warn(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> warn(msg); +} + +void logfmt::Entry::error(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> error(msg); +} + +void logfmt::Entry::critical(std::string msg) +{ + entry_log -> set_pattern(processKey()); + entry_log -> critical(msg); +} +//////////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////////// +// logfmt implementation + +logfmt::logfmt(std::string name, bool to_file) //constructor +{ + if (to_file) + { + logger = spdlog::basic_logger_mt(name , "logs/basic-log.txt"); + } + else + { + logger = spdlog::stdout_color_mt(name); + } + WriteFile = to_file; + JSONstatus = false; +} + +// function +void logfmt::OutputJSON() +{ + JSONstatus = true; +} + +void logfmt::OutputDefault() +{ + JSONstatus = false; +} + +logfmt::Entry& logfmt::WithField(std::map& keyMap) +{ + loggerEntry = Entry(logger, JSONstatus); + return loggerEntry.WithField(keyMap); +} + +std::string logfmt::JSONformatter() +{ + return "\"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : \"%v\" "; +} + +//basic logging +void logfmt::info(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> info(msg); +} + +void logfmt::trace(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> trace(msg); +} +void logfmt::debug(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> debug(msg); +} +void logfmt::warn(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> warn(msg); +} +void logfmt::error(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> error(msg); +} +void logfmt::critical(std::string msg) +{ + if(JSONstatus) + { + logger -> set_pattern("{ " + JSONformatter() + "}"); + } + else + { + logger -> set_pattern("%+"); + } + logger -> critical(msg); +} diff --git a/logfmt.h b/logfmt.h new file mode 100644 index 0000000..bb41613 --- /dev/null +++ b/logfmt.h @@ -0,0 +1,60 @@ +#pragma once + +#include +#include +#include +#include +#include "spdlog/spdlog.h" +#include "spdlog/sinks/stdout_color_sinks.h" +#include "spdlog/sinks/basic_file_sink.h" + +class logfmt +{ +private: + //member + class Entry + { + private: + //member + std::map entry_field; + std::shared_ptr entry_log; + bool JSON; + //function + std::string AddQuotation(std::string msg); + std::string JSONformatter(); + std::string processPattern(std::string pattern); + std::string processKey(); + std::string casting(std::string key, std::any val); + public: + Entry(); //default ctor + Entry(std::shared_ptr& log, bool JSON ); //ctor with parameter + Entry& WithField(std::map& keyMap); + void info(std::string msg); + void trace(std::string msg); + void debug(std::string msg); + void warn(std::string msg); + void error(std::string msg); + void critical(std::string msg); + }; + Entry loggerEntry; + std::shared_ptr logger; + bool JSONstatus; // make this true to make log in JSON form / false in normal form + bool WriteFile; // make this true to write log into file +public: + //member + std::map custom_field; + //ctor + logfmt(std::string name, bool to_file); + //function + void OutputJSON(); + void OutputDefault(); + logfmt::Entry& WithField(std::map& keyMap); + std::string JSONformatter(); + //basic logging + void info(std::string msg); + void trace(std::string msg); + void debug(std::string msg); + void warn(std::string msg); + void error(std::string msg); + void critical(std::string msg); +}; diff --git a/logs/basic-log.txt b/logs/basic-log.txt index 73b5037..db8e863 100644 --- a/logs/basic-log.txt +++ b/logs/basic-log.txt @@ -22,3 +22,27 @@ [2018-08-07 17:18:01.156] [test] [warning] This is WARN with custom key animal = "griffin" rider = "azure" weapon = "spear" [2018-08-07 17:18:01.156] [test] [critical] This is CRITICAL with custom key animal = "griffin" rider = "azure" weapon = "spear" [2018-08-07 17:18:01.156] [test] [error] This is ERROR with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:20:39.675] [test] [info] INFO of WALRUS and its total animal = "walrus" total = 100 +[2018-08-07 17:20:39.677] [test] [info] No Walrus +[2018-08-07 17:20:39.677] [test] [debug] DEBUG of HORSE and its total animal = "horse" total = 90 +[2018-08-07 17:20:39.677] [test] [debug] No Horse +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "trace" , "message" : "TRACE of BIRD and its total" , "animal" : "bird" , "total" : 40.500000 } +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "trace" , "message" : "No Bird" } +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "warning" , "message" : "WARN of DOG and its total" , "animal" : "dog" , "total" : 2.800000 } +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "warning" , "message" : "No Dog" } +[2018-08-07 17:20:39.677] [test] [critical] CRITICAL of CAT and its total animal = "cat" total = 100 +[2018-08-07 17:20:39.677] [test] [critical] No Cat +[2018-08-07 17:20:39.677] [test] [error] ERROR of FALCON and its total animal = "falcon" total = 10 +[2018-08-07 17:20:39.677] [test] [error] No Falcon +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "info" , "message" : "This is INFO with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "debug" , "message" : "This is DEBUG with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "trace" , "message" : "This is TRACE with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "warning" , "message" : "This is WARN with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "critical" , "message" : "This is CRITICAL with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "error" , "message" : "This is ERROR with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } +[2018-08-07 17:20:39.677] [test] [info] This is INFO with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:20:39.677] [test] [debug] This is DEBUG with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:20:39.677] [test] [trace] This is TRACE with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:20:39.677] [test] [warning] This is WARN with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:20:39.677] [test] [critical] This is CRITICAL with custom key animal = "griffin" rider = "azure" weapon = "spear" +[2018-08-07 17:20:39.677] [test] [error] This is ERROR with custom key animal = "griffin" rider = "azure" weapon = "spear" From 249bcd0e1108baf425c8afb97b3f0b64f691d3a9 Mon Sep 17 00:00:00 2001 From: cks Date: Wed, 8 Aug 2018 17:52:57 +0700 Subject: [PATCH 04/11] delete CustomLogger --- CustomLogger.cpp | 308 -- CustomLogger.h | 60 - spdlog_lib/spdlog/async.h | 87 - spdlog_lib/spdlog/async_logger.h | 71 - spdlog_lib/spdlog/common.h | 183 - spdlog_lib/spdlog/details/async_logger_impl.h | 100 - spdlog_lib/spdlog/details/circular_q.h | 62 - spdlog_lib/spdlog/details/console_globals.h | 61 - spdlog_lib/spdlog/details/file_helper.h | 153 - spdlog_lib/spdlog/details/fmt_helper.h | 130 - spdlog_lib/spdlog/details/log_msg.h | 47 - spdlog_lib/spdlog/details/logger_impl.h | 345 -- spdlog_lib/spdlog/details/mpmc_blocking_q.h | 115 - spdlog_lib/spdlog/details/null_mutex.h | 45 - spdlog_lib/spdlog/details/os.h | 432 -- spdlog_lib/spdlog/details/pattern_formatter.h | 772 --- spdlog_lib/spdlog/details/periodic_worker.h | 71 - spdlog_lib/spdlog/details/registry.h | 218 - spdlog_lib/spdlog/details/thread_pool.h | 220 - spdlog_lib/spdlog/fmt/bundled/LICENSE.rst | 23 - spdlog_lib/spdlog/fmt/bundled/colors.h | 257 - spdlog_lib/spdlog/fmt/bundled/core.h | 1578 ------ spdlog_lib/spdlog/fmt/bundled/format-inl.h | 578 -- spdlog_lib/spdlog/fmt/bundled/format.h | 4716 ----------------- spdlog_lib/spdlog/fmt/bundled/locale.h | 27 - spdlog_lib/spdlog/fmt/bundled/ostream.h | 173 - spdlog_lib/spdlog/fmt/bundled/posix.h | 484 -- spdlog_lib/spdlog/fmt/bundled/printf.h | 807 --- spdlog_lib/spdlog/fmt/bundled/ranges.h | 344 -- spdlog_lib/spdlog/fmt/bundled/time.h | 199 - spdlog_lib/spdlog/fmt/fmt.h | 25 - spdlog_lib/spdlog/fmt/ostr.h | 18 - spdlog_lib/spdlog/formatter.h | 20 - spdlog_lib/spdlog/logger.h | 162 - spdlog_lib/spdlog/sinks/android_sink.h | 117 - spdlog_lib/spdlog/sinks/ansicolor_sink.h | 156 - spdlog_lib/spdlog/sinks/base_sink.h | 63 - spdlog_lib/spdlog/sinks/basic_file_sink.h | 66 - spdlog_lib/spdlog/sinks/daily_file_sink.h | 132 - spdlog_lib/spdlog/sinks/dist_sink.h | 68 - spdlog_lib/spdlog/sinks/msvc_sink.h | 50 - spdlog_lib/spdlog/sinks/null_sink.h | 28 - spdlog_lib/spdlog/sinks/ostream_sink.h | 51 - spdlog_lib/spdlog/sinks/rotating_file_sink.h | 144 - spdlog_lib/spdlog/sinks/sink.h | 57 - spdlog_lib/spdlog/sinks/stdout_color_sinks.h | 53 - spdlog_lib/spdlog/sinks/stdout_sinks.h | 100 - spdlog_lib/spdlog/sinks/syslog_sink.h | 91 - spdlog_lib/spdlog/sinks/wincolor_sink.h | 139 - spdlog_lib/spdlog/spdlog.h | 161 - spdlog_lib/spdlog/tweakme.h | 132 - spdlog_lib/spdlog/version.h | 12 - 52 files changed, 14511 deletions(-) delete mode 100644 CustomLogger.cpp delete mode 100644 CustomLogger.h delete mode 100644 spdlog_lib/spdlog/async.h delete mode 100644 spdlog_lib/spdlog/async_logger.h delete mode 100644 spdlog_lib/spdlog/common.h delete mode 100644 spdlog_lib/spdlog/details/async_logger_impl.h delete mode 100644 spdlog_lib/spdlog/details/circular_q.h delete mode 100644 spdlog_lib/spdlog/details/console_globals.h delete mode 100644 spdlog_lib/spdlog/details/file_helper.h delete mode 100644 spdlog_lib/spdlog/details/fmt_helper.h delete mode 100644 spdlog_lib/spdlog/details/log_msg.h delete mode 100644 spdlog_lib/spdlog/details/logger_impl.h delete mode 100644 spdlog_lib/spdlog/details/mpmc_blocking_q.h delete mode 100644 spdlog_lib/spdlog/details/null_mutex.h delete mode 100644 spdlog_lib/spdlog/details/os.h delete mode 100644 spdlog_lib/spdlog/details/pattern_formatter.h delete mode 100644 spdlog_lib/spdlog/details/periodic_worker.h delete mode 100644 spdlog_lib/spdlog/details/registry.h delete mode 100644 spdlog_lib/spdlog/details/thread_pool.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/LICENSE.rst delete mode 100644 spdlog_lib/spdlog/fmt/bundled/colors.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/core.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/format-inl.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/format.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/locale.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/ostream.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/posix.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/printf.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/ranges.h delete mode 100644 spdlog_lib/spdlog/fmt/bundled/time.h delete mode 100644 spdlog_lib/spdlog/fmt/fmt.h delete mode 100644 spdlog_lib/spdlog/fmt/ostr.h delete mode 100644 spdlog_lib/spdlog/formatter.h delete mode 100644 spdlog_lib/spdlog/logger.h delete mode 100644 spdlog_lib/spdlog/sinks/android_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/ansicolor_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/base_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/basic_file_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/daily_file_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/dist_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/msvc_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/null_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/ostream_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/rotating_file_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/sink.h delete mode 100644 spdlog_lib/spdlog/sinks/stdout_color_sinks.h delete mode 100644 spdlog_lib/spdlog/sinks/stdout_sinks.h delete mode 100644 spdlog_lib/spdlog/sinks/syslog_sink.h delete mode 100644 spdlog_lib/spdlog/sinks/wincolor_sink.h delete mode 100644 spdlog_lib/spdlog/spdlog.h delete mode 100644 spdlog_lib/spdlog/tweakme.h delete mode 100644 spdlog_lib/spdlog/version.h diff --git a/CustomLogger.cpp b/CustomLogger.cpp deleted file mode 100644 index fe277bb..0000000 --- a/CustomLogger.cpp +++ /dev/null @@ -1,308 +0,0 @@ -#include "CustomLogger.h" - -//////////////////////////////////////////////////////////////////////////////////////////////////////// - -//class Entry - -//private -std::string CustomLogger::Entry::AddQuotation(std::string msg) //return quotation in message input -{ - return "\"" + msg + "\""; -} - -std::string CustomLogger::Entry::JSONformatter() //return json formatter -{ - return "\"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : \"%v\" "; -} - -std::string CustomLogger::Entry::processPattern(std::string pattern) -{ - if(JSON) //jsonform is true - { - return "{ " + JSONformatter() + pattern + "}"; - } - else //jsonform is false - { - return "%+ " + pattern; - } -} - -std::string CustomLogger::Entry::processKey() -{ - std::string pattern =""; - - for (auto& [key,val] : entry_field) - { - pattern = pattern + casting(key, val); - } - return processPattern(pattern); -} - -std::string CustomLogger::Entry::casting(std::string key, std::any val) //casting the value in map into string -{ - std::string custom_string; - if(JSON) - { - custom_string = custom_string + ", " + AddQuotation(key) + " : " ; - //check type for any_cast - if (val.type() == typeid(char)) //char - { - custom_string = custom_string + "\""; - custom_string += (std::any_cast(val)); - custom_string = custom_string + "\" "; - } - else if (val.type() == typeid(const char *)) //array of char - { - std::string temp(std::any_cast(val)); - custom_string = custom_string + AddQuotation(temp) + " "; - } - else if (val.type() == typeid(int)) //integer - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(float)) //float - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(double)) //double - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(bool)) //boolean - { - if (std::any_cast(val) == 1) - { - custom_string = custom_string + "true "; - } - else if (std::any_cast(val) == 0) - { - custom_string = custom_string + "false "; - } - } - else if (val.type() == typeid(std::string)) //string - { - custom_string = custom_string + AddQuotation(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(long)) //long - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - } - else - { - custom_string = custom_string + key + " = " ; - //check type for any_cast - if (val.type() == typeid(char)) - { - custom_string = custom_string + "\""; - custom_string += (std::any_cast(val)); - custom_string = custom_string + "\" "; - } - else if (val.type() == typeid(const char *)) - { - std::string temp(std::any_cast(val)); - custom_string = custom_string + AddQuotation(temp) + " "; - } - else if (val.type() == typeid(int)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(float)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(double)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(bool)) - { - if (std::any_cast(val) == 1) - { - custom_string = custom_string + "true "; - } - else if (std::any_cast(val) == 0) - { - custom_string = custom_string + "false "; - } - } - else if (val.type() == typeid(std::string)) - { - custom_string = custom_string + AddQuotation(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(long)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - } - - return custom_string; -} - -//public -CustomLogger::Entry::Entry() -{ - //default ctor (not used) -} - -CustomLogger::Entry::Entry(std::shared_ptr& log, bool JSON ) //ctor -{ - entry_log = log; - this -> JSON = JSON; -} - -CustomLogger::Entry& CustomLogger::Entry::WithField(std::map& keyMap) -{ - entry_field = keyMap; - return *this; -} -void CustomLogger::Entry::info(std::string msg) -{ - entry_log -> set_pattern(processKey()); - entry_log -> info(msg); -} - -void CustomLogger::Entry::trace(std::string msg) -{ - entry_log -> set_pattern(processKey()); - entry_log -> trace(msg); -} - -void CustomLogger::Entry::debug(std::string msg) -{ - entry_log -> set_pattern(processKey()); - entry_log -> debug(msg); -} - -void CustomLogger::Entry::warn(std::string msg) -{ - entry_log -> set_pattern(processKey()); - entry_log -> warn(msg); -} - -void CustomLogger::Entry::error(std::string msg) -{ - entry_log -> set_pattern(processKey()); - entry_log -> error(msg); -} - -void CustomLogger::Entry::critical(std::string msg) -{ - entry_log -> set_pattern(processKey()); - entry_log -> critical(msg); -} -//////////////////////////////////////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////////////////////////////////////// -// CustomLogger implementation - -CustomLogger::CustomLogger(std::string name, bool to_file) //constructor -{ - if (to_file) - { - logger = spdlog::basic_logger_mt(name , "logs/basic-log.txt"); - } - else - { - logger = spdlog::stdout_color_mt(name); - } - WriteFile = to_file; - JSONstatus = false; -} - -// function -void CustomLogger::OutputJSON() -{ - JSONstatus = true; -} - -void CustomLogger::OutputDefault() -{ - JSONstatus = false; -} - -CustomLogger::Entry& CustomLogger::WithField(std::map& keyMap) -{ - loggerEntry = Entry(logger, JSONstatus); - return loggerEntry.WithField(keyMap); -} - -std::string CustomLogger::JSONformatter() -{ - return "\"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : \"%v\" "; -} - -//basic logging -void CustomLogger::info(std::string msg) -{ - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); - } - logger -> info(msg); -} - -void CustomLogger::trace(std::string msg) -{ - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); - } - logger -> trace(msg); -} -void CustomLogger::debug(std::string msg) -{ - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); - } - logger -> debug(msg); -} -void CustomLogger::warn(std::string msg) -{ - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); - } - logger -> warn(msg); -} -void CustomLogger::error(std::string msg) -{ - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); - } - logger -> error(msg); -} -void CustomLogger::critical(std::string msg) -{ - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); - } - logger -> critical(msg); -} diff --git a/CustomLogger.h b/CustomLogger.h deleted file mode 100644 index ea250b5..0000000 --- a/CustomLogger.h +++ /dev/null @@ -1,60 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include "spdlog/spdlog.h" -#include "spdlog/sinks/stdout_color_sinks.h" -#include "spdlog/sinks/basic_file_sink.h" - -class CustomLogger -{ -private: - //member - class Entry - { - private: - //member - std::map entry_field; - std::shared_ptr entry_log; - bool JSON; - //function - std::string AddQuotation(std::string msg); - std::string JSONformatter(); - std::string processPattern(std::string pattern); - std::string processKey(); - std::string casting(std::string key, std::any val); - public: - Entry(); //default ctor - Entry(std::shared_ptr& log, bool JSON ); //ctor with parameter - Entry& WithField(std::map& keyMap); - void info(std::string msg); - void trace(std::string msg); - void debug(std::string msg); - void warn(std::string msg); - void error(std::string msg); - void critical(std::string msg); - }; - Entry loggerEntry; - std::shared_ptr logger; - bool JSONstatus; // make this true to make log in JSON form / false in normal form - bool WriteFile; // make this true to write log into file -public: - //member - std::map custom_field; - //ctor - CustomLogger(std::string name, bool to_file); - //function - void OutputJSON(); - void OutputDefault(); - CustomLogger::Entry& WithField(std::map& keyMap); - std::string JSONformatter(); - //basic logging - void info(std::string msg); - void trace(std::string msg); - void debug(std::string msg); - void warn(std::string msg); - void error(std::string msg); - void critical(std::string msg); -}; diff --git a/spdlog_lib/spdlog/async.h b/spdlog_lib/spdlog/async.h deleted file mode 100644 index f70c4a3..0000000 --- a/spdlog_lib/spdlog/async.h +++ /dev/null @@ -1,87 +0,0 @@ - -// -// Copyright(c) 2018 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -// -// Async logging using global thread pool -// All loggers created here share same global thread pool. -// Each log message is pushed to a queue along withe a shared pointer to the -// logger. -// If a logger deleted while having pending messages in the queue, it's actual -// destruction will defer -// until all its messages are processed by the thread pool. -// This is because each message in the queue holds a shared_ptr to the -// originating logger. - -#include "spdlog/async_logger.h" -#include "spdlog/details/registry.h" -#include "spdlog/details/thread_pool.h" - -#include -#include - -namespace spdlog { - -namespace details { -static const size_t default_async_q_size = 8192; -} - -// async logger factory - creates async loggers backed with thread pool. -// if a global thread pool doesn't already exist, create it with default queue -// size of 8192 items and single thread. -template -struct async_factory_impl -{ - template - static std::shared_ptr create(const std::string &logger_name, SinkArgs &&... args) - { - auto ®istry_inst = details::registry::instance(); - - // create global thread pool if not already exists.. - std::lock_guard(registry_inst.tp_mutex()); - auto tp = registry_inst.get_tp(); - if (tp == nullptr) - { - tp = std::make_shared(details::default_async_q_size, 1); - registry_inst.set_tp(tp); - } - - auto sink = std::make_shared(std::forward(args)...); - auto new_logger = std::make_shared(logger_name, std::move(sink), std::move(tp), OverflowPolicy); - registry_inst.register_and_init(new_logger); - return new_logger; - } -}; - -using async_factory = async_factory_impl; -using async_factory_nonblock = async_factory_impl; - -template -inline std::shared_ptr create_async(const std::string &logger_name, SinkArgs &&... sink_args) -{ - return async_factory::create(logger_name, std::forward(sink_args)...); -} - -template -inline std::shared_ptr create_async_nb(const std::string &logger_name, SinkArgs &&... sink_args) -{ - return async_factory_nonblock::create(logger_name, std::forward(sink_args)...); -} - -// set global thread pool. -inline void init_thread_pool(size_t q_size, size_t thread_count) -{ - auto tp = std::make_shared(q_size, thread_count); - details::registry::instance().set_tp(std::move(tp)); -} - -// get the global thread pool. -inline std::shared_ptr thread_pool() -{ - return details::registry::instance().get_tp(); -} -} // namespace spdlog diff --git a/spdlog_lib/spdlog/async_logger.h b/spdlog_lib/spdlog/async_logger.h deleted file mode 100644 index 2d58f98..0000000 --- a/spdlog_lib/spdlog/async_logger.h +++ /dev/null @@ -1,71 +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 -#include -#include - -namespace spdlog { - -// Async overflow policy - block by default. -enum class async_overflow_policy -{ - block, // Block until message can be enqueued - overrun_oldest // Discard oldest message in the queue if full when trying to - // add new item. -}; - -namespace details { -class thread_pool; -} - -class async_logger SPDLOG_FINAL : public std::enable_shared_from_this, public logger -{ - friend class details::thread_pool; - -public: - template - async_logger(std::string logger_name, const It &begin, const It &end, std::weak_ptr tp, - async_overflow_policy overflow_policy = async_overflow_policy::block); - - async_logger(std::string logger_name, sinks_init_list sinks, std::weak_ptr tp, - async_overflow_policy overflow_policy = async_overflow_policy::block); - - async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, - async_overflow_policy overflow_policy = async_overflow_policy::block); - -protected: - void sink_it_(details::log_msg &msg) override; - void flush_() override; - - void backend_log_(details::log_msg &incoming_log_msg); - void backend_flush_(); - -private: - std::weak_ptr thread_pool_; - async_overflow_policy overflow_policy_; -}; -} // namespace spdlog - -#include "details/async_logger_impl.h" diff --git a/spdlog_lib/spdlog/common.h b/spdlog_lib/spdlog/common.h deleted file mode 100644 index b8d4517..0000000 --- a/spdlog_lib/spdlog/common.h +++ /dev/null @@ -1,183 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "spdlog/tweakme.h" - -#include -#include -#include -#include -#include -#include -#include -#include - -#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -#include -#include -#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 - -// final keyword support. On by default. See tweakme.h -#if defined(SPDLOG_NO_FINAL) -#define SPDLOG_FINAL -#else -#define SPDLOG_FINAL final -#endif - -#if defined(__GNUC__) || defined(__clang__) -#define SPDLOG_DEPRECATED __attribute__((deprecated)) -#elif defined(_MSC_VER) -#define SPDLOG_DEPRECATED __declspec(deprecated) -#else -#define SPDLOG_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; -using sinks_init_list = std::initializer_list; -using log_err_handler = std::function; - -#if defined(SPDLOG_NO_ATOMIC_LEVELS) -using level_t = details::null_atomic_int; -#else -using level_t = std::atomic; -#endif - -// Log level enum -namespace level { -enum level_enum -{ - trace = 0, - debug = 1, - info = 2, - warn = 3, - err = 4, - critical = 5, - off = 6 -}; - -#if !defined(SPDLOG_LEVEL_NAMES) -#define SPDLOG_LEVEL_NAMES \ - { \ - "trace", "debug", "info", "warning", "error", "critical", "off" \ - } -#endif -static const char *level_names[] SPDLOG_LEVEL_NAMES; - -static const char *short_level_names[]{"T", "D", "I", "W", "E", "C", "O"}; - -inline const char *to_c_str(spdlog::level::level_enum l) -{ - return level_names[l]; -} - -inline const char *to_short_c_str(spdlog::level::level_enum l) -{ - return short_level_names[l]; -} -inline spdlog::level::level_enum from_str(const std::string &name) -{ - static std::unordered_map name_to_level = // map string->level - {{level_names[0], level::trace}, // trace - {level_names[1], level::debug}, // debug - {level_names[2], level::info}, // info - {level_names[3], level::warn}, // warn - {level_names[4], level::err}, // err - {level_names[5], level::critical}, // critical - {level_names[6], level::off}}; // off - - auto lvl_it = name_to_level.find(name); - return lvl_it != name_to_level.end() ? lvl_it->second : level::off; -} - -using level_hasher = std::hash; -} // namespace level - -// -// Pattern time - specific time getting to use for pattern_formatter. -// local time by default -// -enum class pattern_time_type -{ - local, // log localtime - utc // log utc -}; - -// -// Log exception -// -class spdlog_ex : public std::runtime_error -{ -public: - explicit spdlog_ex(const std::string &msg) - : runtime_error(msg) - { - } - spdlog_ex(std::string msg, int last_errno) - : runtime_error(std::move(msg)) - , last_errno_(last_errno) - { - } - const char *what() const SPDLOG_NOEXCEPT override - { - if (last_errno_) - { - fmt::memory_buffer buf; - std::string msg(runtime_error::what()); - fmt::format_system_error(buf, last_errno_, msg); - return fmt::to_string(buf).c_str(); - } - else - { - return runtime_error::what(); - } - } - -private: - int last_errno_{0}; -}; - -// -// 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 - -#define SPDLOG_CATCH_AND_HANDLE \ - catch (const std::exception &ex) \ - { \ - err_handler_(ex.what()); \ - } \ - catch (...) \ - { \ - err_handler_("Unknown exeption in logger"); \ - } -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/async_logger_impl.h b/spdlog_lib/spdlog/details/async_logger_impl.h deleted file mode 100644 index a42ade9..0000000 --- a/spdlog_lib/spdlog/details/async_logger_impl.h +++ /dev/null @@ -1,100 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -// async logger implementation -// uses a thread pool to perform the actual logging - -#include "spdlog/details/thread_pool.h" - -#include -#include -#include - -template -inline spdlog::async_logger::async_logger( - std::string logger_name, const It &begin, const It &end, std::weak_ptr tp, async_overflow_policy overflow_policy) - : logger(std::move(logger_name), begin, end) - , thread_pool_(tp) - , overflow_policy_(overflow_policy) -{ -} - -inline spdlog::async_logger::async_logger( - std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, async_overflow_policy overflow_policy) - : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), tp, overflow_policy) -{ -} - -inline spdlog::async_logger::async_logger( - std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, async_overflow_policy overflow_policy) - : async_logger(std::move(logger_name), {single_sink}, tp, overflow_policy) -{ -} - -// send the log message to the thread pool -inline void spdlog::async_logger::sink_it_(details::log_msg &msg) -{ -#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER) - incr_msg_counter_(msg); -#endif - if (auto pool_ptr = thread_pool_.lock()) - { - pool_ptr->post_log(shared_from_this(), std::move(msg), overflow_policy_); - } - else - { - throw spdlog_ex("async log: thread pool doens't exist anymore"); - } -} - -// send flush request to the thread pool -inline void spdlog::async_logger::flush_() -{ - if (auto pool_ptr = thread_pool_.lock()) - { - pool_ptr->post_flush(shared_from_this(), overflow_policy_); - } - else - { - throw spdlog_ex("async flush: thread pool doesn't exist anymore"); - } -} - -// -// backend functions - called from the thread pool to do the actual job -// -inline void spdlog::async_logger::backend_log_(details::log_msg &incoming_log_msg) -{ - try - { - for (auto &s : sinks_) - { - if (s->should_log(incoming_log_msg.level)) - { - s->log(incoming_log_msg); - } - } - } - SPDLOG_CATCH_AND_HANDLE - - if (should_flush_(incoming_log_msg)) - { - backend_flush_(); - } -} - -inline void spdlog::async_logger::backend_flush_() -{ - try - { - for (auto &sink : sinks_) - { - sink->flush(); - } - } - SPDLOG_CATCH_AND_HANDLE -} diff --git a/spdlog_lib/spdlog/details/circular_q.h b/spdlog_lib/spdlog/details/circular_q.h deleted file mode 100644 index 48f9a8f..0000000 --- a/spdlog_lib/spdlog/details/circular_q.h +++ /dev/null @@ -1,62 +0,0 @@ -// -// Copyright(c) 2018 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -// cirucal q view of std::vector. -#pragma once - -namespace spdlog { -namespace details { -template -class circular_q -{ -public: - using item_type = T; - - explicit circular_q(size_t max_items) - : max_items_(max_items + 1) // one item is reserved as marker for full q - , v_(max_items_) - { - } - - // push back, overrun (oldest) item if no room left - void push_back(T &&item) - { - v_[tail_] = std::move(item); - tail_ = (tail_ + 1) % max_items_; - - if (tail_ == head_) // overrun last item if full - { - head_ = (head_ + 1) % max_items_; - } - } - - // Pop item from front. - // If there are no elements in the container, the behavior is undefined. - void pop_front(T &popped_item) - { - popped_item = std::move(v_[head_]); - head_ = (head_ + 1) % max_items_; - } - - bool empty() - { - return tail_ == head_; - } - - bool full() - { - // head is ahead of the tail by 1 - return ((tail_ + 1) % max_items_) == head_; - } - -private: - size_t max_items_; - typename std::vector::size_type head_ = 0; - typename std::vector::size_type tail_ = 0; - - std::vector v_; -}; -} // namespace details -} // namespace spdlog \ No newline at end of file diff --git a/spdlog_lib/spdlog/details/console_globals.h b/spdlog_lib/spdlog/details/console_globals.h deleted file mode 100644 index 52de06a..0000000 --- a/spdlog_lib/spdlog/details/console_globals.h +++ /dev/null @@ -1,61 +0,0 @@ -#pragma once -// -// Copyright(c) 2018 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#include "spdlog/details/null_mutex.h" -#include "stdio.h" -#include - -namespace spdlog { -namespace details { -struct console_stdout -{ - static FILE *stream() - { - return stdout; - } -#ifdef _WIN32 - static HANDLE handle() - { - return ::GetStdHandle(STD_OUTPUT_HANDLE); - } -#endif -}; - -struct console_stderr -{ - static FILE *stream() - { - return stderr; - } -#ifdef _WIN32 - static HANDLE handle() - { - return ::GetStdHandle(STD_ERROR_HANDLE); - } -#endif -}; - -struct console_mutex -{ - using mutex_t = std::mutex; - static mutex_t &mutex() - { - static mutex_t s_mutex; - return s_mutex; - } -}; - -struct console_nullmutex -{ - using mutex_t = null_mutex; - static mutex_t &mutex() - { - static mutex_t s_mutex; - return s_mutex; - } -}; -} // namespace details -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/file_helper.h b/spdlog_lib/spdlog/details/file_helper.h deleted file mode 100644 index ef70d56..0000000 --- a/spdlog_lib/spdlog/details/file_helper.h +++ /dev/null @@ -1,153 +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) -// Throw spdlog_ex exception on errors - -#include "../details/log_msg.h" -#include "../details/os.h" - -#include -#include -#include -#include -#include -#include - -namespace spdlog { -namespace details { - -class file_helper -{ - -public: - const int open_tries = 5; - const int open_interval = 10; - - explicit file_helper() = default; - - 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; - } - - details::os::sleep_for_millis(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_ != nullptr) - { - std::fclose(fd_); - fd_ = nullptr; - } - } - - void write(const fmt::memory_buffer &buf) - { - size_t msg_size = buf.size(); - auto data = buf.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() const - { - if (fd_ == nullptr) - { - 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 &fname) - { - return os::file_exists(fname); - } - - // - // return file path and its extension: - // - // "mylog.txt" => ("mylog", ".txt") - // "mylog" => ("mylog", "") - // "mylog." => ("mylog.", "") - // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") - // - // the starting dot in filenames is ignored (hidden files): - // - // ".mylog" => (".mylog". "") - // "my_folder/.mylog" => ("my_folder/.mylog", "") - // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") - static std::tuple split_by_extenstion(const spdlog::filename_t &fname) - { - auto ext_index = fname.rfind('.'); - - // no valid extension found - return whole path and empty string as - // extension - if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) - { - return std::make_tuple(fname, spdlog::filename_t()); - } - - // treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile" - auto folder_index = fname.rfind(details::os::folder_sep); - if (folder_index != fname.npos && folder_index >= ext_index - 1) - { - return std::make_tuple(fname, spdlog::filename_t()); - } - - // finally - return a valid base and extension tuple - return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); - } - -private: - FILE *fd_{nullptr}; - filename_t _filename; -}; -} // namespace details -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/fmt_helper.h b/spdlog_lib/spdlog/details/fmt_helper.h deleted file mode 100644 index 0f67053..0000000 --- a/spdlog_lib/spdlog/details/fmt_helper.h +++ /dev/null @@ -1,130 +0,0 @@ -// -// Created by gabi on 6/15/18. -// - -#pragma once - -#include "chrono" -#include "spdlog/fmt/fmt.h" - -// Some fmt helpers to efficiently format and pad ints and strings -namespace spdlog { -namespace details { -namespace fmt_helper { - -template -inline void append_str(const std::string &str, fmt::basic_memory_buffer &dest) -{ - auto *str_ptr = str.data(); - dest.append(str_ptr, str_ptr + str.size()); -} - -template -inline void append_c_str(const char *c_str, fmt::basic_memory_buffer &dest) -{ - char ch; - while ((ch = *c_str) != '\0') - { - dest.push_back(ch); - ++c_str; - } -} - -template -inline void append_buf(const fmt::basic_memory_buffer &buf, fmt::basic_memory_buffer &dest) -{ - auto *buf_ptr = buf.data(); - dest.append(buf_ptr, buf_ptr + buf.size()); -} - -template -inline void append_int(T n, fmt::basic_memory_buffer &dest) -{ - fmt::format_int i(n); - dest.append(i.data(), i.data() + i.size()); -} - -template -inline void pad2(int n, fmt::basic_memory_buffer &dest) -{ - if (n > 99) - { - append_int(n, dest); - return; - } - if (n > 9) // 10-99 - { - dest.push_back('0' + static_cast(n / 10)); - dest.push_back('0' + static_cast(n % 10)); - return; - } - if (n >= 0) // 0-9 - { - dest.push_back('0'); - dest.push_back('0' + static_cast(n)); - return; - } - // negatives (unlikely, but just in case, let fmt deal with it) - fmt::format_to(dest, "{:02}", n); -} - -template -inline void pad3(int n, fmt::basic_memory_buffer &dest) -{ - if (n > 999) - { - append_int(n, dest); - return; - } - - if (n > 99) // 100-999 - { - append_int(n / 100, dest); - pad2(n % 100, dest); - return; - } - if (n > 9) // 10-99 - { - dest.push_back('0'); - dest.push_back('0' + static_cast(n / 10)); - dest.push_back('0' + static_cast(n % 10)); - return; - } - if (n >= 0) - { - dest.push_back('0'); - dest.push_back('0'); - dest.push_back('0' + static_cast(n)); - return; - } - // negatives (unlikely, but just in case let fmt deal with it) - fmt::format_to(dest, "{:03}", n); -} - -template -inline void pad6(size_t n, fmt::basic_memory_buffer &dest) -{ - if (n > 99999) - { - append_int(n, dest); - return; - } - pad3(static_cast(n / 1000), dest); - pad3(static_cast(n % 1000), dest); -} - -// return fraction of a second of the given time_point. -// e.g. -// fraction(tp) -> will return the millis part of the second -template -inline ToDuration time_fraction(const log_clock::time_point &tp) -{ - using namespace std::chrono; - auto duration = tp.time_since_epoch(); - auto secs = duration_cast(duration); - return duration_cast(duration) - duration_cast(secs); -} - -} // namespace fmt_helper -} // namespace details -} // namespace spdlog \ No newline at end of file diff --git a/spdlog_lib/spdlog/details/log_msg.h b/spdlog_lib/spdlog/details/log_msg.h deleted file mode 100644 index ce988e4..0000000 --- a/spdlog_lib/spdlog/details/log_msg.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/common.h" -#include "spdlog/details/os.h" - -#include -#include - -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(log_msg &&other) = delete; - log_msg &operator=(log_msg &&other) = delete; - - const std::string *logger_name{nullptr}; - level::level_enum level; - log_clock::time_point time; - size_t thread_id; - fmt::memory_buffer raw; - size_t msg_id{0}; - // info about wrapping the formatted text with color - mutable size_t color_range_start{0}; - mutable size_t color_range_end{0}; -}; -} // namespace details -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/logger_impl.h b/spdlog_lib/spdlog/details/logger_impl.h deleted file mode 100644 index 0a7c5b6..0000000 --- a/spdlog_lib/spdlog/details/logger_impl.h +++ /dev/null @@ -1,345 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include -#include - -// create logger with given name, sinks and the default pattern formatter -// all other ctors will call this one -template -inline spdlog::logger::logger(std::string logger_name, const It &begin, const It &end) - : name_(std::move(logger_name)) - , sinks_(begin, end) - , level_(level::info) - , flush_level_(level::off) - , last_err_time_(0) - , msg_counter_(1) // message counter will start from 1. 0-message id will be - // reserved for controll messages -{ - err_handler_ = [this](const std::string &msg) { this->default_err_handler_(msg); }; -} - -// ctor with sinks as init list -inline spdlog::logger::logger(std::string logger_name, sinks_init_list sinks_list) - : logger(std::move(logger_name), sinks_list.begin(), sinks_list.end()) -{ -} - -// ctor with single sink -inline spdlog::logger::logger(std::string logger_name, spdlog::sink_ptr single_sink) - : logger(std::move(logger_name), {std::move(single_sink)}) -{ -} - -inline spdlog::logger::~logger() = default; - -inline void spdlog::logger::set_formatter(std::unique_ptr f) -{ - for (auto &sink : sinks_) - { - sink->set_formatter(f->clone()); - } -} - -inline void spdlog::logger::set_pattern(std::string pattern, pattern_time_type time_type) -{ - set_formatter(std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); -} - -template -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); - fmt::format_to(log_msg.raw, fmt, args...); - sink_it_(log_msg); - } - SPDLOG_CATCH_AND_HANDLE -} - -template -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); - fmt::format_to(log_msg.raw, "{}", msg); - sink_it_(log_msg); - } - SPDLOG_CATCH_AND_HANDLE -} - -template -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); - fmt::format_to(log_msg.raw, "{}", msg); - sink_it_(log_msg); - } - SPDLOG_CATCH_AND_HANDLE -} - -template -inline void spdlog::logger::trace(const char *fmt, const Args &... args) -{ - log(level::trace, fmt, args...); -} - -template -inline void spdlog::logger::debug(const char *fmt, const Args &... args) -{ - log(level::debug, fmt, args...); -} - -template -inline void spdlog::logger::info(const char *fmt, const Args &... args) -{ - log(level::info, fmt, args...); -} - -template -inline void spdlog::logger::warn(const char *fmt, const Args &... args) -{ - log(level::warn, fmt, args...); -} - -template -inline void spdlog::logger::error(const char *fmt, const Args &... args) -{ - log(level::err, fmt, args...); -} - -template -inline void spdlog::logger::critical(const char *fmt, const Args &... args) -{ - log(level::critical, fmt, args...); -} - -template -inline void spdlog::logger::trace(const T &msg) -{ - log(level::trace, msg); -} - -template -inline void spdlog::logger::debug(const T &msg) -{ - log(level::debug, msg); -} - -template -inline void spdlog::logger::info(const T &msg) -{ - log(level::info, msg); -} - -template -inline void spdlog::logger::warn(const T &msg) -{ - log(level::warn, msg); -} - -template -inline void spdlog::logger::error(const T &msg) -{ - log(level::err, msg); -} - -template -inline void spdlog::logger::critical(const T &msg) -{ - log(level::critical, msg); -} - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT -template -inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args) -{ - if (!should_log(lvl)) - { - return; - } - - decltype(wstring_converter_)::byte_string utf8_string; - - try - { - { - std::lock_guard lock(wstring_converter_mutex_); - utf8_string = wstring_converter_.to_bytes(fmt); - } - log(lvl, utf8_string.c_str(), args...); - } - SPDLOG_CATCH_AND_HANDLE -} - -template -inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args) -{ - log(level::trace, fmt, args...); -} - -template -inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args) -{ - log(level::debug, fmt, args...); -} - -template -inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args) -{ - log(level::info, fmt, args...); -} - -template -inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args) -{ - log(level::warn, fmt, args...); -} - -template -inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args) -{ - log(level::err, fmt, args...); -} - -template -inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args) -{ - log(level::critical, fmt, args...); -} - -#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT - -// -// 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_ = std::move(err_handler); -} - -inline spdlog::log_err_handler spdlog::logger::error_handler() -{ - return err_handler_; -} - -inline void spdlog::logger::flush() -{ - try - { - flush_(); - } - SPDLOG_CATCH_AND_HANDLE -} - -inline void spdlog::logger::flush_on(level::level_enum log_level) -{ - flush_level_.store(log_level); -} - -inline bool spdlog::logger::should_flush_(const details::log_msg &msg) -{ - auto flush_level = flush_level_.load(std::memory_order_relaxed); - return (msg.level >= flush_level) && (msg.level != level::off); -} - -inline spdlog::level::level_enum spdlog::logger::level() const -{ - return static_cast(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) -{ -#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER) - incr_msg_counter_(msg); -#endif - for (auto &sink : sinks_) - { - if (sink->should_log(msg.level)) - { - sink->log(msg); - } - } - - if (should_flush_(msg)) - { - flush(); - } -} - -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; - } - last_err_time_ = now; - 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); - fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg); -} - -inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg) -{ - msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed); -} - -inline const std::vector &spdlog::logger::sinks() const -{ - return sinks_; -} - -inline std::vector &spdlog::logger::sinks() -{ - return sinks_; -} diff --git a/spdlog_lib/spdlog/details/mpmc_blocking_q.h b/spdlog_lib/spdlog/details/mpmc_blocking_q.h deleted file mode 100644 index d607da2..0000000 --- a/spdlog_lib/spdlog/details/mpmc_blocking_q.h +++ /dev/null @@ -1,115 +0,0 @@ -#pragma once - -// -// Copyright(c) 2018 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -// multi producer-multi consumer blocking queue. -// enqueue(..) - will block until room found to put the new message. -// enqueue_nowait(..) - will return immediately with false if no room left in -// the queue. -// dequeue_for(..) - will block until the queue is not empty or timeout have -// passed. - -#include "spdlog/details/circular_q.h" - -#include -#include - -namespace spdlog { -namespace details { - -template -class mpmc_blocking_queue -{ -public: - using item_type = T; - explicit mpmc_blocking_queue(size_t max_items) - : q_(max_items) - { - } - -#ifndef __MINGW32__ - // try to enqueue and block if no room left - void enqueue(T &&item) - { - { - std::unique_lock lock(queue_mutex_); - pop_cv_.wait(lock, [this] { return !this->q_.full(); }); - q_.push_back(std::move(item)); - } - push_cv_.notify_one(); - } - - // enqueue immediately. overrun oldest message in the queue if no room left. - void enqueue_nowait(T &&item) - { - { - std::unique_lock lock(queue_mutex_); - q_.push_back(std::move(item)); - } - push_cv_.notify_one(); - } - - // try to dequeue item. if no item found. wait upto timeout and try again - // Return true, if succeeded dequeue item, false otherwise - bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) - { - { - std::unique_lock lock(queue_mutex_); - if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) - { - return false; - } - q_.pop_front(popped_item); - } - pop_cv_.notify_one(); - return true; - } - -#else - // apparently mingw deadlocks if the mutex is released before cv.notify_one(), - // so release the mutex at the very end each function. - - // try to enqueue and block if no room left - void enqueue(T &&item) - { - std::unique_lock lock(queue_mutex_); - pop_cv_.wait(lock, [this] { return !this->q_.full(); }); - q_.push_back(std::move(item)); - push_cv_.notify_one(); - } - - // enqueue immediately. overrun oldest message in the queue if no room left. - void enqueue_nowait(T &&item) - { - std::unique_lock lock(queue_mutex_); - q_.push_back(std::move(item)); - push_cv_.notify_one(); - } - - // try to dequeue item. if no item found. wait upto timeout and try again - // Return true, if succeeded dequeue item, false otherwise - bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) - { - std::unique_lock lock(queue_mutex_); - if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) - { - return false; - } - q_.pop_front(popped_item); - pop_cv_.notify_one(); - return true; - } - -#endif - -private: - std::mutex queue_mutex_; - std::condition_variable push_cv_; - std::condition_variable pop_cv_; - spdlog::details::circular_q q_; -}; -} // namespace details -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/null_mutex.h b/spdlog_lib/spdlog/details/null_mutex.h deleted file mode 100644 index 3f495bd..0000000 --- a/spdlog_lib/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 -// 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; - - explicit null_atomic_int(int val) - : value(val) - { - } - - int load(std::memory_order) const - { - return value; - } - - void store(int val) - { - value = val; - } -}; - -} // namespace details -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/os.h b/spdlog_lib/spdlog/details/os.h deleted file mode 100644 index d7f7430..0000000 --- a/spdlog_lib/spdlog/details/os.h +++ /dev/null @@ -1,432 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// -#pragma once - -#include "../common.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifdef _WIN32 - -#ifndef NOMINMAX -#define NOMINMAX // prevent windows redefining min/max -#endif - -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#endif -#include // _get_osfhandle and _isatty support -#include // _get_pid support -#include - -#ifdef __MINGW32__ -#include -#endif - -#else // unix - -#include -#include - -#ifdef __linux__ -#include //Use gettid() syscall under linux to get thread id - -#elif __FreeBSD__ -#include //Use thr_self() syscall under FreeBSD to get thread id -#endif - -#endif // unix - -#ifndef __has_feature // Clang - feature checking macros. -#define __has_feature(x) 0 // Compatibility with non-clang compilers. -#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( - std::chrono::duration_cast(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 *default_eol = SPDLOG_EOL; - -// folder separator -#ifdef _WIN32 -SPDLOG_CONSTEXPR static const char folder_sep = '\\'; -#else -SPDLOG_CONSTEXPR static const char folder_sep = '/'; -#endif - -inline void prevent_child_fd(FILE *f) -{ - -#ifdef _WIN32 -#if !defined(__cplusplus_winrt) - auto file_handle = (HANDLE)_get_osfhandle(_fileno(f)); - if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) - throw spdlog_ex("SetHandleInformation failed", errno); -#endif -#else - auto fd = fileno(f); - if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) - { - throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno); - } -#endif -} - -// fopen_s on non windows for writing -inline bool 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 -#else // unix - *fp = fopen((filename.c_str()), mode.c_str()); -#endif - -#ifdef SPDLOG_PREVENT_CHILD_FD - if (*fp != nullptr) - { - prevent_child_fd(*fp); - } -#endif - return *fp == nullptr; -} - -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"); - } -#if defined(_WIN32) && !defined(__CYGWIN__) - 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(ret); - } -#endif - -#else // unix - int fd = fileno(f); -// 64 bits(but not in osx or cygwin, where fstat64 is deprecated) -#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__) - struct stat64 st; - if (fstat64(fd, &st) == 0) - { - return static_cast(st.st_size); - } -#else // unix 32 bits or cygwin - struct stat st; - - if (fstat(fd, &st) == 0) - { - return static_cast(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) || defined(_AIX) - // '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; - } - }; - - auto offset_seconds = helper::calculate_gmt_offset(tm); -#else - auto offset_seconds = tm.tm_gmtoff; -#endif - - return static_cast(offset_seconds / 60); -#endif -} - -// Return current thread id as size_t -// It exists because the std::this_thread::get_id() is much slower(especially -// under VS 2013) -inline size_t _thread_id() -{ -#ifdef _WIN32 - return static_cast(::GetCurrentThreadId()); -#elif __linux__ -#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) -#define SYS_gettid __NR_gettid -#endif - return static_cast(syscall(SYS_gettid)); -#elif __FreeBSD__ - long tid; - thr_self(&tid); - return static_cast(tid); -#elif __APPLE__ - uint64_t tid; - pthread_threadid_np(nullptr, &tid); - return static_cast(tid); -#else // Default to standard C++11 (other Unix) - return static_cast(std::hash()(std::this_thread::get_id())); -#endif -} - -// Return current thread id as size_t (from thread local storage) -inline size_t thread_id() -{ -#if defined(SPDLOG_DISABLE_TID_CACHING) || (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) || \ - (defined(__clang__) && !__has_feature(cxx_thread_local)) - return _thread_id(); -#else // cache thread id in tls - static thread_local const size_t tid = _thread_id(); - return tid; -#endif -} - -// This is avoid msvc issue in sleep_for that happens if the clock changes. -// See https://github.com/gabime/spdlog/issues/609 -inline void sleep_for_millis(int milliseconds) -{ -#if defined(_WIN32) - ::Sleep(milliseconds); -#else - std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); -#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, 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 - -inline int pid() -{ - -#ifdef _WIN32 - return static_cast(::GetCurrentProcessId()); -#else - return static_cast(::getpid()); -#endif -} - -// Determine if the terminal supports colors -// Source: https://github.com/agauniyal/rang/ -inline bool is_color_terminal() -{ -#ifdef _WIN32 - return true; -#else - static constexpr const char *Terms[] = { - "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"}; - - const char *env_p = std::getenv("TERM"); - if (env_p == nullptr) - { - return false; - } - - static const bool result = - std::any_of(std::begin(Terms), std::end(Terms), [&](const char *term) { return std::strstr(env_p, term) != nullptr; }); - return result; -#endif -} - -// Detrmine if the terminal attached -// Source: https://github.com/agauniyal/rang/ -inline bool in_terminal(FILE *file) -{ - -#ifdef _WIN32 - return _isatty(_fileno(file)) != 0; -#else - return isatty(fileno(file)) != 0; -#endif -} -} // namespace os -} // namespace details -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/pattern_formatter.h b/spdlog_lib/spdlog/details/pattern_formatter.h deleted file mode 100644 index 765f930..0000000 --- a/spdlog_lib/spdlog/details/pattern_formatter.h +++ /dev/null @@ -1,772 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "spdlog/details/fmt_helper.h" -#include "spdlog/details/log_msg.h" -#include "spdlog/details/os.h" -#include "spdlog/fmt/fmt.h" -#include "spdlog/formatter.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace spdlog { -namespace details { - -class flag_formatter -{ -public: - virtual ~flag_formatter() = default; - virtual void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) = 0; -}; - -/////////////////////////////////////////////////////////////////////// -// name & level pattern appenders -/////////////////////////////////////////////////////////////////////// -class name_formatter : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - fmt_helper::append_str(*msg.logger_name, dest); - } -}; - -// log level appender -class level_formatter : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - fmt_helper::append_c_str(level::to_c_str(msg.level), dest); - } -}; - -// short log level appender -class short_level_formatter : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - fmt_helper::append_c_str(level::to_short_c_str(msg.level), dest); - } -}; - -/////////////////////////////////////////////////////////////////////// -// Date time pattern appenders -/////////////////////////////////////////////////////////////////////// - -static const char *ampm(const tm &t) -{ - return t.tm_hour >= 12 ? "PM" : "AM"; -} - -static unsigned int to12h(const tm &t) -{ - return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; -} - -// Abbreviated weekday name -static const char *days[]{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; -class a_formatter : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::append_c_str(days[tm_time.tm_wday], dest); - } -}; - -// Full weekday name -static const char *full_days[]{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; -class A_formatter : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::append_c_str(full_days[tm_time.tm_wday], dest); - } -}; - -// Abbreviated month -static const char *months[]{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}; -class b_formatter : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::append_c_str(months[tm_time.tm_mon], dest); - } -}; - -// Full month name -static const char *full_months[]{ - "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; -class B_formatter : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::append_c_str(full_months[tm_time.tm_mon], dest); - } -}; - -// Date and time representation (Thu Aug 23 15:35:46 2014) -class c_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - // fmt::format_to(dest, "{} {} {} ", days[tm_time.tm_wday], - // months[tm_time.tm_mon], tm_time.tm_mday); - // date - fmt_helper::append_str(days[tm_time.tm_wday], dest); - dest.push_back(' '); - fmt_helper::append_str(months[tm_time.tm_mon], dest); - dest.push_back(' '); - fmt_helper::append_int(tm_time.tm_mday, dest); - dest.push_back(' '); - // time - - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - dest.push_back(' '); - fmt_helper::append_int(tm_time.tm_year + 1900, dest); - } -}; - -// year - 2 digit -class C_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(tm_time.tm_year % 100, dest); - } -}; - -// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01 -class D_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(tm_time.tm_mon + 1, dest); - dest.push_back('/'); - fmt_helper::pad2(tm_time.tm_mday, dest); - dest.push_back('/'); - fmt_helper::pad2(tm_time.tm_year % 100, dest); - } -}; - -// year - 4 digit -class Y_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::append_int(tm_time.tm_year + 1900, dest); - } -}; - -// month 1-12 -class m_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(tm_time.tm_mon + 1, dest); - } -}; - -// day of month 1-31 -class d_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(tm_time.tm_mday, dest); - } -}; - -// hours in 24 format 0-23 -class H_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(tm_time.tm_hour, dest); - } -}; - -// hours in 12 format 1-12 -class I_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(to12h(tm_time), dest); - } -}; - -// minutes 0-59 -class M_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(tm_time.tm_min, dest); - } -}; - -// seconds 0-59 -class S_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(tm_time.tm_sec, dest); - } -}; - -// milliseconds -class e_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - auto millis = fmt_helper::time_fraction(msg.time); - fmt_helper::pad3(static_cast(millis.count()), dest); - } -}; - -// microseconds -class f_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - auto micros = fmt_helper::time_fraction(msg.time); - fmt_helper::pad6(static_cast(micros.count()), dest); - } -}; - -// nanoseconds -class F_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - auto ns = fmt_helper::time_fraction(msg.time); - fmt::format_to(dest, "{:09}", ns.count()); - } -}; - -// seconds since epoch -class E_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - auto duration = msg.time.time_since_epoch(); - auto seconds = std::chrono::duration_cast(duration).count(); - fmt_helper::append_int(seconds, dest); - } -}; - -// AM/PM -class p_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::append_c_str(ampm(tm_time), dest); - } -}; - -// 12 hour clock 02:55:02 pm -class r_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(to12h(tm_time), dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - dest.push_back(' '); - fmt_helper::append_c_str(ampm(tm_time), dest); - } -}; - -// 24-hour HH:MM time, equivalent to %H:%M -class R_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - } -}; - -// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S -class T_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - // fmt::format_to(dest, "{:02}:{:02}:{:02}", tm_time.tm_hour, - // tm_time.tm_min, tm_time.tm_sec); - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - } -}; - -// ISO 8601 offset from UTC in timezone (+-HH:MM) -class z_formatter SPDLOG_FINAL : public flag_formatter -{ -public: - const std::chrono::seconds cache_refresh = std::chrono::seconds(5); - - z_formatter() = default; - z_formatter(const z_formatter &) = delete; - z_formatter &operator=(const z_formatter &) = delete; - - void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) 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) - (void)(msg); - int total_minutes = os::utc_minutes_offset(tm_time); -#endif - bool is_negative = total_minutes < 0; - if (is_negative) - { - total_minutes = -total_minutes; - dest.push_back('-'); - } - else - { - dest.push_back('+'); - } - - fmt_helper::pad2(total_minutes / 60, dest); // hours - dest.push_back(':'); - fmt_helper::pad2(total_minutes % 60, dest); // minutes - } - -private: - log_clock::time_point last_update_{std::chrono::seconds(0)}; -#ifdef _WIN32 - int offset_minutes_{0}; - - int get_cached_offset(const log_msg &msg, const std::tm &tm_time) - { - if (msg.time - last_update_ >= cache_refresh) - { - offset_minutes_ = os::utc_minutes_offset(tm_time); - last_update_ = msg.time; - } - return offset_minutes_; - } -#endif -}; - -// Thread id -class t_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - fmt_helper::pad6(msg.thread_id, dest); - } -}; - -// Current pid -class pid_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override - { - fmt_helper::append_int(details::os::pid(), dest); - } -}; - -// message counter formatter -class i_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - fmt_helper::pad6(msg.msg_id, dest); - } -}; - -class v_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - fmt_helper::append_buf(msg.raw, dest); - } -}; - -class ch_formatter SPDLOG_FINAL : public flag_formatter -{ -public: - explicit ch_formatter(char ch) - : ch_(ch) - { - } - void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override - { - dest.push_back(ch_); - } - -private: - char ch_; -}; - -// aggregate user chars to display as is -class aggregate_formatter SPDLOG_FINAL : public flag_formatter -{ -public: - aggregate_formatter() = default; - - void add_ch(char ch) - { - str_ += ch; - } - void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override - { - fmt_helper::append_str(str_, dest); - } - -private: - std::string str_; -}; - -// mark the color range. expect it to be in the form of "%^colored text%$" -class color_start_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - msg.color_range_start = dest.size(); - } -}; -class color_stop_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override - { - msg.color_range_end = dest.size(); - } -}; - -// Full info formatter -// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v -class full_formatter SPDLOG_FINAL : public flag_formatter -{ - void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override - { - using namespace std::chrono; -#ifndef SPDLOG_NO_DATETIME - - // cache the date/time part for the next second. - auto duration = msg.time.time_since_epoch(); - auto secs = duration_cast(duration); - - if (cache_timestamp_ != secs || cached_datetime_.size() == 0) - { - cached_datetime_.resize(0); - cached_datetime_.push_back('['); - fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_); - cached_datetime_.push_back('-'); - - fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_); - cached_datetime_.push_back('-'); - - fmt_helper::pad2(tm_time.tm_mday, cached_datetime_); - cached_datetime_.push_back(' '); - - fmt_helper::pad2(tm_time.tm_hour, cached_datetime_); - cached_datetime_.push_back(':'); - - fmt_helper::pad2(tm_time.tm_min, cached_datetime_); - cached_datetime_.push_back(':'); - - fmt_helper::pad2(tm_time.tm_sec, cached_datetime_); - cached_datetime_.push_back('.'); - - cache_timestamp_ = secs; - } - fmt_helper::append_buf(cached_datetime_, dest); - - auto millis = fmt_helper::time_fraction(msg.time); - fmt_helper::pad3(static_cast(millis.count()), dest); - dest.push_back(']'); - dest.push_back(' '); - -#else // no datetime needed - (void)tm_time; -#endif - -#ifndef SPDLOG_NO_NAME - dest.push_back('['); - fmt_helper::append_str(*msg.logger_name, dest); - dest.push_back(']'); - dest.push_back(' '); -#endif - - dest.push_back('['); - // wrap the level name with color - msg.color_range_start = dest.size(); - fmt_helper::append_c_str(level::to_c_str(msg.level), dest); - msg.color_range_end = dest.size(); - dest.push_back(']'); - dest.push_back(' '); - fmt_helper::append_buf(msg.raw, dest); - } - -private: - std::chrono::seconds cache_timestamp_{0}; - fmt::basic_memory_buffer cached_datetime_; -}; - -} // namespace details - -class pattern_formatter SPDLOG_FINAL : public formatter -{ -public: - explicit pattern_formatter( - std::string pattern, pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol) - : pattern_(std::move(pattern)) - , eol_(std::move(eol)) - , pattern_time_type_(time_type) - , last_log_secs_(0) - { - std::memset(&cached_tm_, 0, sizeof(cached_tm_)); - compile_pattern_(pattern_); - } - - pattern_formatter(const pattern_formatter &other) = delete; - pattern_formatter &operator=(const pattern_formatter &other) = delete; - - virtual std::unique_ptr clone() const override - { - return std::unique_ptr(new pattern_formatter(pattern_, pattern_time_type_, eol_)); - } - - void format(const details::log_msg &msg, fmt::memory_buffer &dest) override - { -#ifndef SPDLOG_NO_DATETIME - auto secs = std::chrono::duration_cast(msg.time.time_since_epoch()); - if (secs != last_log_secs_) - { - cached_tm_ = get_time_(msg); - last_log_secs_ = secs; - } -#endif - for (auto &f : formatters_) - { - f->format(msg, cached_tm_, dest); - } - // write eol - details::fmt_helper::append_str(eol_, dest); - } - -private: - std::string pattern_; - std::string eol_; - pattern_time_type pattern_time_type_; - std::tm cached_tm_; - std::chrono::seconds last_log_secs_; - - std::vector> formatters_; - - std::tm get_time_(const details::log_msg &msg) - { - if (pattern_time_type_ == pattern_time_type::local) - { - return details::os::localtime(log_clock::to_time_t(msg.time)); - } - return details::os::gmtime(log_clock::to_time_t(msg.time)); - } - - void handle_flag_(char flag) - { - switch (flag) - { - // logger name - case 'n': - formatters_.emplace_back(new details::name_formatter()); - break; - - case 'l': - formatters_.emplace_back(new details::level_formatter()); - break; - - case 'L': - formatters_.emplace_back(new details::short_level_formatter()); - break; - - case ('t'): - formatters_.emplace_back(new details::t_formatter()); - break; - - case ('v'): - formatters_.emplace_back(new details::v_formatter()); - break; - - case ('a'): - formatters_.emplace_back(new details::a_formatter()); - break; - - case ('A'): - formatters_.emplace_back(new details::A_formatter()); - break; - - case ('b'): - case ('h'): - formatters_.emplace_back(new details::b_formatter()); - break; - - case ('B'): - formatters_.emplace_back(new details::B_formatter()); - break; - case ('c'): - formatters_.emplace_back(new details::c_formatter()); - break; - - case ('C'): - formatters_.emplace_back(new details::C_formatter()); - break; - - case ('Y'): - formatters_.emplace_back(new details::Y_formatter()); - break; - - case ('D'): - case ('x'): - formatters_.emplace_back(new details::D_formatter()); - break; - - case ('m'): - formatters_.emplace_back(new details::m_formatter()); - break; - - case ('d'): - formatters_.emplace_back(new details::d_formatter()); - break; - - case ('H'): - formatters_.emplace_back(new details::H_formatter()); - break; - - case ('I'): - formatters_.emplace_back(new details::I_formatter()); - break; - - case ('M'): - formatters_.emplace_back(new details::M_formatter()); - break; - - case ('S'): - formatters_.emplace_back(new details::S_formatter()); - break; - - case ('e'): - formatters_.emplace_back(new details::e_formatter()); - break; - - case ('f'): - formatters_.emplace_back(new details::f_formatter()); - break; - case ('F'): - formatters_.emplace_back(new details::F_formatter()); - break; - - case ('E'): - formatters_.emplace_back(new details::E_formatter()); - break; - - case ('p'): - formatters_.emplace_back(new details::p_formatter()); - break; - - case ('r'): - formatters_.emplace_back(new details::r_formatter()); - break; - - case ('R'): - formatters_.emplace_back(new details::R_formatter()); - break; - - case ('T'): - case ('X'): - formatters_.emplace_back(new details::T_formatter()); - break; - - case ('z'): - formatters_.emplace_back(new details::z_formatter()); - break; - - case ('+'): - formatters_.emplace_back(new details::full_formatter()); - break; - - case ('P'): - formatters_.emplace_back(new details::pid_formatter()); - break; - - case ('i'): - formatters_.emplace_back(new details::i_formatter()); - break; - - case ('^'): - formatters_.emplace_back(new details::color_start_formatter()); - break; - - case ('$'): - formatters_.emplace_back(new details::color_stop_formatter()); - break; - - default: // Unknown flag appears as is - formatters_.emplace_back(new details::ch_formatter('%')); - formatters_.emplace_back(new details::ch_formatter(flag)); - break; - } - } - - void compile_pattern_(const std::string &pattern) - { - auto end = pattern.end(); - std::unique_ptr user_chars; - formatters_.clear(); - 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( - 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(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)); - } - } -}; -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/periodic_worker.h b/spdlog_lib/spdlog/details/periodic_worker.h deleted file mode 100644 index acc1311..0000000 --- a/spdlog_lib/spdlog/details/periodic_worker.h +++ /dev/null @@ -1,71 +0,0 @@ - -// -// Copyright(c) 2018 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -// periodic worker thread - periodically executes the given callback function. -// -// RAII over the owned thread: -// creates the thread on construction. -// stops and joins the thread on destruction. - -#include -#include -#include -#include -#include -namespace spdlog { -namespace details { - -class periodic_worker -{ -public: - periodic_worker(std::function callback_fun, std::chrono::seconds interval) - { - active_ = (interval > std::chrono::seconds::zero()); - if (!active_) - { - return; - } - - worker_thread_ = std::thread([this, callback_fun, interval]() { - for (;;) - { - std::unique_lock lock(this->mutex_); - if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) - { - return; // active_ == false, so exit this thread - } - callback_fun(); - } - }); - } - - periodic_worker(const periodic_worker &) = delete; - periodic_worker &operator=(const periodic_worker &) = delete; - - // stop the worker thread and join it - ~periodic_worker() - { - if (worker_thread_.joinable()) - { - { - std::lock_guard lock(mutex_); - active_ = false; - } - cv_.notify_one(); - worker_thread_.join(); - } - } - -private: - bool active_; - std::thread worker_thread_; - std::mutex mutex_; - std::condition_variable cv_; -}; -} // namespace details -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/registry.h b/spdlog_lib/spdlog/details/registry.h deleted file mode 100644 index b3db19a..0000000 --- a/spdlog_lib/spdlog/details/registry.h +++ /dev/null @@ -1,218 +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/common.h" -#include "spdlog/details/periodic_worker.h" -#include "spdlog/logger.h" - -#include -#include -#include -#include -#include - -namespace spdlog { -namespace details { -class thread_pool; - -class registry -{ -public: - registry(const registry &) = delete; - registry &operator=(const registry &) = delete; - - void register_logger(std::shared_ptr new_logger) - { - std::lock_guard lock(logger_map_mutex_); - auto logger_name = new_logger->name(); - throw_if_exists_(logger_name); - loggers_[logger_name] = new_logger; - } - - void register_and_init(std::shared_ptr new_logger) - { - std::lock_guard lock(logger_map_mutex_); - auto logger_name = new_logger->name(); - throw_if_exists_(logger_name); - - // set the global formatter pattern - new_logger->set_formatter(formatter_->clone()); - - if (err_handler_) - { - new_logger->set_error_handler(err_handler_); - } - - new_logger->set_level(level_); - new_logger->flush_on(flush_level_); - - // add to registry - loggers_[logger_name] = new_logger; - } - - std::shared_ptr get(const std::string &logger_name) - { - std::lock_guard lock(logger_map_mutex_); - auto found = loggers_.find(logger_name); - return found == loggers_.end() ? nullptr : found->second; - } - - void set_tp(std::shared_ptr tp) - { - std::lock_guard lock(tp_mutex_); - tp_ = std::move(tp); - } - - std::shared_ptr get_tp() - { - std::lock_guard lock(tp_mutex_); - return tp_; - } - - // Set global formatter. Each sink in each logger will get a clone of this object - void set_formatter(std::unique_ptr formatter) - { - std::lock_guard lock(logger_map_mutex_); - formatter_ = std::move(formatter); - for (auto &l : loggers_) - { - l.second->set_formatter(formatter_->clone()); - } - } - - void set_level(level::level_enum log_level) - { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { - l.second->set_level(log_level); - } - level_ = log_level; - } - - void flush_on(level::level_enum log_level) - { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { - l.second->flush_on(log_level); - } - flush_level_ = log_level; - } - - void flush_every(std::chrono::seconds interval) - { - std::lock_guard lock(flusher_mutex_); - std::function clbk(std::bind(®istry::flush_all, this)); - periodic_flusher_.reset(new periodic_worker(clbk, interval)); - } - - void set_error_handler(log_err_handler handler) - { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { - l.second->set_error_handler(handler); - } - err_handler_ = handler; - } - - void apply_all(std::function)> fun) - { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { - fun(l.second); - } - } - - void flush_all() - { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { - l.second->flush(); - } - } - - void drop(const std::string &logger_name) - { - std::lock_guard lock(logger_map_mutex_); - loggers_.erase(logger_name); - } - - void drop_all() - { - std::lock_guard lock(logger_map_mutex_); - loggers_.clear(); - } - - // clean all reasources and threads started by the registry - void shutdown() - { - { - std::lock_guard lock(flusher_mutex_); - periodic_flusher_.reset(); - } - - drop_all(); - - { - std::lock_guard lock(tp_mutex_); - tp_.reset(); - } - } - - std::recursive_mutex &tp_mutex() - { - return tp_mutex_; - } - - static registry &instance() - { - static registry s_instance; - return s_instance; - } - -private: - registry() - : formatter_(new pattern_formatter("%+")) - { - } - - ~registry() - { - /*std::lock_guard lock(flusher_mutex_); - periodic_flusher_.reset();*/ - } - - 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"); - } - } - - std::mutex logger_map_mutex_, flusher_mutex_; - std::recursive_mutex tp_mutex_; - std::unordered_map> loggers_; - std::unique_ptr formatter_; - level::level_enum level_ = level::info; - level::level_enum flush_level_ = level::off; - log_err_handler err_handler_; - std::shared_ptr tp_; - std::unique_ptr periodic_flusher_; -}; - -} // namespace details -} // namespace spdlog diff --git a/spdlog_lib/spdlog/details/thread_pool.h b/spdlog_lib/spdlog/details/thread_pool.h deleted file mode 100644 index 2620a19..0000000 --- a/spdlog_lib/spdlog/details/thread_pool.h +++ /dev/null @@ -1,220 +0,0 @@ -#pragma once - -#include "spdlog/details/log_msg.h" -#include "spdlog/details/mpmc_blocking_q.h" -#include "spdlog/details/os.h" - -#include -#include -#include -#include - -namespace spdlog { -namespace details { - -using async_logger_ptr = std::shared_ptr; - -enum class async_msg_type -{ - log, - flush, - terminate -}; - -// Async msg to move to/from the queue -// Movable only. should never be copied -struct async_msg -{ - async_msg_type msg_type; - level::level_enum level; - log_clock::time_point time; - size_t thread_id; - fmt::basic_memory_buffer raw; - - size_t msg_id; - async_logger_ptr worker_ptr; - - async_msg() = default; - ~async_msg() = default; - - // should only be moved in or out of the queue.. - async_msg(const async_msg &) = delete; - -// support for vs2013 move -#if defined(_MSC_VER) && _MSC_VER <= 1800 - async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type), - level(other.level), - time(other.time), - thread_id(other.thread_id), - raw(move(other.raw)), - msg_id(other.msg_id), - worker_ptr(std::move(other.worker_ptr)) - { - } - - async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT - { - msg_type = other.msg_type; - level = other.level; - time = other.time; - thread_id = other.thread_id; - raw = std::move(other.raw); - msg_id = other.msg_id; - worker_ptr = std::move(other.worker_ptr); - return *this; - } -#else // (_MSC_VER) && _MSC_VER <= 1800 - async_msg(async_msg &&other) = default; - async_msg &operator=(async_msg &&other) = default; -#endif - - // construct from log_msg with given type - async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &&m) - : msg_type(the_type) - , level(m.level) - , time(m.time) - , thread_id(m.thread_id) - , msg_id(m.msg_id) - , worker_ptr(std::forward(worker)) - { - fmt_helper::append_buf(m.raw, raw); - } - - async_msg(async_logger_ptr &&worker, async_msg_type the_type) - : async_msg(std::forward(worker), the_type, details::log_msg()) - { - } - - explicit async_msg(async_msg_type the_type) - : async_msg(nullptr, the_type, details::log_msg()) - { - } - - // copy into log_msg - void to_log_msg(log_msg &msg) - { - msg.logger_name = &worker_ptr->name(); - msg.level = level; - msg.time = time; - msg.thread_id = thread_id; - fmt_helper::append_buf(raw, msg.raw); - msg.msg_id = msg_id; - msg.color_range_start = 0; - msg.color_range_end = 0; - } -}; - -class thread_pool -{ -public: - using item_type = async_msg; - using q_type = details::mpmc_blocking_queue; - - thread_pool(size_t q_max_items, size_t threads_n) - : q_(q_max_items) - { - // std::cout << "thread_pool() q_size_bytes: " << q_size_bytes << - // "\tthreads_n: " << threads_n << std::endl; - if (threads_n == 0 || threads_n > 1000) - { - throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid " - "range is 1-1000)"); - } - for (size_t i = 0; i < threads_n; i++) - { - threads_.emplace_back(std::bind(&thread_pool::worker_loop_, this)); - } - } - - // message all threads to terminate gracefully join them - ~thread_pool() - { - try - { - for (size_t i = 0; i < threads_.size(); i++) - { - post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block); - } - - for (auto &t : threads_) - { - t.join(); - } - } - catch (...) - { - } - } - - void post_log(async_logger_ptr &&worker_ptr, details::log_msg &&msg, async_overflow_policy overflow_policy) - { - async_msg async_m(std::forward(worker_ptr), async_msg_type::log, std::forward(msg)); - post_async_msg_(std::move(async_m), overflow_policy); - } - - void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy) - { - post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy); - } - -private: - q_type q_; - - std::vector threads_; - - void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) - { - if (overflow_policy == async_overflow_policy::block) - { - q_.enqueue(std::move(new_msg)); - } - else - { - q_.enqueue_nowait(std::move(new_msg)); - } - } - - void worker_loop_() - { - while (process_next_msg_()) {}; - } - - // process next message in the queue - // return true if this thread should still be active (while no terminate msg - // was received) - bool process_next_msg_() - { - async_msg incoming_async_msg; - bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10)); - if (!dequeued) - { - return true; - } - - switch (incoming_async_msg.msg_type) - { - case async_msg_type::flush: - { - incoming_async_msg.worker_ptr->backend_flush_(); - return true; - } - - case async_msg_type::terminate: - { - return false; - } - - default: - { - log_msg msg; - incoming_async_msg.to_log_msg(msg); - incoming_async_msg.worker_ptr->backend_log_(msg); - return true; - } - } - return true; // should not be reached - } -}; - -} // namespace details -} // namespace spdlog \ No newline at end of file diff --git a/spdlog_lib/spdlog/fmt/bundled/LICENSE.rst b/spdlog_lib/spdlog/fmt/bundled/LICENSE.rst deleted file mode 100644 index eb6be65..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/LICENSE.rst +++ /dev/null @@ -1,23 +0,0 @@ -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. diff --git a/spdlog_lib/spdlog/fmt/bundled/colors.h b/spdlog_lib/spdlog/fmt/bundled/colors.h deleted file mode 100644 index 003a667..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/colors.h +++ /dev/null @@ -1,257 +0,0 @@ -// Formatting library for C++ - the core API -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. -// -// Copyright (c) 2018 - present, Remotion (Igor Schulz) -// All Rights Reserved -// {fmt} support for rgb color output. - -#ifndef FMT_COLORS_H_ -#define FMT_COLORS_H_ - -#include "format.h" - -FMT_BEGIN_NAMESPACE - -// rgb is a struct for red, green and blue colors. -// We use rgb as name because some editors will show it as color direct in the -// editor. -struct rgb -{ - FMT_CONSTEXPR_DECL rgb() - : r(0) - , g(0) - , b(0) - { - } - FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_) - : r(r_) - , g(g_) - , b(b_) - { - } - FMT_CONSTEXPR_DECL rgb(uint32_t hex) - : r((hex >> 16) & 0xFF) - , g((hex >> 8) & 0xFF) - , b((hex)&0xFF) - { - } - uint8_t r; - uint8_t g; - uint8_t b; -}; - -namespace internal { - -FMT_CONSTEXPR inline void to_esc(uint8_t c, char out[], int offset) -{ - out[offset + 0] = static_cast('0' + c / 100); - out[offset + 1] = static_cast('0' + c / 10 % 10); - out[offset + 2] = static_cast('0' + c % 10); -} - -} // namespace internal - -FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) -{ - char escape_fd[] = "\x1b[38;2;000;000;000m"; - static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m"; - internal::to_esc(fd.r, escape_fd, 7); - internal::to_esc(fd.g, escape_fd, 11); - internal::to_esc(fd.b, escape_fd, 15); - - std::fputs(escape_fd, stdout); - vprint(format, args); - std::fputs(RESET_COLOR, stdout); -} - -FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) -{ - char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color - char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color - static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m"; - internal::to_esc(fd.r, escape_fd, 7); - internal::to_esc(fd.g, escape_fd, 11); - internal::to_esc(fd.b, escape_fd, 15); - - internal::to_esc(bg.r, escape_bg, 7); - internal::to_esc(bg.g, escape_bg, 11); - internal::to_esc(bg.b, escape_bg, 15); - - std::fputs(escape_fd, stdout); - std::fputs(escape_bg, stdout); - vprint(format, args); - std::fputs(RESET_COLOR, stdout); -} - -template -inline void print_rgb(rgb fd, string_view format_str, const Args &... args) -{ - vprint_rgb(fd, format_str, make_format_args(args...)); -} - -// rgb foreground color -template -inline void print(rgb fd, string_view format_str, const Args &... args) -{ - vprint_rgb(fd, format_str, make_format_args(args...)); -} - -// rgb foreground color and background color -template -inline void print(rgb fd, rgb bg, string_view format_str, const Args &... args) -{ - vprint_rgb(fd, bg, format_str, make_format_args(args...)); -} - -enum class color : uint32_t -{ - alice_blue = 0xF0F8FF, // rgb(240,248,255) - antique_white = 0xFAEBD7, // rgb(250,235,215) - aqua = 0x00FFFF, // rgb(0,255,255) - aquamarine = 0x7FFFD4, // rgb(127,255,212) - azure = 0xF0FFFF, // rgb(240,255,255) - beige = 0xF5F5DC, // rgb(245,245,220) - bisque = 0xFFE4C4, // rgb(255,228,196) - black = 0x000000, // rgb(0,0,0) - blanched_almond = 0xFFEBCD, // rgb(255,235,205) - blue = 0x0000FF, // rgb(0,0,255) - blue_violet = 0x8A2BE2, // rgb(138,43,226) - brown = 0xA52A2A, // rgb(165,42,42) - burly_wood = 0xDEB887, // rgb(222,184,135) - cadet_blue = 0x5F9EA0, // rgb(95,158,160) - chartreuse = 0x7FFF00, // rgb(127,255,0) - chocolate = 0xD2691E, // rgb(210,105,30) - coral = 0xFF7F50, // rgb(255,127,80) - cornflower_blue = 0x6495ED, // rgb(100,149,237) - cornsilk = 0xFFF8DC, // rgb(255,248,220) - crimson = 0xDC143C, // rgb(220,20,60) - cyan = 0x00FFFF, // rgb(0,255,255) - dark_blue = 0x00008B, // rgb(0,0,139) - dark_cyan = 0x008B8B, // rgb(0,139,139) - dark_golden_rod = 0xB8860B, // rgb(184,134,11) - dark_gray = 0xA9A9A9, // rgb(169,169,169) - dark_green = 0x006400, // rgb(0,100,0) - dark_khaki = 0xBDB76B, // rgb(189,183,107) - dark_magenta = 0x8B008B, // rgb(139,0,139) - dark_olive_green = 0x556B2F, // rgb(85,107,47) - dark_orange = 0xFF8C00, // rgb(255,140,0) - dark_orchid = 0x9932CC, // rgb(153,50,204) - dark_red = 0x8B0000, // rgb(139,0,0) - dark_salmon = 0xE9967A, // rgb(233,150,122) - dark_sea_green = 0x8FBC8F, // rgb(143,188,143) - dark_slate_blue = 0x483D8B, // rgb(72,61,139) - dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) - dark_turquoise = 0x00CED1, // rgb(0,206,209) - dark_violet = 0x9400D3, // rgb(148,0,211) - deep_pink = 0xFF1493, // rgb(255,20,147) - deep_sky_blue = 0x00BFFF, // rgb(0,191,255) - dim_gray = 0x696969, // rgb(105,105,105) - dodger_blue = 0x1E90FF, // rgb(30,144,255) - fire_brick = 0xB22222, // rgb(178,34,34) - floral_white = 0xFFFAF0, // rgb(255,250,240) - forest_green = 0x228B22, // rgb(34,139,34) - fuchsia = 0xFF00FF, // rgb(255,0,255) - gainsboro = 0xDCDCDC, // rgb(220,220,220) - ghost_white = 0xF8F8FF, // rgb(248,248,255) - gold = 0xFFD700, // rgb(255,215,0) - golden_rod = 0xDAA520, // rgb(218,165,32) - gray = 0x808080, // rgb(128,128,128) - green = 0x008000, // rgb(0,128,0) - green_yellow = 0xADFF2F, // rgb(173,255,47) - honey_dew = 0xF0FFF0, // rgb(240,255,240) - hot_pink = 0xFF69B4, // rgb(255,105,180) - indian_red = 0xCD5C5C, // rgb(205,92,92) - indigo = 0x4B0082, // rgb(75,0,130) - ivory = 0xFFFFF0, // rgb(255,255,240) - khaki = 0xF0E68C, // rgb(240,230,140) - lavender = 0xE6E6FA, // rgb(230,230,250) - lavender_blush = 0xFFF0F5, // rgb(255,240,245) - lawn_green = 0x7CFC00, // rgb(124,252,0) - lemon_chiffon = 0xFFFACD, // rgb(255,250,205) - light_blue = 0xADD8E6, // rgb(173,216,230) - light_coral = 0xF08080, // rgb(240,128,128) - light_cyan = 0xE0FFFF, // rgb(224,255,255) - light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) - light_gray = 0xD3D3D3, // rgb(211,211,211) - light_green = 0x90EE90, // rgb(144,238,144) - light_pink = 0xFFB6C1, // rgb(255,182,193) - light_salmon = 0xFFA07A, // rgb(255,160,122) - light_sea_green = 0x20B2AA, // rgb(32,178,170) - light_sky_blue = 0x87CEFA, // rgb(135,206,250) - light_slate_gray = 0x778899, // rgb(119,136,153) - light_steel_blue = 0xB0C4DE, // rgb(176,196,222) - light_yellow = 0xFFFFE0, // rgb(255,255,224) - lime = 0x00FF00, // rgb(0,255,0) - lime_green = 0x32CD32, // rgb(50,205,50) - linen = 0xFAF0E6, // rgb(250,240,230) - magenta = 0xFF00FF, // rgb(255,0,255) - maroon = 0x800000, // rgb(128,0,0) - medium_aqua_marine = 0x66CDAA, // rgb(102,205,170) - medium_blue = 0x0000CD, // rgb(0,0,205) - medium_orchid = 0xBA55D3, // rgb(186,85,211) - medium_purple = 0x9370DB, // rgb(147,112,219) - medium_sea_green = 0x3CB371, // rgb(60,179,113) - medium_slate_blue = 0x7B68EE, // rgb(123,104,238) - medium_spring_green = 0x00FA9A, // rgb(0,250,154) - medium_turquoise = 0x48D1CC, // rgb(72,209,204) - medium_violet_red = 0xC71585, // rgb(199,21,133) - midnight_blue = 0x191970, // rgb(25,25,112) - mint_cream = 0xF5FFFA, // rgb(245,255,250) - misty_rose = 0xFFE4E1, // rgb(255,228,225) - moccasin = 0xFFE4B5, // rgb(255,228,181) - navajo_white = 0xFFDEAD, // rgb(255,222,173) - navy = 0x000080, // rgb(0,0,128) - old_lace = 0xFDF5E6, // rgb(253,245,230) - olive = 0x808000, // rgb(128,128,0) - olive_drab = 0x6B8E23, // rgb(107,142,35) - orange = 0xFFA500, // rgb(255,165,0) - orange_red = 0xFF4500, // rgb(255,69,0) - orchid = 0xDA70D6, // rgb(218,112,214) - pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) - pale_green = 0x98FB98, // rgb(152,251,152) - pale_turquoise = 0xAFEEEE, // rgb(175,238,238) - pale_violet_red = 0xDB7093, // rgb(219,112,147) - papaya_whip = 0xFFEFD5, // rgb(255,239,213) - peach_puff = 0xFFDAB9, // rgb(255,218,185) - peru = 0xCD853F, // rgb(205,133,63) - pink = 0xFFC0CB, // rgb(255,192,203) - plum = 0xDDA0DD, // rgb(221,160,221) - powder_blue = 0xB0E0E6, // rgb(176,224,230) - purple = 0x800080, // rgb(128,0,128) - rebecca_purple = 0x663399, // rgb(102,51,153) - red = 0xFF0000, // rgb(255,0,0) - rosy_brown = 0xBC8F8F, // rgb(188,143,143) - royal_blue = 0x4169E1, // rgb(65,105,225) - saddle_brown = 0x8B4513, // rgb(139,69,19) - salmon = 0xFA8072, // rgb(250,128,114) - sandy_brown = 0xF4A460, // rgb(244,164,96) - sea_green = 0x2E8B57, // rgb(46,139,87) - sea_shell = 0xFFF5EE, // rgb(255,245,238) - sienna = 0xA0522D, // rgb(160,82,45) - silver = 0xC0C0C0, // rgb(192,192,192) - sky_blue = 0x87CEEB, // rgb(135,206,235) - slate_blue = 0x6A5ACD, // rgb(106,90,205) - slate_gray = 0x708090, // rgb(112,128,144) - snow = 0xFFFAFA, // rgb(255,250,250) - spring_green = 0x00FF7F, // rgb(0,255,127) - steel_blue = 0x4682B4, // rgb(70,130,180) - tan = 0xD2B48C, // rgb(210,180,140) - teal = 0x008080, // rgb(0,128,128) - thistle = 0xD8BFD8, // rgb(216,191,216) - tomato = 0xFF6347, // rgb(255,99,71) - turquoise = 0x40E0D0, // rgb(64,224,208) - violet = 0xEE82EE, // rgb(238,130,238) - wheat = 0xF5DEB3, // rgb(245,222,179) - white = 0xFFFFFF, // rgb(255,255,255) - white_smoke = 0xF5F5F5, // rgb(245,245,245) - yellow = 0xFFFF00, // rgb(255,255,0) - yellow_green = 0x9ACD32, // rgb(154,205,50) -}; // enum class colors - -FMT_END_NAMESPACE - -#endif // FMT_COLORS_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/core.h b/spdlog_lib/spdlog/fmt/bundled/core.h deleted file mode 100644 index 19273a6..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/core.h +++ /dev/null @@ -1,1578 +0,0 @@ -// Formatting library for C++ - the core API -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#ifndef FMT_CORE_H_ -#define FMT_CORE_H_ - -#include -#include -#include -#include -#include -#include - -// The fmt library version in the form major * 10000 + minor * 100 + patch. -#define FMT_VERSION 50100 - -#ifdef __has_feature -#define FMT_HAS_FEATURE(x) __has_feature(x) -#else -#define FMT_HAS_FEATURE(x) 0 -#endif - -#ifdef __has_include -#define FMT_HAS_INCLUDE(x) __has_include(x) -#else -#define FMT_HAS_INCLUDE(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 - -#if defined(__GNUC__) && !defined(__clang__) -#define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) -#else -#define FMT_GCC_VERSION 0 -#endif - -#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) -#define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION -#else -#define FMT_HAS_GXX_CXX11 0 -#endif - -#ifdef _MSC_VER -#define FMT_MSC_VER _MSC_VER -#else -#define FMT_MSC_VER 0 -#endif - -// Check if relaxed c++14 constexpr is supported. -// GCC doesn't allow throw in constexpr until version 6 (bug 67371). -#ifndef FMT_USE_CONSTEXPR -#define FMT_USE_CONSTEXPR \ - (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) -#endif -#if FMT_USE_CONSTEXPR -#define FMT_CONSTEXPR constexpr -#define FMT_CONSTEXPR_DECL constexpr -#else -#define FMT_CONSTEXPR inline -#define FMT_CONSTEXPR_DECL -#endif - -#ifndef FMT_OVERRIDE -#if 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 - -#if FMT_HAS_FEATURE(cxx_explicit_conversions) || FMT_MSC_VER >= 1800 -#define FMT_EXPLICIT explicit -#else -#define FMT_EXPLICIT -#endif - -#ifndef FMT_NULL -#if FMT_HAS_FEATURE(cxx_nullptr) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600 -#define FMT_NULL nullptr -#define FMT_USE_NULLPTR 1 -#else -#define FMT_NULL NULL -#endif -#endif - -#ifndef FMT_USE_NULLPTR -#define FMT_USE_NULLPTR 0 -#endif - -#if FMT_HAS_CPP_ATTRIBUTE(noreturn) -#define FMT_NORETURN [[noreturn]] -#else -#define FMT_NORETURN -#endif - -// Check if exceptions are disabled. -#if defined(__GNUC__) && !defined(__EXCEPTIONS) -#define FMT_EXCEPTIONS 0 -#elif FMT_MSC_VER && !_HAS_EXCEPTIONS -#define FMT_EXCEPTIONS 0 -#endif -#ifndef FMT_EXCEPTIONS -#define FMT_EXCEPTIONS 1 -#endif - -// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature). -#ifndef FMT_USE_NOEXCEPT -#define FMT_USE_NOEXCEPT 0 -#endif - -#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900 -#define FMT_DETECTED_NOEXCEPT noexcept -#else -#define FMT_DETECTED_NOEXCEPT throw() -#endif - -#ifndef FMT_NOEXCEPT -#if FMT_EXCEPTIONS -#define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT -#else -#define FMT_NOEXCEPT -#endif -#endif - -// This is needed because GCC still uses throw() in its headers when exceptions -// are disabled. -#if FMT_GCC_VERSION -#define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT -#else -#define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT -#endif - -#ifndef FMT_BEGIN_NAMESPACE -#if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || FMT_MSC_VER >= 1900 -#define FMT_INLINE_NAMESPACE inline namespace -#define FMT_END_NAMESPACE \ - } \ - } -#else -#define FMT_INLINE_NAMESPACE namespace -#define FMT_END_NAMESPACE \ - } \ - using namespace v5; \ - } -#endif -#define FMT_BEGIN_NAMESPACE \ - namespace fmt { \ - FMT_INLINE_NAMESPACE v5 \ - { -#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 - -#ifndef FMT_ASSERT -#define FMT_ASSERT(condition, message) assert((condition) && message) -#endif - -#define FMT_DELETED = delete - -// A macro to disallow the copy construction and assignment. -#define FMT_DISALLOW_COPY_AND_ASSIGN(Type) \ - Type(const Type &) FMT_DELETED; \ - void operator=(const Type &) FMT_DELETED - -// libc++ supports string_view in pre-c++17. -#if (FMT_HAS_INCLUDE() && (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \ - (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910) -#include -#define FMT_USE_STD_STRING_VIEW -#elif (FMT_HAS_INCLUDE() && __cplusplus >= 201402L) -#include -#define FMT_USE_EXPERIMENTAL_STRING_VIEW -#endif - -// std::result_of is defined in in gcc 4.4. -#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404 -#include -#endif - -FMT_BEGIN_NAMESPACE - -namespace internal { - -// An implementation of declval for pre-C++11 compilers such as gcc 4. -template -typename std::add_rvalue_reference::type declval() FMT_NOEXCEPT; - -// Casts nonnegative integer to unsigned. -template -FMT_CONSTEXPR typename std::make_unsigned::type to_unsigned(Int value) -{ - FMT_ASSERT(value >= 0, "negative value"); - return static_cast::type>(value); -} - -} // namespace internal - -/** - An implementation of ``std::basic_string_view`` for pre-C++17. It provides a - subset of the API. ``fmt::basic_string_view`` is used for format strings even - if ``std::string_view`` is available to prevent issues when a library is - compiled with a different ``-std`` option than the client code (which is not - recommended). - */ -template -class basic_string_view -{ -private: - const Char *data_; - size_t size_; - -public: - typedef Char char_type; - typedef const Char *iterator; - -// Standard basic_string_view type. -#if defined(FMT_USE_STD_STRING_VIEW) - typedef std::basic_string_view type; -#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) - typedef std::experimental::basic_string_view type; -#else - struct type - { - const char *data() const - { - return FMT_NULL; - } - size_t size() const - { - return 0; - } - }; -#endif - - FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {} - - /** Constructs a string reference object from a C string and a size. */ - FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT : data_(s), size_(count) {} - - /** - \rst - Constructs a string reference object from a C string computing - the size with ``std::char_traits::length``. - \endrst - */ - basic_string_view(const Char *s) - : data_(s) - , size_(std::char_traits::length(s)) - { - } - - /** Constructs a string reference from a ``std::basic_string`` object. */ - template - FMT_CONSTEXPR basic_string_view(const std::basic_string &s) FMT_NOEXCEPT : data_(s.c_str()), size_(s.size()) - { - } - - FMT_CONSTEXPR basic_string_view(type s) FMT_NOEXCEPT : data_(s.data()), size_(s.size()) {} - - /** Returns a pointer to the string data. */ - const Char *data() const - { - return data_; - } - - /** Returns the string size. */ - FMT_CONSTEXPR size_t size() const - { - return size_; - } - - FMT_CONSTEXPR iterator begin() const - { - return data_; - } - FMT_CONSTEXPR iterator end() const - { - return data_ + size_; - } - - FMT_CONSTEXPR void remove_prefix(size_t n) - { - data_ += n; - size_ -= n; - } - - // Lexicographically compare this string reference to other. - int compare(basic_string_view other) const - { - size_t str_size = size_ < other.size_ ? size_ : other.size_; - int result = std::char_traits::compare(data_, other.data_, str_size); - if (result == 0) - result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); - return result; - } - - friend bool operator==(basic_string_view lhs, basic_string_view rhs) - { - return lhs.compare(rhs) == 0; - } - friend bool operator!=(basic_string_view lhs, basic_string_view rhs) - { - return lhs.compare(rhs) != 0; - } - friend bool operator<(basic_string_view lhs, basic_string_view rhs) - { - return lhs.compare(rhs) < 0; - } - friend bool operator<=(basic_string_view lhs, basic_string_view rhs) - { - return lhs.compare(rhs) <= 0; - } - friend bool operator>(basic_string_view lhs, basic_string_view rhs) - { - return lhs.compare(rhs) > 0; - } - friend bool operator>=(basic_string_view lhs, basic_string_view rhs) - { - return lhs.compare(rhs) >= 0; - } -}; - -typedef basic_string_view string_view; -typedef basic_string_view wstring_view; - -template -class basic_format_arg; - -template -class basic_format_args; - -// A formatter for objects of type T. -template -struct formatter; - -namespace internal { - -/** A contiguous memory buffer with an optional growing ability. */ -template -class basic_buffer -{ -private: - FMT_DISALLOW_COPY_AND_ASSIGN(basic_buffer); - - T *ptr_; - std::size_t size_; - std::size_t capacity_; - -protected: - basic_buffer(T *p = FMT_NULL, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT : ptr_(p), size_(sz), capacity_(cap) {} - - /** Sets the buffer data and capacity. */ - void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT - { - ptr_ = buf_data; - capacity_ = buf_capacity; - } - - /** Increases the buffer capacity to hold at least *capacity* elements. */ - virtual void grow(std::size_t capacity) = 0; - -public: - typedef T value_type; - typedef const T &const_reference; - - virtual ~basic_buffer() {} - - T *begin() FMT_NOEXCEPT - { - return ptr_; - } - T *end() FMT_NOEXCEPT - { - return ptr_ + size_; - } - - /** Returns the size of this buffer. */ - std::size_t size() const FMT_NOEXCEPT - { - return size_; - } - - /** Returns the capacity of this buffer. */ - std::size_t capacity() const FMT_NOEXCEPT - { - return capacity_; - } - - /** Returns a pointer to the buffer data. */ - T *data() FMT_NOEXCEPT - { - return ptr_; - } - - /** Returns a pointer to the buffer data. */ - const T *data() const FMT_NOEXCEPT - { - return ptr_; - } - - /** - Resizes the buffer. If T is a POD type new elements may not be initialized. - */ - void resize(std::size_t new_size) - { - reserve(new_size); - size_ = new_size; - } - - /** Reserves space to store at least *capacity* elements. */ - void reserve(std::size_t new_capacity) - { - if (new_capacity > capacity_) - grow(new_capacity); - } - - void push_back(const T &value) - { - reserve(size_ + 1); - ptr_[size_++] = value; - } - - /** Appends data to the end of the buffer. */ - template - 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]; - } -}; - -typedef basic_buffer buffer; -typedef basic_buffer wbuffer; - -// A container-backed buffer. -template -class container_buffer : public basic_buffer -{ -private: - Container &container_; - -protected: - void grow(std::size_t capacity) FMT_OVERRIDE - { - container_.resize(capacity); - this->set(&container_[0], capacity); - } - -public: - explicit container_buffer(Container &c) - : basic_buffer(&c[0], c.size(), c.size()) - , container_(c) - { - } -}; - -struct error_handler -{ - FMT_CONSTEXPR error_handler() {} - FMT_CONSTEXPR error_handler(const error_handler &) {} - - // This function is intentionally not constexpr to give a compile-time error. - FMT_API void on_error(const char *message); -}; - -// Formatting of wide characters and strings into a narrow output is disallowed: -// fmt::format("{}", L"test"); // error -// To fix this, use a wide format string: -// fmt::format(L"{}", L"test"); -template -inline void require_wchar() -{ - static_assert(std::is_same::value, "formatting of wide characters into a narrow output is disallowed"); -} - -template -struct named_arg_base; - -template -struct named_arg; - -template -struct is_named_arg : std::false_type -{ -}; - -template -struct is_named_arg> : std::true_type -{ -}; - -enum type -{ - none_type, - named_arg_type, - // Integer types should go first, - int_type, - uint_type, - long_long_type, - ulong_long_type, - bool_type, - char_type, - last_integer_type = char_type, - // followed by floating-point types. - double_type, - long_double_type, - last_numeric_type = long_double_type, - cstring_type, - string_type, - pointer_type, - custom_type -}; - -FMT_CONSTEXPR bool is_integral(type t) -{ - FMT_ASSERT(t != internal::named_arg_type, "invalid argument type"); - return t > internal::none_type && t <= internal::last_integer_type; -} - -FMT_CONSTEXPR bool is_arithmetic(type t) -{ - FMT_ASSERT(t != internal::named_arg_type, "invalid argument type"); - return t > internal::none_type && t <= internal::last_numeric_type; -} - -template -struct convert_to_int -{ - enum - { - value = !std::is_arithmetic::value && std::is_convertible::value - }; -}; - -template -struct string_value -{ - const Char *value; - std::size_t size; -}; - -template -struct custom_value -{ - const void *value; - void (*format)(const void *arg, Context &ctx); -}; - -// A formatting argument value. -template -class value -{ -public: - typedef typename Context::char_type char_type; - - union - { - int int_value; - unsigned uint_value; - long long long_long_value; - unsigned long long ulong_long_value; - double double_value; - long double long_double_value; - const void *pointer; - string_value string; - string_value sstring; - string_value ustring; - custom_value custom; - }; - - FMT_CONSTEXPR value(int val = 0) - : int_value(val) - { - } - value(unsigned val) - { - uint_value = val; - } - value(long long val) - { - long_long_value = val; - } - value(unsigned long long val) - { - ulong_long_value = val; - } - value(double val) - { - double_value = val; - } - value(long double val) - { - long_double_value = val; - } - value(const char_type *val) - { - string.value = val; - } - value(const signed char *val) - { - static_assert(std::is_same::value, "incompatible string types"); - sstring.value = val; - } - value(const unsigned char *val) - { - static_assert(std::is_same::value, "incompatible string types"); - ustring.value = val; - } - value(basic_string_view val) - { - string.value = val.data(); - string.size = val.size(); - } - value(const void *val) - { - pointer = val; - } - - template - explicit value(const T &val) - { - custom.value = &val; - custom.format = &format_custom_arg; - } - - const named_arg_base &as_named_arg() - { - return *static_cast *>(pointer); - } - -private: - // Formats an argument of a custom type, such as a user-defined class. - template - static void format_custom_arg(const void *arg, Context &ctx) - { - // Get the formatter type through the context to allow different contexts - // have different extension points, e.g. `formatter` for `format` and - // `printf_formatter` for `printf`. - typename Context::template formatter_type::type f; - auto &&parse_ctx = ctx.parse_context(); - parse_ctx.advance_to(f.parse(parse_ctx)); - ctx.advance_to(f.format(*static_cast(arg), ctx)); - } -}; - -template -struct typed_value : value -{ - static const type type_tag = TYPE; - - template - FMT_CONSTEXPR typed_value(const T &val) - : value(val) - { - } -}; - -template -FMT_CONSTEXPR basic_format_arg make_arg(const T &value); - -#define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \ - template \ - FMT_CONSTEXPR typed_value make_value(ArgType val) \ - { \ - return static_cast(val); \ - } - -#define FMT_MAKE_VALUE_SAME(TAG, Type) \ - template \ - FMT_CONSTEXPR typed_value make_value(Type val) \ - { \ - return val; \ - } - -FMT_MAKE_VALUE(bool_type, bool, int) -FMT_MAKE_VALUE(int_type, short, int) -FMT_MAKE_VALUE(uint_type, unsigned short, unsigned) -FMT_MAKE_VALUE_SAME(int_type, int) -FMT_MAKE_VALUE_SAME(uint_type, unsigned) - -// 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. -typedef std::conditional::type long_type; -FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type) -typedef std::conditional::type ulong_type; -FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type), unsigned long, ulong_type) - -FMT_MAKE_VALUE_SAME(long_long_type, long long) -FMT_MAKE_VALUE_SAME(ulong_long_type, unsigned long long) -FMT_MAKE_VALUE(int_type, signed char, int) -FMT_MAKE_VALUE(uint_type, unsigned char, unsigned) -FMT_MAKE_VALUE(char_type, char, int) - -#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) -template -inline typed_value make_value(wchar_t val) -{ - require_wchar(); - return static_cast(val); -} -#endif - -FMT_MAKE_VALUE(double_type, float, double) -FMT_MAKE_VALUE_SAME(double_type, double) -FMT_MAKE_VALUE_SAME(long_double_type, long double) - -// Formatting of wide strings into a narrow buffer and multibyte strings -// into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606). -FMT_MAKE_VALUE(cstring_type, typename C::char_type *, const typename C::char_type *) -FMT_MAKE_VALUE(cstring_type, const typename C::char_type *, const typename C::char_type *) - -FMT_MAKE_VALUE(cstring_type, signed char *, const signed char *) -FMT_MAKE_VALUE_SAME(cstring_type, const signed char *) -FMT_MAKE_VALUE(cstring_type, unsigned char *, const unsigned char *) -FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char *) -FMT_MAKE_VALUE_SAME(string_type, basic_string_view) -FMT_MAKE_VALUE(string_type, typename basic_string_view::type, basic_string_view) -FMT_MAKE_VALUE(string_type, const std::basic_string &, basic_string_view) -FMT_MAKE_VALUE(pointer_type, void *, const void *) -FMT_MAKE_VALUE_SAME(pointer_type, const void *) - -#if FMT_USE_NULLPTR -FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void *) -#endif - -// Formatting of arbitrary pointers is disallowed. 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. -template -typename std::enable_if::value>::type make_value(const T *) -{ - static_assert(!sizeof(T), "formatting of non-void pointers is disallowed"); -} - -template -inline typename std::enable_if::value && convert_to_int::value, typed_value>::type -make_value(const T &val) -{ - return static_cast(val); -} - -template -inline typename std::enable_if::value && !std::is_convertible>::value, - // Implicit conversion to std::string is not handled here because it's - // unsafe: https://github.com/fmtlib/fmt/issues/729 - typed_value>::type -make_value(const T &val) -{ - return val; -} - -template -typed_value make_value(const named_arg &val) -{ - basic_format_arg arg = make_arg(val.value); - std::memcpy(val.data, &arg, sizeof(arg)); - return static_cast(&val); -} - -// Maximum number of arguments with packed types. -enum -{ - max_packed_args = 15 -}; - -template -class arg_map; - -template -struct result_of; - -template -struct result_of -{ - // A workaround for gcc 4.4 that doesn't allow F to be a reference. - typedef typename std::result_of::type(Args...)>::type type; -}; -} // namespace internal - -// A formatting argument. It is a trivially copyable/constructible type to -// allow storage in basic_memory_buffer. -template -class basic_format_arg -{ -private: - internal::value value_; - internal::type type_; - - template - friend FMT_CONSTEXPR basic_format_arg internal::make_arg(const T &value); - - template - friend FMT_CONSTEXPR typename internal::result_of::type visit(Visitor &&vis, basic_format_arg arg); - - friend class basic_format_args; - friend class internal::arg_map; - - typedef typename Context::char_type char_type; - -public: - class handle - { - public: - explicit handle(internal::custom_value custom) - : custom_(custom) - { - } - - void format(Context &ctx) const - { - custom_.format(custom_.value, ctx); - } - - private: - internal::custom_value custom_; - }; - - FMT_CONSTEXPR basic_format_arg() - : type_(internal::none_type) - { - } - - FMT_EXPLICIT operator bool() const FMT_NOEXCEPT - { - return type_ != internal::none_type; - } - - internal::type type() const - { - return type_; - } - - bool is_integral() const - { - return internal::is_integral(type_); - } - bool is_arithmetic() const - { - return internal::is_arithmetic(type_); - } -}; - -// Parsing context consisting of a format string range being parsed and an -// argument counter for automatic indexing. -template -class basic_parse_context : private ErrorHandler -{ -private: - basic_string_view format_str_; - int next_arg_id_; - -public: - typedef Char char_type; - typedef typename basic_string_view::iterator iterator; - - explicit FMT_CONSTEXPR basic_parse_context(basic_string_view format_str, ErrorHandler eh = ErrorHandler()) - : ErrorHandler(eh) - , format_str_(format_str) - , next_arg_id_(0) - { - } - - // Returns an iterator to the beginning of the format string range being - // parsed. - FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT - { - return format_str_.begin(); - } - - // Returns an iterator past the end of the format string range being parsed. - FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT - { - return format_str_.end(); - } - - // Advances the begin iterator to ``it``. - FMT_CONSTEXPR void advance_to(iterator it) - { - format_str_.remove_prefix(internal::to_unsigned(it - begin())); - } - - // Returns the next argument index. - FMT_CONSTEXPR unsigned next_arg_id(); - - FMT_CONSTEXPR bool check_arg_id(unsigned) - { - if (next_arg_id_ > 0) - { - on_error("cannot switch from automatic to manual argument indexing"); - return false; - } - next_arg_id_ = -1; - return true; - } - void check_arg_id(basic_string_view) {} - - FMT_CONSTEXPR void on_error(const char *message) - { - ErrorHandler::on_error(message); - } - - FMT_CONSTEXPR ErrorHandler error_handler() const - { - return *this; - } -}; - -typedef basic_parse_context parse_context; -typedef basic_parse_context wparse_context; - -namespace internal { -// A map from argument names to their values for named arguments. -template -class arg_map -{ -private: - FMT_DISALLOW_COPY_AND_ASSIGN(arg_map); - - typedef typename Context::char_type char_type; - - struct entry - { - basic_string_view name; - basic_format_arg arg; - }; - - entry *map_; - unsigned size_; - - void push_back(value val) - { - const internal::named_arg_base &named = val.as_named_arg(); - map_[size_] = entry{named.name, named.template deserialize()}; - ++size_; - } - -public: - arg_map() - : map_(FMT_NULL) - , size_(0) - { - } - void init(const basic_format_args &args); - ~arg_map() - { - delete[] map_; - } - - basic_format_arg find(basic_string_view name) const - { - // The list is unsorted, so just return the first matching name. - for (entry *it = map_, *end = map_ + size_; it != end; ++it) - { - if (it->name == name) - return it->arg; - } - return basic_format_arg(); - } -}; - -template -class context_base -{ -public: - typedef OutputIt iterator; - -private: - basic_parse_context parse_context_; - iterator out_; - basic_format_args args_; - -protected: - typedef Char char_type; - typedef basic_format_arg format_arg; - - context_base(OutputIt out, basic_string_view format_str, basic_format_args ctx_args) - : parse_context_(format_str) - , out_(out) - , args_(ctx_args) - { - } - - // Returns the argument with specified index. - format_arg do_get_arg(unsigned arg_id) - { - format_arg arg = args_.get(arg_id); - if (!arg) - parse_context_.on_error("argument index out of range"); - return arg; - } - - // Checks if manual indexing is used and returns the argument with - // specified index. - format_arg get_arg(unsigned arg_id) - { - return this->parse_context().check_arg_id(arg_id) ? this->do_get_arg(arg_id) : format_arg(); - } - -public: - basic_parse_context &parse_context() - { - return parse_context_; - } - - internal::error_handler error_handler() - { - return parse_context_.error_handler(); - } - - void on_error(const char *message) - { - parse_context_.on_error(message); - } - - // Returns an iterator to the beginning of the output range. - iterator out() - { - return out_; - } - iterator begin() - { - return out_; - } // deprecated - - // Advances the begin iterator to ``it``. - void advance_to(iterator it) - { - out_ = it; - } - - basic_format_args args() const - { - return args_; - } -}; - -// Extracts a reference to the container from back_insert_iterator. -template -inline Container &get_container(std::back_insert_iterator it) -{ - typedef std::back_insert_iterator bi_iterator; - struct accessor : bi_iterator - { - accessor(bi_iterator iter) - : bi_iterator(iter) - { - } - using bi_iterator::container; - }; - return *accessor(it).container; -} -} // namespace internal - -// Formatting context. -template -class basic_format_context : public internal::context_base, Char> -{ -public: - /** The character type for the output. */ - typedef Char char_type; - - // using formatter_type = formatter; - template - struct formatter_type - { - typedef formatter type; - }; - -private: - internal::arg_map map_; - - FMT_DISALLOW_COPY_AND_ASSIGN(basic_format_context); - - typedef internal::context_base base; - typedef typename base::format_arg format_arg; - using base::get_arg; - -public: - using typename base::iterator; - - /** - Constructs a ``basic_format_context`` object. References to the arguments are - stored in the object so make sure they have appropriate lifetimes. - */ - basic_format_context(OutputIt out, basic_string_view format_str, basic_format_args ctx_args) - : base(out, format_str, ctx_args) - { - } - - format_arg next_arg() - { - return this->do_get_arg(this->parse_context().next_arg_id()); - } - format_arg get_arg(unsigned arg_id) - { - return this->do_get_arg(arg_id); - } - - // Checks if manual indexing is used and returns the argument with the - // specified name. - format_arg get_arg(basic_string_view name); -}; - -template -struct buffer_context -{ - typedef basic_format_context>, Char> type; -}; -typedef buffer_context::type format_context; -typedef buffer_context::type wformat_context; - -namespace internal { -template -struct get_type -{ - typedef decltype(make_value(declval::type &>())) value_type; - static const type value = value_type::type_tag; -}; - -template -FMT_CONSTEXPR unsigned long long get_types() -{ - return 0; -} - -template -FMT_CONSTEXPR unsigned long long get_types() -{ - return get_type::value | (get_types() << 4); -} - -template -FMT_CONSTEXPR basic_format_arg make_arg(const T &value) -{ - basic_format_arg arg; - arg.type_ = get_type::value; - arg.value_ = make_value(value); - return arg; -} - -template -inline typename std::enable_if>::type make_arg(const T &value) -{ - return make_value(value); -} - -template -inline typename std::enable_if>::type make_arg(const T &value) -{ - return make_arg(value); -} -} // namespace internal - -/** - \rst - An array of references to arguments. It can be implicitly converted into - `~fmt::basic_format_args` for passing into type-erased formatting functions - such as `~fmt::vformat`. - \endrst - */ -template -class format_arg_store -{ -private: - static const size_t NUM_ARGS = sizeof...(Args); - - // Packed is a macro on MinGW so use IS_PACKED instead. - static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args; - - typedef typename std::conditional, basic_format_arg>::type value_type; - - // If the arguments are not packed, add one more element to mark the end. - static const size_t DATA_SIZE = NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1); - value_type data_[DATA_SIZE]; - - friend class basic_format_args; - - static FMT_CONSTEXPR long long get_types() - { - return IS_PACKED ? static_cast(internal::get_types()) : -static_cast(NUM_ARGS); - } - -public: -#if FMT_USE_CONSTEXPR - static constexpr long long TYPES = get_types(); -#else - static const long long TYPES; -#endif - -#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 405) || (FMT_MSC_VER && FMT_MSC_VER <= 1800) - // Workaround array initialization issues in gcc <= 4.5 and MSVC <= 2013. - format_arg_store(const Args &... args) - { - value_type init[DATA_SIZE] = {internal::make_arg(args)...}; - std::memcpy(data_, init, sizeof(init)); - } -#else - format_arg_store(const Args &... args) - : data_{internal::make_arg(args)...} - { - } -#endif -}; - -#if !FMT_USE_CONSTEXPR -template -const long long format_arg_store::TYPES = get_types(); -#endif - -/** - \rst - Constructs an `~fmt::format_arg_store` object that contains references to - arguments and can be implicitly converted to `~fmt::format_args`. `Context` - can - be omitted in which case it defaults to `~fmt::context`. - \endrst - */ -template -inline format_arg_store make_format_args(const Args &... args) -{ - return format_arg_store(args...); -} - -template -inline format_arg_store make_format_args(const Args &... args) -{ - return format_arg_store(args...); -} - -/** Formatting arguments. */ -template -class basic_format_args -{ -public: - typedef unsigned size_type; - typedef basic_format_arg format_arg; - -private: - // To reduce compiled code size per formatting function call, types of first - // max_packed_args arguments are passed in the types_ field. - unsigned long long 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 format_arg *args_; - }; - - typename internal::type type(unsigned index) const - { - unsigned shift = index * 4; - unsigned long long mask = 0xf; - return static_cast((types_ & (mask << shift)) >> shift); - } - - friend class internal::arg_map; - - void set_data(const internal::value *values) - { - values_ = values; - } - void set_data(const format_arg *args) - { - args_ = args; - } - - format_arg do_get(size_type index) const - { - long long signed_types = static_cast(types_); - if (signed_types < 0) - { - unsigned long long num_args = static_cast(-signed_types); - return index < num_args ? args_[index] : format_arg(); - } - format_arg arg; - if (index > internal::max_packed_args) - return arg; - arg.type_ = type(index); - if (arg.type_ == internal::none_type) - return arg; - internal::value &val = arg.value_; - val = values_[index]; - return arg; - } - -public: - basic_format_args() - : types_(0) - { - } - - /** - \rst - Constructs a `basic_format_args` object from `~fmt::format_arg_store`. - \endrst - */ - template - basic_format_args(const format_arg_store &store) - : types_(static_cast(store.TYPES)) - { - set_data(store.data_); - } - - /** Returns the argument at specified index. */ - format_arg get(size_type index) const - { - format_arg arg = do_get(index); - return arg.type_ == internal::named_arg_type ? arg.value_.as_named_arg().template deserialize() : arg; - } - - unsigned max_size() const - { - long long signed_types = static_cast(types_); - return static_cast(signed_types < 0 ? -signed_types : static_cast(internal::max_packed_args)); - } -}; - -/** An alias to ``basic_format_args``. */ -// It is a separate type rather than a typedef to make symbols readable. -struct format_args : basic_format_args -{ - template - format_args(Args &&... arg) - : basic_format_args(std::forward(arg)...) - { - } -}; -struct wformat_args : basic_format_args -{ - template - wformat_args(Args &&... arg) - : basic_format_args(std::forward(arg)...) - { - } -}; - -namespace internal { -template -struct named_arg_base -{ - basic_string_view name; - - // Serialized value. - mutable char data[sizeof(basic_format_arg)]; - - named_arg_base(basic_string_view nm) - : name(nm) - { - } - - template - basic_format_arg deserialize() const - { - basic_format_arg arg; - std::memcpy(&arg, data, sizeof(basic_format_arg)); - return arg; - } -}; - -template -struct named_arg : named_arg_base -{ - const T &value; - - named_arg(basic_string_view name, const T &val) - : named_arg_base(name) - , value(val) - { - } -}; -} // namespace internal - -/** - \rst - Returns a named argument to be used in a formatting function. - - **Example**:: - - fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); - \endrst - */ -template -inline internal::named_arg arg(string_view name, const T &arg) -{ - return internal::named_arg(name, arg); -} - -template -inline internal::named_arg arg(wstring_view name, const T &arg) -{ - return internal::named_arg(name, arg); -} - -// This function template is deleted intentionally to disable nested named -// arguments as in ``format("{}", arg("a", arg("b", 42)))``. -template -void arg(S, internal::named_arg) FMT_DELETED; - -#ifndef FMT_EXTENDED_COLORS -// color and (v)print_colored are deprecated. -enum color -{ - black, - red, - green, - yellow, - blue, - magenta, - cyan, - white -}; -FMT_API void vprint_colored(color c, string_view format, format_args args); -FMT_API void vprint_colored(color c, wstring_view format, wformat_args args); -template -inline void print_colored(color c, string_view format_str, const Args &... args) -{ - vprint_colored(c, format_str, make_format_args(args...)); -} -template -inline void print_colored(color c, wstring_view format_str, const Args &... args) -{ - vprint_colored(c, format_str, make_format_args(args...)); -} -#endif - -format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args); -wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args); - -template -struct is_contiguous : std::false_type -{ -}; - -template -struct is_contiguous> : std::true_type -{ -}; - -template -struct is_contiguous> : std::true_type -{ -}; - -/** Formats a string and writes the output to ``out``. */ -template -typename std::enable_if::value, std::back_insert_iterator>::type vformat_to( - std::back_insert_iterator out, string_view format_str, format_args args) -{ - auto &container = internal::get_container(out); - internal::container_buffer buf(container); - vformat_to(buf, format_str, args); - return std::back_inserter(container); -} - -template -typename std::enable_if::value, std::back_insert_iterator>::type vformat_to( - std::back_insert_iterator out, wstring_view format_str, wformat_args args) -{ - auto &container = internal::get_container(out); - internal::container_buffer buf(container); - vformat_to(buf, format_str, args); - return std::back_inserter(container); -} - -std::string vformat(string_view format_str, format_args args); -std::wstring vformat(wstring_view format_str, wformat_args args); - -/** - \rst - Formats arguments and returns the result as a string. - - **Example**:: - - #include - std::string message = fmt::format("The answer is {}", 42); - \endrst -*/ -template -inline std::string format(string_view format_str, const Args &... args) -{ - // This should be just - // return vformat(format_str, make_format_args(args...)); - // but gcc has trouble optimizing the latter, so break it down. - format_arg_store as{args...}; - return vformat(format_str, as); -} -template -inline std::wstring format(wstring_view format_str, const Args &... args) -{ - format_arg_store as{args...}; - return vformat(format_str, as); -} - -FMT_API void vprint(std::FILE *f, string_view format_str, format_args args); -FMT_API void vprint(std::FILE *f, wstring_view format_str, wformat_args args); - -/** - \rst - Prints formatted data to the file *f*. - - **Example**:: - - fmt::print(stderr, "Don't {}!", "panic"); - \endrst - */ -template -inline void print(std::FILE *f, string_view format_str, const Args &... args) -{ - format_arg_store as(args...); - vprint(f, format_str, as); -} -/** - Prints formatted data to the file *f* which should be in wide-oriented mode - set - via ``fwide(f, 1)`` or ``_setmode(_fileno(f), _O_U8TEXT)`` on Windows. - */ -template -inline void print(std::FILE *f, wstring_view format_str, const Args &... args) -{ - format_arg_store as(args...); - vprint(f, format_str, as); -} - -FMT_API void vprint(string_view format_str, format_args args); -FMT_API void vprint(wstring_view format_str, wformat_args args); - -/** - \rst - Prints formatted data to ``stdout``. - - **Example**:: - - fmt::print("Elapsed time: {0:.2f} seconds", 1.23); - \endrst - */ -template -inline void print(string_view format_str, const Args &... args) -{ - format_arg_store as{args...}; - vprint(format_str, as); -} - -template -inline void print(wstring_view format_str, const Args &... args) -{ - format_arg_store as(args...); - vprint(format_str, as); -} -FMT_END_NAMESPACE - -#endif // FMT_CORE_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/format-inl.h b/spdlog_lib/spdlog/fmt/bundled/format-inl.h deleted file mode 100644 index 1aba8c6..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/format-inl.h +++ /dev/null @@ -1,578 +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_FORMAT_INL_H_ -#define FMT_FORMAT_INL_H_ - -#include "format.h" - -#include - -#include -#include -#include -#include -#include -#include // for std::ptrdiff_t -#include - -#if defined(_WIN32) && defined(__MINGW32__) -#include -#endif - -#if FMT_USE_WINDOWS_H -#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN) -#define WIN32_LEAN_AND_MEAN -#endif -#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX) -#include -#else -#define NOMINMAX -#include -#undef NOMINMAX -#endif -#endif - -#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. -inline fmt::internal::null<> strerror_r(int, char *, ...) -{ - return fmt::internal::null<>(); -} -inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) -{ - return fmt::internal::null<>(); -} - -FMT_BEGIN_NAMESPACE - -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) - -typedef void (*FormatFunc)(internal::buffer &, int, string_view); - -// 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 != FMT_NULL && buffer_size != 0, "invalid buffer"); - - class dispatcher - { - private: - int error_code_; - char *&buffer_; - std::size_t buffer_size_; - - // A noop assignment operator to avoid bogus warnings. - void operator=(const dispatcher &) {} - - // 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: - dispatcher(int err_code, char *&buf, std::size_t buf_size) - : error_code_(err_code) - , buffer_(buf) - , buffer_size_(buf_size) - { - } - - int run() - { - return handle(strerror_r(error_code_, buffer_, buffer_size_)); - } - }; - return dispatcher(error_code, buffer, buffer_size).run(); -} - -void format_error_code(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT -{ - // Report error code making sure that the output fits into - // inline_buffer_size to avoid dynamic memory allocation and potential - // bad_alloc. - out.resize(0); - 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::int_traits::main_type main_type; - main_type abs_value = static_cast(error_code); - if (internal::is_negative(error_code)) - { - abs_value = 0 - abs_value; - ++error_code_size; - } - error_code_size += internal::count_digits(abs_value); - writer w(out); - if (message.size() <= inline_buffer_size - error_code_size) - { - w.write(message); - w.write(SEP); - } - w.write(ERROR_STR); - w.write(error_code); - assert(out.size() <= inline_buffer_size); -} - -void report_error(FormatFunc func, int error_code, string_view message) FMT_NOEXCEPT -{ - memory_buffer full_message; - func(full_message, error_code, message); - // Use Writer::data instead of Writer::c_str to avoid potential memory - // allocation. - std::fwrite(full_message.data(), full_message.size(), 1, stderr); - std::fputc('\n', stderr); -} -} // namespace - -class locale -{ -private: - std::locale locale_; - -public: - explicit locale(std::locale loc = std::locale()) - : locale_(loc) - { - } - std::locale get() - { - return locale_; - } -}; - -template -FMT_FUNC Char internal::thousands_sep(locale_provider *lp) -{ - std::locale loc = lp ? lp->locale().get() : std::locale(); - return std::use_facet>(loc).thousands_sep(); -} - -FMT_FUNC void system_error::init(int err_code, string_view format_str, format_args args) -{ - error_code_ = err_code; - memory_buffer buffer; - format_system_error(buffer, err_code, vformat(format_str, args)); - std::runtime_error &base = *this; - base = std::runtime_error(to_string(buffer)); -} - -namespace internal { -template -int char_traits::format_float(char *buffer, std::size_t size, const char *format, int precision, T value) -{ - return precision < 0 ? FMT_SNPRINTF(buffer, size, format, value) : FMT_SNPRINTF(buffer, size, format, precision, value); -} - -template -int char_traits::format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value) -{ - return precision < 0 ? FMT_SWPRINTF(buffer, size, format, value) : FMT_SWPRINTF(buffer, size, format, precision, value); -} - -template -const char basic_data::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 -const uint32_t basic_data::POWERS_OF_10_32[] = {0, FMT_POWERS_OF_10(1)}; - -template -const uint64_t basic_data::POWERS_OF_10_64[] = {0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull}; - -// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340. -// These are generated by support/compute-powers.py. -template -const uint64_t basic_data::POW10_SIGNIFICANDS[] = {0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea, - 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, - 0xd3515c2831559a83, 0x9d71ac8fada6c9b5, 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637, - 0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, - 0xc5dd44271ad3cdba, 0x936b9fcebb25c996, 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8, - 0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, - 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3, - 0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, 0xe8d4a51000000000, - 0xad78ebc5ac620000, 0x813f3978f8940984, 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245, - 0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, 0xda01ee641a708dea, - 0xa26da3999aef774a, 0xf209787bb47d6b85, 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3, - 0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, - 0x98165af37b2153df, 0xe2a0b5dc971f303a, 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a, - 0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, - 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b}; - -// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding -// to significands above. -template -const int16_t basic_data::POW10_EXPONENTS[] = {-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901, - -874, -847, -821, -794, -768, -741, -715, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -343, -316, - -289, -263, -236, -210, -183, -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, 375, - 402, 428, 455, 481, 508, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066}; - -template -const char basic_data::RESET_COLOR[] = "\x1b[0m"; -template -const wchar_t basic_data::WRESET_COLOR[] = L"\x1b[0m"; - -FMT_FUNC fp operator*(fp x, fp y) -{ - // Multiply 32-bit parts of significands. - uint64_t mask = (1ULL << 32) - 1; - uint64_t a = x.f >> 32, b = x.f & mask; - uint64_t c = y.f >> 32, d = y.f & mask; - uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; - // Compute mid 64-bit of result and round. - uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); - return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64); -} - -FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) -{ - const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10) - int index = static_cast(std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10)); - // Decimal exponent of the first (smallest) cached power of 10. - const int first_dec_exp = -348; - // Difference between two consecutive decimal exponents in cached powers of - // 10. - const int dec_exp_step = 8; - index = (index - first_dec_exp - 1) / dec_exp_step + 1; - pow10_exponent = first_dec_exp + index * dec_exp_step; - return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]); -} -} // namespace internal - -#if FMT_USE_WINDOWS_H - -FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) -{ - static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; - if (s.size() > INT_MAX) - FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG)); - int s_size = static_cast(s.size()); - if (s_size == 0) - { - // MultiByteToWideChar does not support zero length, handle separately. - buffer_.resize(1); - buffer_[0] = 0; - return; - } - - int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0); - if (length == 0) - FMT_THROW(windows_error(GetLastError(), ERROR_MSG)); - buffer_.resize(length + 1); - length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length); - if (length == 0) - FMT_THROW(windows_error(GetLastError(), ERROR_MSG)); - buffer_[length] = 0; -} - -FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) -{ - if (int error_code = convert(s)) - { - FMT_THROW(windows_error(error_code, "cannot convert string from UTF-16 to UTF-8")); - } -} - -FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) -{ - if (s.size() > INT_MAX) - return ERROR_INVALID_PARAMETER; - int s_size = static_cast(s.size()); - if (s_size == 0) - { - // WideCharToMultiByte does not support zero length, handle separately. - buffer_.resize(1); - buffer_[0] = 0; - return 0; - } - - int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL); - if (length == 0) - return GetLastError(); - buffer_.resize(length + 1); - length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL); - if (length == 0) - return GetLastError(); - buffer_[length] = 0; - return 0; -} - -FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_args args) -{ - error_code_ = err_code; - memory_buffer buffer; - internal::format_windows_error(buffer, err_code, vformat(format_str, args)); - std::runtime_error &base = *this; - base = std::runtime_error(to_string(buffer)); -} - -FMT_FUNC void internal::format_windows_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT -{ - FMT_TRY - { - wmemory_buffer buf; - buf.resize(inline_buffer_size); - for (;;) - { - wchar_t *system_message = &buf[0]; - int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL, error_code, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message, static_cast(buf.size()), FMT_NULL); - if (result != 0) - { - utf16_to_utf8 utf8_message; - if (utf8_message.convert(system_message) == ERROR_SUCCESS) - { - writer w(out); - w.write(message); - w.write(": "); - w.write(utf8_message); - return; - } - break; - } - if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) - break; // Can't get error message, report error code instead. - buf.resize(buf.size() * 2); - } - } - FMT_CATCH(...) {} - format_error_code(out, error_code, message); -} - -#endif // FMT_USE_WINDOWS_H - -FMT_FUNC void format_system_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT -{ - FMT_TRY - { - memory_buffer buf; - buf.resize(inline_buffer_size); - for (;;) - { - char *system_message = &buf[0]; - int result = safe_strerror(error_code, system_message, buf.size()); - if (result == 0) - { - writer w(out); - w.write(message); - w.write(": "); - w.write(system_message); - return; - } - if (result != ERANGE) - break; // Can't get error message, report error code instead. - buf.resize(buf.size() * 2); - } - } - FMT_CATCH(...) {} - format_error_code(out, error_code, message); -} - -template -void basic_fixed_buffer::grow(std::size_t) -{ - FMT_THROW(std::runtime_error("buffer overflow")); -} - -FMT_FUNC void internal::error_handler::on_error(const char *message) -{ - FMT_THROW(format_error(message)); -} - -FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT -{ - report_error(format_system_error, error_code, message); -} - -#if FMT_USE_WINDOWS_H -FMT_FUNC void report_windows_error(int error_code, fmt::string_view message) FMT_NOEXCEPT -{ - report_error(internal::format_windows_error, error_code, message); -} -#endif - -FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) -{ - memory_buffer buffer; - vformat_to(buffer, format_str, args); - std::fwrite(buffer.data(), 1, buffer.size(), f); -} - -FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) -{ - wmemory_buffer buffer; - vformat_to(buffer, format_str, args); - std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f); -} - -FMT_FUNC void vprint(string_view format_str, format_args args) -{ - vprint(stdout, format_str, args); -} - -FMT_FUNC void vprint(wstring_view format_str, wformat_args args) -{ - vprint(stdout, format_str, args); -} - -#ifndef FMT_EXTENDED_COLORS -FMT_FUNC void vprint_colored(color c, string_view format, format_args args) -{ - char escape[] = "\x1b[30m"; - escape[3] = static_cast('0' + c); - std::fputs(escape, stdout); - vprint(format, args); - std::fputs(internal::data::RESET_COLOR, stdout); -} - -FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args) -{ - wchar_t escape[] = L"\x1b[30m"; - escape[3] = static_cast('0' + c); - std::fputws(escape, stdout); - vprint(format, args); - std::fputws(internal::data::WRESET_COLOR, stdout); -} -#else -namespace internal { -FMT_CONSTEXPR void to_esc(uint8_t c, char out[], int offset) -{ - out[offset + 0] = static_cast('0' + c / 100); - out[offset + 1] = static_cast('0' + c / 10 % 10); - out[offset + 2] = static_cast('0' + c % 10); -} -} // namespace internal - -FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) -{ - char escape_fd[] = "\x1b[38;2;000;000;000m"; - internal::to_esc(fd.r, escape_fd, 7); - internal::to_esc(fd.g, escape_fd, 11); - internal::to_esc(fd.b, escape_fd, 15); - - std::fputs(escape_fd, stdout); - vprint(format, args); - std::fputs(internal::data::RESET_COLOR, stdout); -} - -FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) -{ - char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color - char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color - internal::to_esc(fd.r, escape_fd, 7); - internal::to_esc(fd.g, escape_fd, 11); - internal::to_esc(fd.b, escape_fd, 15); - - internal::to_esc(bg.r, escape_bg, 7); - internal::to_esc(bg.g, escape_bg, 11); - internal::to_esc(bg.b, escape_bg, 15); - - std::fputs(escape_fd, stdout); - std::fputs(escape_bg, stdout); - vprint(format, args); - std::fputs(internal::data::RESET_COLOR, stdout); -} -#endif - -FMT_FUNC locale locale_provider::locale() -{ - return fmt::locale(); -} - -FMT_END_NAMESPACE - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -#endif // FMT_FORMAT_INL_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/format.h b/spdlog_lib/spdlog/fmt/bundled/format.h deleted file mode 100644 index 60001f3..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/format.h +++ /dev/null @@ -1,4716 +0,0 @@ -/* - Formatting library for C++ - - Copyright (c) 2012 - present, 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 -#include -#include -#include -#include -#include -#include -#include - -#ifdef __clang__ -#define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) -#else -#define FMT_CLANG_VERSION 0 -#endif - -#ifdef __INTEL_COMPILER -#define FMT_ICC_VERSION __INTEL_COMPILER -#elif defined(__ICL) -#define FMT_ICC_VERSION __ICL -#else -#define FMT_ICC_VERSION 0 -#endif - -#include "core.h" - -#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION -#pragma GCC diagnostic push - -// 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 - -#ifdef _SECURE_SCL -#define FMT_SECURE_SCL _SECURE_SCL -#else -#define FMT_SECURE_SCL 0 -#endif - -#if FMT_SECURE_SCL -#include -#endif - -#ifdef __has_builtin -#define FMT_HAS_BUILTIN(x) __has_builtin(x) -#else -#define FMT_HAS_BUILTIN(x) 0 -#endif - -#ifdef __GNUC_LIBSTD__ -#define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) -#endif - -#ifndef FMT_THROW -#if FMT_EXCEPTIONS -#if FMT_MSC_VER -FMT_BEGIN_NAMESPACE -namespace internal { -template -inline void do_throw(const Exception &x) -{ - // Silence unreachable code warnings in MSVC because these are nearly - // impossible to fix in a generic code. - volatile bool b = true; - if (b) - throw x; -} -} // namespace internal -FMT_END_NAMESPACE -#define FMT_THROW(x) fmt::internal::do_throw(x) -#else -#define FMT_THROW(x) throw x -#endif -#else -#define FMT_THROW(x) \ - do \ - { \ - static_cast(sizeof(x)); \ - assert(false); \ - } while (false); -#endif -#endif - -#ifndef FMT_USE_USER_DEFINED_LITERALS -// For Intel's compiler both it and the system gcc/msc must support UDLs. -#if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) && (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1500) -#define FMT_USE_USER_DEFINED_LITERALS 1 -#else -#define FMT_USE_USER_DEFINED_LITERALS 0 -#endif -#endif - -#if FMT_USE_USER_DEFINED_LITERALS && !defined(FMT_ICC_VERSION) && \ - ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304)) -#define FMT_UDL_TEMPLATE 1 -#else -#define FMT_UDL_TEMPLATE 0 -#endif - -#ifndef FMT_USE_EXTERN_TEMPLATES -#ifndef FMT_HEADER_ONLY -#define FMT_USE_EXTERN_TEMPLATES ((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11)) -#else -#define FMT_USE_EXTERN_TEMPLATES 0 -#endif -#endif - -#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || FMT_MSC_VER >= 1600 -#define FMT_USE_TRAILING_RETURN 1 -#else -#define FMT_USE_TRAILING_RETURN 0 -#endif - -#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_rvalue_references) || FMT_MSC_VER >= 1600 -#define FMT_USE_RVALUE_REFERENCES 1 -#else -#define FMT_USE_RVALUE_REFERENCES 0 -#endif - -#ifndef FMT_USE_GRISU -#define FMT_USE_GRISU 0 -#endif - -// __builtin_clz is broken in clang with Microsoft CodeGen: -// https://github.com/fmtlib/fmt/issues/519 -#ifndef _MSC_VER -#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 -#endif - -// A workaround for gcc 4.4 that doesn't support union members with ctors. -#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 404) || (FMT_MSC_VER && FMT_MSC_VER <= 1800) -#define FMT_UNION struct -#else -#define FMT_UNION union -#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) && !defined(_MANAGED) -#include // _BitScanReverse, _BitScanReverse64 - -FMT_BEGIN_NAMESPACE -namespace internal { -// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. -#ifndef __clang__ -#pragma intrinsic(_BitScanReverse) -#endif -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) - -#if defined(_WIN64) && !defined(__clang__) -#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(x >> 32))) - return 63 - (r + 32); - - // Scan the low 32 bits. - _BitScanReverse(&r, static_cast(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) -} // namespace internal -FMT_END_NAMESPACE -#endif - -FMT_BEGIN_NAMESPACE -namespace internal { - -// An equivalent of `*reinterpret_cast(&source)` that doesn't produce -// undefined behavior (e.g. due to type aliasing). -// Example: uint64_t d = bit_cast(2.718); -template -inline Dest bit_cast(const Source &source) -{ - static_assert(sizeof(Dest) == sizeof(Source), "size mismatch"); - Dest dest; - std::memcpy(&dest, &source, sizeof(dest)); - return dest; -} - -// An implementation of begin and end for pre-C++11 compilers such as gcc 4. -template -FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin()) -{ - return c.begin(); -} -template -FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT -{ - return array; -} -template -FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end()) -{ - return c.end(); -} -template -FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT -{ - return array + N; -} - -// For std::result_of in gcc 4.4. -template -struct function -{ - template - struct result - { - typedef Result type; - }; -}; - -struct dummy_int -{ - int data[2]; - operator int() const - { - return 0; - } -}; -typedef std::numeric_limits fputil; - -// Dummy implementations of system functions such as signbit and ecvt called -// if the latter are not available. -inline dummy_int signbit(...) -{ - return dummy_int(); -} -inline dummy_int _ecvt_s(...) -{ - return dummy_int(); -} -inline dummy_int isinf(...) -{ - return dummy_int(); -} -inline dummy_int _finite(...) -{ - return dummy_int(); -} -inline dummy_int isnan(...) -{ - return dummy_int(); -} -inline dummy_int _isnan(...) -{ - return dummy_int(); -} - -// A handmade floating-point number f * pow(2, e). -class fp -{ -private: - typedef uint64_t significand_type; - - // All sizes are in bits. - static FMT_CONSTEXPR_DECL const int char_size = std::numeric_limits::digits; - // Subtract 1 to account for an implicit most significant bit in the - // normalized form. - static FMT_CONSTEXPR_DECL const int double_significand_size = std::numeric_limits::digits - 1; - static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = 1ull << double_significand_size; - -public: - significand_type f; - int e; - - static FMT_CONSTEXPR_DECL const int significand_size = sizeof(significand_type) * char_size; - - fp(uint64_t f, int e) - : f(f) - , e(e) - { - } - - // Constructs fp from an IEEE754 double. It is a template to prevent compile - // errors on platforms where double is not IEEE754. - template - explicit fp(Double d) - { - // Assume double is in the format [sign][exponent][significand]. - typedef std::numeric_limits limits; - const int double_size = sizeof(Double) * char_size; - const int exponent_size = double_size - double_significand_size - 1; // -1 for sign - const uint64_t significand_mask = implicit_bit - 1; - const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask; - const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1; - auto u = bit_cast(d); - auto biased_e = (u & exponent_mask) >> double_significand_size; - f = u & significand_mask; - if (biased_e != 0) - f += implicit_bit; - else - biased_e = 1; // Subnormals use biased exponent 1 (min exponent). - e = static_cast(biased_e - exponent_bias - double_significand_size); - } - - // Normalizes the value converted from double and multiplied by (1 << SHIFT). - template - void normalize() - { - // Handle subnormals. - auto shifted_implicit_bit = implicit_bit << SHIFT; - while ((f & shifted_implicit_bit) == 0) - { - f <<= 1; - --e; - } - // Subtract 1 to account for hidden bit. - auto offset = significand_size - double_significand_size - SHIFT - 1; - f <<= offset; - e -= offset; - } -}; - -// Returns an fp number representing x - y. Result may not be normalized. -inline fp operator-(fp x, fp y) -{ - FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands"); - return fp(x.f - y.f, x.e); -} - -// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest -// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be -// normalized. -fp operator*(fp x, fp y); - -// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its -// (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 3. -fp get_cached_power(int min_exponent, int &pow10_exponent); - -template -typename Allocator::value_type *allocate(Allocator &alloc, std::size_t n) -{ -#if __cplusplus >= 201103L || FMT_MSC_VER >= 1700 - return std::allocator_traits::allocate(alloc, n); -#else - return alloc.allocate(n); -#endif -} - -// A helper function to suppress bogus "conditional expression is constant" -// warnings. -template -inline T const_check(T value) -{ - return value; -} -} // namespace internal -FMT_END_NAMESPACE - -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 : public std::numeric_limits -{ -public: - // Portable version of isinf. - template - 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(dummy_int))) - return isinf(x) != 0; - return !_finite(static_cast(x)); - } - - // Portable version of isnan. - template - static bool isnotanumber(T x) - { - using namespace fmt::internal; - if (const_check(sizeof(isnan(x)) != sizeof(fmt::internal::dummy_int))) - return isnan(x) != 0; - return _isnan(static_cast(x)) != 0; - } - - // Portable version of signbit. - static bool isnegative(double x) - { - using namespace fmt::internal; - if (const_check(sizeof(signbit(x)) != sizeof(fmt::internal::dummy_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 - -FMT_BEGIN_NAMESPACE -template -class basic_writer; - -template -class output_range -{ -private: - OutputIt it_; - - // Unused yet. - typedef void sentinel; - sentinel end() const; - -public: - typedef OutputIt iterator; - typedef T value_type; - - explicit output_range(OutputIt it) - : it_(it) - { - } - OutputIt begin() const - { - return it_; - } -}; - -// A range where begin() returns back_insert_iterator. -template -class back_insert_range : public output_range> -{ - typedef output_range> base; - -public: - typedef typename Container::value_type value_type; - - back_insert_range(Container &c) - : base(std::back_inserter(c)) - { - } - back_insert_range(typename base::iterator it) - : base(it) - { - } -}; - -typedef basic_writer> writer; -typedef basic_writer> wwriter; - -/** A formatting error such as invalid format string. */ -class format_error : public std::runtime_error -{ -public: - explicit format_error(const char *message) - : std::runtime_error(message) - { - } - - explicit format_error(const std::string &message) - : std::runtime_error(message) - { - } -}; - -namespace internal { - -#if FMT_SECURE_SCL -template -struct checked -{ - typedef stdext::checked_array_iterator type; -}; - -// Make a checked iterator to avoid warnings on MSVC. -template -inline stdext::checked_array_iterator make_checked(T *p, std::size_t size) -{ - return {p, size}; -} -#else -template -struct checked -{ - typedef T *type; -}; -template -inline T *make_checked(T *p, std::size_t) -{ - return p; -} -#endif - -template -template -void basic_buffer::append(const U *begin, const U *end) -{ - std::size_t new_size = size_ + internal::to_unsigned(end - begin); - reserve(new_size); - std::uninitialized_copy(begin, end, internal::make_checked(ptr_, capacity_) + size_); - size_ = new_size; -} -} // namespace internal - -// A wrapper around std::locale used to reduce compile times since -// is very heavy. -class locale; - -class locale_provider -{ -public: - virtual ~locale_provider() {} - virtual fmt::locale locale(); -}; - -// The number of characters to store in the basic_memory_buffer object itself -// to avoid dynamic memory allocation. -enum -{ - inline_buffer_size = 500 -}; - -/** - \rst - A dynamically growing memory buffer for trivially copyable/constructible types - with the first ``SIZE`` elements stored in the object itself. - - You can use one of the following typedefs for common character types: - - +----------------+------------------------------+ - | Type | Definition | - +================+==============================+ - | memory_buffer | basic_memory_buffer | - +----------------+------------------------------+ - | wmemory_buffer | basic_memory_buffer | - +----------------+------------------------------+ - - **Example**:: - - fmt::memory_buffer out; - format_to(out, "The answer is {}.", 42); - - This will write the following output to the ``out`` object: - - .. code-block:: none - - The answer is 42. - - The output can be converted to an ``std::string`` with ``to_string(out)``. - \endrst - */ -template> -class basic_memory_buffer : private Allocator, public internal::basic_buffer -{ -private: - T store_[SIZE]; - - // Deallocate memory allocated by the buffer. - void deallocate() - { - T *data = this->data(); - if (data != store_) - Allocator::deallocate(data, this->capacity()); - } - -protected: - void grow(std::size_t size) FMT_OVERRIDE; - -public: - explicit basic_memory_buffer(const Allocator &alloc = Allocator()) - : Allocator(alloc) - { - this->set(store_, SIZE); - } - ~basic_memory_buffer() - { - deallocate(); - } - -private: - // Move data from other to this buffer. - void move(basic_memory_buffer &other) - { - Allocator &this_alloc = *this, &other_alloc = other; - this_alloc = std::move(other_alloc); - T *data = other.data(); - std::size_t size = other.size(), capacity = other.capacity(); - if (data == other.store_) - { - this->set(store_, capacity); - std::uninitialized_copy(other.store_, other.store_ + size, internal::make_checked(store_, capacity)); - } - else - { - this->set(data, capacity); - // Set pointer to the inline array so that delete is not called - // when deallocating. - other.set(other.store_, 0); - } - this->resize(size); - } - -public: - /** - \rst - Constructs a :class:`fmt::basic_memory_buffer` object moving the content - of the other object to it. - \endrst - */ - basic_memory_buffer(basic_memory_buffer &&other) - { - move(other); - } - - /** - \rst - Moves the content of the other ``basic_memory_buffer`` object to this one. - \endrst - */ - basic_memory_buffer &operator=(basic_memory_buffer &&other) - { - assert(this != &other); - deallocate(); - move(other); - return *this; - } - - // Returns a copy of the allocator associated with this buffer. - Allocator get_allocator() const - { - return *this; - } -}; - -template -void basic_memory_buffer::grow(std::size_t size) -{ - std::size_t old_capacity = this->capacity(); - std::size_t new_capacity = old_capacity + old_capacity / 2; - if (size > new_capacity) - new_capacity = size; - T *old_data = this->data(); - T *new_data = internal::allocate(*this, new_capacity); - // The following code doesn't throw, so the raw pointer above doesn't leak. - std::uninitialized_copy(old_data, old_data + this->size(), internal::make_checked(new_data, new_capacity)); - this->set(new_data, new_capacity); - // deallocate must not throw according to the standard, but even if it does, - // the buffer already uses the new storage and will deallocate it in - // destructor. - if (old_data != store_) - Allocator::deallocate(old_data, old_capacity); -} - -typedef basic_memory_buffer memory_buffer; -typedef basic_memory_buffer wmemory_buffer; - -/** - \rst - A fixed-size memory buffer. For a dynamically growing buffer use - :class:`fmt::basic_memory_buffer`. - - Trying to increase the buffer size past the initial capacity will throw - ``std::runtime_error``. - \endrst - */ -template -class basic_fixed_buffer : public internal::basic_buffer -{ -public: - /** - \rst - Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the - given size. - \endrst - */ - basic_fixed_buffer(Char *array, std::size_t size) - { - this->set(array, size); - } - - /** - \rst - Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the - size known at compile time. - \endrst - */ - template - explicit basic_fixed_buffer(Char (&array)[SIZE]) - { - this->set(array, SIZE); - } - -protected: - FMT_API void grow(std::size_t size) FMT_OVERRIDE; -}; - -namespace internal { - -template -struct char_traits; - -template<> -struct char_traits -{ - // Formats a floating-point number. - template - FMT_API static int format_float(char *buffer, std::size_t size, const char *format, int precision, T value); -}; - -template<> -struct char_traits -{ - template - FMT_API static int format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value); -}; - -#if FMT_USE_EXTERN_TEMPLATES -extern template int char_traits::format_float( - char *buffer, std::size_t size, const char *format, int precision, double value); -extern template int char_traits::format_float( - char *buffer, std::size_t size, const char *format, int precision, long double value); - -extern template int char_traits::format_float( - wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, double value); -extern template int char_traits::format_float( - wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, long double value); -#endif - -template -inline typename std::enable_if::value, typename checked::type>::type reserve( - std::back_insert_iterator &it, std::size_t n) -{ - Container &c = internal::get_container(it); - std::size_t size = c.size(); - c.resize(size + n); - return make_checked(&c[size], n); -} - -template -inline Iterator &reserve(Iterator &it, std::size_t) -{ - return it; -} - -template -class null_terminating_iterator; - -template -FMT_CONSTEXPR_DECL const Char *pointer_from(null_terminating_iterator it); - -// An iterator that produces a null terminator on *end. This simplifies parsing -// and allows comparing the performance of processing a null-terminated string -// vs string_view. -template -class null_terminating_iterator -{ -public: - typedef std::ptrdiff_t difference_type; - typedef Char value_type; - typedef const Char *pointer; - typedef const Char &reference; - typedef std::random_access_iterator_tag iterator_category; - - null_terminating_iterator() - : ptr_(0) - , end_(0) - { - } - - FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end) - : ptr_(ptr) - , end_(end) - { - } - - template - FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r) - : ptr_(r.begin()) - , end_(r.end()) - { - } - - null_terminating_iterator &operator=(const Char *ptr) - { - assert(ptr <= end_); - ptr_ = ptr; - return *this; - } - - FMT_CONSTEXPR Char operator*() const - { - return ptr_ != end_ ? *ptr_ : 0; - } - - FMT_CONSTEXPR null_terminating_iterator operator++() - { - ++ptr_; - return *this; - } - - FMT_CONSTEXPR null_terminating_iterator operator++(int) - { - null_terminating_iterator result(*this); - ++ptr_; - return result; - } - - FMT_CONSTEXPR null_terminating_iterator operator--() - { - --ptr_; - return *this; - } - - FMT_CONSTEXPR null_terminating_iterator operator+(difference_type n) - { - return null_terminating_iterator(ptr_ + n, end_); - } - - FMT_CONSTEXPR null_terminating_iterator operator-(difference_type n) - { - return null_terminating_iterator(ptr_ - n, end_); - } - - FMT_CONSTEXPR null_terminating_iterator operator+=(difference_type n) - { - ptr_ += n; - return *this; - } - - FMT_CONSTEXPR difference_type operator-(null_terminating_iterator other) const - { - return ptr_ - other.ptr_; - } - - FMT_CONSTEXPR bool operator!=(null_terminating_iterator other) const - { - return ptr_ != other.ptr_; - } - - bool operator>=(null_terminating_iterator other) const - { - return ptr_ >= other.ptr_; - } - - // This should be a friend specialization pointer_from but the latter - // doesn't compile by gcc 5.1 due to a compiler bug. - template - friend FMT_CONSTEXPR_DECL const CharT *pointer_from(null_terminating_iterator it); - -private: - const Char *ptr_; - const Char *end_; -}; - -template -FMT_CONSTEXPR const T *pointer_from(const T *p) -{ - return p; -} - -template -FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator it) -{ - return it.ptr_; -} - -// An output iterator that counts the number of objects written to it and -// discards them. -template -class counting_iterator -{ -private: - std::size_t count_; - mutable T blackhole_; - -public: - typedef std::output_iterator_tag iterator_category; - typedef T value_type; - typedef std::ptrdiff_t difference_type; - typedef T *pointer; - typedef T &reference; - typedef counting_iterator _Unchecked_type; // Mark iterator as checked. - - counting_iterator() - : count_(0) - { - } - - std::size_t count() const - { - return count_; - } - - counting_iterator &operator++() - { - ++count_; - return *this; - } - - counting_iterator operator++(int) - { - auto it = *this; - ++*this; - return it; - } - - T &operator*() const - { - return blackhole_; - } -}; - -// An output iterator that truncates the output and counts the number of objects -// written to it. -template -class truncating_iterator -{ -private: - typedef std::iterator_traits traits; - - OutputIt out_; - std::size_t limit_; - std::size_t count_; - mutable typename traits::value_type blackhole_; - -public: - typedef std::output_iterator_tag iterator_category; - typedef typename traits::value_type value_type; - typedef typename traits::difference_type difference_type; - typedef typename traits::pointer pointer; - typedef typename traits::reference reference; - typedef truncating_iterator _Unchecked_type; // Mark iterator as checked. - - truncating_iterator(OutputIt out, std::size_t limit) - : out_(out) - , limit_(limit) - , count_(0) - { - } - - OutputIt base() const - { - return out_; - } - std::size_t count() const - { - return count_; - } - - truncating_iterator &operator++() - { - if (count_++ < limit_) - ++out_; - return *this; - } - - truncating_iterator operator++(int) - { - auto it = *this; - ++*this; - return it; - } - - reference operator*() const - { - return count_ < limit_ ? *out_ : blackhole_; - } -}; - -// Returns true if value is negative, false otherwise. -// Same as (value < 0) but doesn't produce warnings if T is an unsigned type. -template -FMT_CONSTEXPR typename std::enable_if::is_signed, bool>::type is_negative(T value) -{ - return value < 0; -} -template -FMT_CONSTEXPR typename std::enable_if::is_signed, bool>::type is_negative(T) -{ - return false; -} - -template -struct int_traits -{ - // Smallest of uint32_t and uint64_t that is large enough to represent - // all values of T. - typedef typename std::conditional::digits <= 32, uint32_t, uint64_t>::type main_type; -}; - -// Static data is placed in this class template to allow header-only -// configuration. -template -struct FMT_API basic_data -{ - static const uint32_t POWERS_OF_10_32[]; - static const uint64_t POWERS_OF_10_64[]; - static const uint64_t POW10_SIGNIFICANDS[]; - static const int16_t POW10_EXPONENTS[]; - static const char DIGITS[]; - static const char RESET_COLOR[]; - static const wchar_t WRESET_COLOR[]; -}; - -#if FMT_USE_EXTERN_TEMPLATES -extern template struct basic_data; -#endif - -typedef basic_data<> 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 - -#if FMT_HAS_CPP_ATTRIBUTE(always_inline) -#define FMT_ALWAYS_INLINE __attribute__((always_inline)) -#else -#define FMT_ALWAYS_INLINE -#endif - -template -inline char *lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE; - -// Computes g = floor(log10(n)) and calls h.on(n); -template -inline char *lg(uint32_t n, Handler h) -{ - return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n) - : n < 1000000 ? n < 10000 ? n < 1000 ? h.template on<2>(n) : h.template on<3>(n) - : n < 100000 ? h.template on<4>(n) : h.template on<5>(n) - : n < 100000000 ? n < 10000000 ? h.template on<6>(n) : h.template on<7>(n) - : n < 1000000000 ? h.template on<8>(n) : h.template on<9>(n); -} - -// An lg handler that formats a decimal number. -// Usage: lg(n, decimal_formatter(buffer)); -class decimal_formatter -{ -private: - char *buffer_; - - void write_pair(unsigned N, uint32_t index) - { - std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2); - } - -public: - explicit decimal_formatter(char *buf) - : buffer_(buf) - { - } - - template - char *on(uint32_t u) - { - if (N == 0) - { - *buffer_ = static_cast(u) + '0'; - } - else if (N == 1) - { - write_pair(0, u); - } - else - { - // The idea of using 4.32 fixed-point numbers is based on - // https://github.com/jeaiii/itoa - unsigned n = N - 1; - unsigned a = n / 5 * n * 53 / 16; - uint64_t t = ((1ULL << (32 + a)) / data::POWERS_OF_10_32[n] + 1 - n / 9); - t = ((t * u) >> a) + n / 5 * 4; - write_pair(0, t >> 32); - for (unsigned i = 2; i < N; i += 2) - { - t = 100ULL * static_cast(t); - write_pair(i, t >> 32); - } - if (N % 2 == 0) - { - buffer_[N] = static_cast((10ULL * static_cast(t)) >> 32) + '0'; - } - } - return buffer_ += N + 1; - } -}; - -// An lg handler that formats a decimal number with a terminating null. -class decimal_formatter_null : public decimal_formatter -{ -public: - explicit decimal_formatter_null(char *buf) - : decimal_formatter(buf) - { - } - - template - char *on(uint32_t u) - { - char *buf = decimal_formatter::on(u); - *buf = '\0'; - return buf; - } -}; - -#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 no_thousands_sep -{ - typedef char char_type; - - template - void operator()(Char *) - { - } -}; - -// A functor that adds a thousands separator. -template -class add_thousands_sep -{ -private: - basic_string_view sep_; - - // Index of a decimal digit with the least significant digit having index 0. - unsigned digit_index_; - -public: - typedef Char char_type; - - explicit add_thousands_sep(basic_string_view sep) - : sep_(sep) - , digit_index_(0) - { - } - - void operator()(Char *&buffer) - { - if (++digit_index_ % 3 != 0) - return; - buffer -= sep_.size(); - std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), internal::make_checked(buffer, sep_.size())); - } -}; - -template -FMT_API Char thousands_sep(locale_provider *lp); - -// 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 -inline Char *format_decimal(Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep) -{ - buffer += num_digits; - Char *end = buffer; - 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((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('0' + value); - return end; - } - unsigned index = static_cast(value * 2); - *--buffer = data::DIGITS[index + 1]; - thousands_sep(buffer); - *--buffer = data::DIGITS[index]; - return end; -} - -template -inline Iterator format_decimal(Iterator out, UInt value, unsigned num_digits, ThousandsSep sep) -{ - typedef typename ThousandsSep::char_type char_type; - // Buffer should be large enough to hold all digits (digits10 + 1) and null. - char_type buffer[std::numeric_limits::digits10 + 2]; - format_decimal(buffer, value, num_digits, sep); - return std::copy_n(buffer, num_digits, out); -} - -template -inline It format_decimal(It out, UInt value, unsigned num_digits) -{ - return format_decimal(out, value, num_digits, no_thousands_sep()); -} - -template -inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits, bool upper = false) -{ - buffer += num_digits; - Char *end = buffer; - do - { - const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; - unsigned digit = (value & ((1 << BASE_BITS) - 1)); - *--buffer = BASE_BITS < 4 ? static_cast('0' + digit) : digits[digit]; - } while ((value >>= BASE_BITS) != 0); - return end; -} - -template -inline It format_uint(It out, UInt value, unsigned num_digits, bool upper = false) -{ - // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1) - // and null. - char buffer[std::numeric_limits::digits / BASE_BITS + 2]; - format_uint(buffer, value, num_digits, upper); - return std::copy_n(buffer, num_digits, out); -} - -#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 utf8_to_utf16 -{ -private: - wmemory_buffer buffer_; - -public: - FMT_API explicit utf8_to_utf16(string_view s); - operator wstring_view() const - { - return wstring_view(&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 utf16_to_utf8 -{ -private: - memory_buffer buffer_; - -public: - utf16_to_utf8() {} - FMT_API explicit utf16_to_utf8(wstring_view s); - operator string_view() const - { - return string_view(&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(wstring_view s); -}; - -FMT_API void format_windows_error(fmt::internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT; -#endif - -template -struct null -{ -}; -} // namespace internal - -struct monostate -{ -}; - -/** - \rst - Visits an argument dispatching to the appropriate visit method based on - the argument type. For example, if the argument type is ``double`` then - ``vis(value)`` will be called with the value of type ``double``. - \endrst - */ -template -FMT_CONSTEXPR typename internal::result_of::type visit(Visitor &&vis, basic_format_arg arg) -{ - typedef typename Context::char_type char_type; - switch (arg.type_) - { - case internal::none_type: - break; - case internal::named_arg_type: - FMT_ASSERT(false, "invalid argument type"); - break; - case internal::int_type: - return vis(arg.value_.int_value); - case internal::uint_type: - return vis(arg.value_.uint_value); - case internal::long_long_type: - return vis(arg.value_.long_long_value); - case internal::ulong_long_type: - return vis(arg.value_.ulong_long_value); - case internal::bool_type: - return vis(arg.value_.int_value != 0); - case internal::char_type: - return vis(static_cast(arg.value_.int_value)); - case internal::double_type: - return vis(arg.value_.double_value); - case internal::long_double_type: - return vis(arg.value_.long_double_value); - case internal::cstring_type: - return vis(arg.value_.string.value); - case internal::string_type: - return vis(basic_string_view(arg.value_.string.value, arg.value_.string.size)); - case internal::pointer_type: - return vis(arg.value_.pointer); - case internal::custom_type: - return vis(typename basic_format_arg::handle(arg.value_.custom)); - } - return vis(monostate()); -} - -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 -}; - -enum format_spec_tag -{ - fill_tag, - align_tag, - width_tag, - type_tag -}; - -// Format specifier. -template -class format_spec -{ -private: - T value_; - -public: - typedef T value_type; - - explicit format_spec(T value) - : value_(value) - { - } - - T value() const - { - return value_; - } -}; - -// template -// typedef format_spec fill_spec; -template -class fill_spec : public format_spec -{ -public: - explicit fill_spec(Char value) - : format_spec(value) - { - } -}; - -typedef format_spec width_spec; -typedef format_spec type_spec; - -// An empty format specifier. -struct empty_spec -{ -}; - -// An alignment specifier. -struct align_spec : empty_spec -{ - unsigned width_; - // Fill is always wchar_t and cast to char if necessary to avoid having - // two specialization of AlignSpec and its subclasses. - wchar_t fill_; - alignment align_; - - FMT_CONSTEXPR align_spec(unsigned width, wchar_t fill, alignment align = ALIGN_DEFAULT) - : width_(width) - , fill_(fill) - , align_(align) - { - } - - FMT_CONSTEXPR unsigned width() const - { - return width_; - } - FMT_CONSTEXPR wchar_t fill() const - { - return fill_; - } - FMT_CONSTEXPR alignment align() const - { - return align_; - } - - int precision() const - { - return -1; - } -}; - -// Format specifiers. -template -class basic_format_specs : public align_spec -{ -public: - unsigned flags_; - int precision_; - Char type_; - - FMT_CONSTEXPR basic_format_specs(unsigned width = 0, char type = 0, wchar_t fill = ' ') - : align_spec(width, fill) - , flags_(0) - , precision_(-1) - , type_(type) - { - } - - FMT_CONSTEXPR bool flag(unsigned f) const - { - return (flags_ & f) != 0; - } - FMT_CONSTEXPR int precision() const - { - return precision_; - } - FMT_CONSTEXPR Char type() const - { - return type_; - } -}; - -typedef basic_format_specs format_specs; - -template -FMT_CONSTEXPR unsigned basic_parse_context::next_arg_id() -{ - if (next_arg_id_ >= 0) - return internal::to_unsigned(next_arg_id_++); - on_error("cannot switch from manual to automatic argument indexing"); - return 0; -} - -struct format_string -{ -}; - -namespace internal { - -template -FMT_CONSTEXPR void handle_int_type_spec(Char spec, Handler &&handler) -{ - switch (spec) - { - case 0: - case 'd': - handler.on_dec(); - break; - case 'x': - case 'X': - handler.on_hex(); - break; - case 'b': - case 'B': - handler.on_bin(); - break; - case 'o': - handler.on_oct(); - break; - case 'n': - handler.on_num(); - break; - default: - handler.on_error(); - } -} - -template -FMT_CONSTEXPR void handle_float_type_spec(Char spec, Handler &&handler) -{ - switch (spec) - { - case 0: - case 'g': - case 'G': - handler.on_general(); - break; - case 'e': - case 'E': - handler.on_exp(); - break; - case 'f': - case 'F': - handler.on_fixed(); - break; - case 'a': - case 'A': - handler.on_hex(); - break; - default: - handler.on_error(); - break; - } -} - -template -FMT_CONSTEXPR void handle_char_specs(const basic_format_specs &specs, Handler &&handler) -{ - if (specs.type() && specs.type() != 'c') - { - handler.on_int(); - return; - } - if (specs.align() == ALIGN_NUMERIC || specs.flag(~0u) != 0) - handler.on_error("invalid format specifier for char"); - handler.on_char(); -} - -template -FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler) -{ - if (spec == 0 || spec == 's') - handler.on_string(); - else if (spec == 'p') - handler.on_pointer(); - else - handler.on_error("invalid type specifier"); -} - -template -FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh) -{ - if (spec != 0 && spec != 's') - eh.on_error("invalid type specifier"); -} - -template -FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh) -{ - if (spec != 0 && spec != 'p') - eh.on_error("invalid type specifier"); -} - -template -class int_type_checker : private ErrorHandler -{ -public: - FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) - : ErrorHandler(eh) - { - } - - FMT_CONSTEXPR void on_dec() {} - FMT_CONSTEXPR void on_hex() {} - FMT_CONSTEXPR void on_bin() {} - FMT_CONSTEXPR void on_oct() {} - FMT_CONSTEXPR void on_num() {} - - FMT_CONSTEXPR void on_error() - { - ErrorHandler::on_error("invalid type specifier"); - } -}; - -template -class float_type_checker : private ErrorHandler -{ -public: - FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh) - : ErrorHandler(eh) - { - } - - FMT_CONSTEXPR void on_general() {} - FMT_CONSTEXPR void on_exp() {} - FMT_CONSTEXPR void on_fixed() {} - FMT_CONSTEXPR void on_hex() {} - - FMT_CONSTEXPR void on_error() - { - ErrorHandler::on_error("invalid type specifier"); - } -}; - -template -class char_specs_checker : public ErrorHandler -{ -private: - CharType type_; - -public: - FMT_CONSTEXPR char_specs_checker(CharType type, ErrorHandler eh) - : ErrorHandler(eh) - , type_(type) - { - } - - FMT_CONSTEXPR void on_int() - { - handle_int_type_spec(type_, int_type_checker(*this)); - } - FMT_CONSTEXPR void on_char() {} -}; - -template -class cstring_type_checker : public ErrorHandler -{ -public: - FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh) - : ErrorHandler(eh) - { - } - - FMT_CONSTEXPR void on_string() {} - FMT_CONSTEXPR void on_pointer() {} -}; - -template -void arg_map::init(const basic_format_args &args) -{ - if (map_) - return; - map_ = new entry[args.max_size()]; - bool use_values = args.type(max_packed_args - 1) == internal::none_type; - if (use_values) - { - for (unsigned i = 0; /*nothing*/; ++i) - { - internal::type arg_type = args.type(i); - switch (arg_type) - { - case internal::none_type: - return; - case internal::named_arg_type: - push_back(args.values_[i]); - break; - default: - break; // Do nothing. - } - } - return; - } - for (unsigned i = 0;; ++i) - { - switch (args.args_[i].type_) - { - case internal::none_type: - return; - case internal::named_arg_type: - push_back(args.args_[i].value_); - break; - default: - break; // Do nothing. - } - } -} - -template -class arg_formatter_base -{ -public: - typedef typename Range::value_type char_type; - typedef decltype(internal::declval().begin()) iterator; - typedef basic_format_specs format_specs; - -private: - typedef basic_writer writer_type; - writer_type writer_; - format_specs &specs_; - - FMT_DISALLOW_COPY_AND_ASSIGN(arg_formatter_base); - - struct char_writer - { - char_type value; - template - void operator()(It &&it) const - { - *it++ = value; - } - }; - - void write_char(char_type value) - { - writer_.write_padded(1, specs_, char_writer{value}); - } - - void write_pointer(const void *p) - { - format_specs specs = specs_; - specs.flags_ = HASH_FLAG; - specs.type_ = 'x'; - writer_.write_int(reinterpret_cast(p), specs); - } - -protected: - writer_type &writer() - { - return writer_; - } - format_specs &spec() - { - return specs_; - } - iterator out() - { - return writer_.out(); - } - - void write(bool value) - { - writer_.write_str(string_view(value ? "true" : "false"), specs_); - } - - void write(const char_type *value) - { - if (!value) - FMT_THROW(format_error("string pointer is null")); - auto length = std::char_traits::length(value); - writer_.write_str(basic_string_view(value, length), specs_); - } - -public: - arg_formatter_base(Range r, format_specs &s) - : writer_(r) - , specs_(s) - { - } - - iterator operator()(monostate) - { - FMT_ASSERT(false, "invalid argument type"); - return out(); - } - - template - typename std::enable_if::value, iterator>::type operator()(T value) - { - // MSVC2013 fails to compile separate overloads for bool and char_type so - // use std::is_same instead. - if (std::is_same::value) - { - if (specs_.type_) - return (*this)(value ? 1 : 0); - write(value != 0); - } - else if (std::is_same::value) - { - internal::handle_char_specs(specs_, char_spec_handler(*this, static_cast(value))); - } - else - { - writer_.write_int(value, specs_); - } - return out(); - } - - template - typename std::enable_if::value, iterator>::type operator()(T value) - { - writer_.write_double(value, specs_); - return out(); - } - - struct char_spec_handler : internal::error_handler - { - arg_formatter_base &formatter; - char_type value; - - char_spec_handler(arg_formatter_base &f, char_type val) - : formatter(f) - , value(val) - { - } - - void on_int() - { - formatter.writer_.write_int(value, formatter.specs_); - } - void on_char() - { - formatter.write_char(value); - } - }; - - struct cstring_spec_handler : internal::error_handler - { - arg_formatter_base &formatter; - const char_type *value; - - cstring_spec_handler(arg_formatter_base &f, const char_type *val) - : formatter(f) - , value(val) - { - } - - void on_string() - { - formatter.write(value); - } - void on_pointer() - { - formatter.write_pointer(value); - } - }; - - iterator operator()(const char_type *value) - { - internal::handle_cstring_type_spec(specs_.type_, cstring_spec_handler(*this, value)); - return out(); - } - - iterator operator()(basic_string_view value) - { - internal::check_string_type_spec(specs_.type_, internal::error_handler()); - writer_.write_str(value, specs_); - return out(); - } - - iterator operator()(const void *value) - { - check_pointer_type_spec(specs_.type_, internal::error_handler()); - write_pointer(value); - return out(); - } -}; - -template -struct is_format_string : std::integral_constant::value> -{ -}; - -template -FMT_CONSTEXPR bool is_name_start(Char c) -{ - return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; -} - -// Parses the input as an unsigned integer. This function assumes that the -// first character is a digit and presence of a non-digit character at the end. -// it: an iterator pointing to the beginning of the input range. -template -FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) -{ - assert('0' <= *it && *it <= '9'); - unsigned value = 0; - // Convert to unsigned to prevent a warning. - unsigned max_int = (std::numeric_limits::max)(); - unsigned big = max_int / 10; - do - { - // Check for overflow. - if (value > big) - { - value = max_int + 1; - break; - } - value = value * 10 + unsigned(*it - '0'); - // Workaround for MSVC "setup_exception stack overflow" error: - auto next = it; - ++next; - it = next; - } while ('0' <= *it && *it <= '9'); - if (value > max_int) - eh.on_error("number is too big"); - return value; -} - -template -class custom_formatter : public function -{ -private: - Context &ctx_; - -public: - explicit custom_formatter(Context &ctx) - : ctx_(ctx) - { - } - - bool operator()(typename basic_format_arg::handle h) const - { - h.format(ctx_); - return true; - } - - template - bool operator()(T) const - { - return false; - } -}; - -template -struct is_integer -{ - enum - { - value = - std::is_integral::value && !std::is_same::value && !std::is_same::value && !std::is_same::value - }; -}; - -template -class width_checker : public function -{ -public: - explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh) - : handler_(eh) - { - } - - template - FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T value) - { - if (is_negative(value)) - handler_.on_error("negative width"); - return static_cast(value); - } - - template - FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T) - { - handler_.on_error("width is not integer"); - return 0; - } - -private: - ErrorHandler &handler_; -}; - -template -class precision_checker : public function -{ -public: - explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh) - : handler_(eh) - { - } - - template - FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T value) - { - if (is_negative(value)) - handler_.on_error("negative precision"); - return static_cast(value); - } - - template - FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T) - { - handler_.on_error("precision is not integer"); - return 0; - } - -private: - ErrorHandler &handler_; -}; - -// A format specifier handler that sets fields in basic_format_specs. -template -class specs_setter -{ -public: - explicit FMT_CONSTEXPR specs_setter(basic_format_specs &specs) - : specs_(specs) - { - } - - FMT_CONSTEXPR specs_setter(const specs_setter &other) - : specs_(other.specs_) - { - } - - FMT_CONSTEXPR void on_align(alignment align) - { - specs_.align_ = align; - } - FMT_CONSTEXPR void on_fill(Char fill) - { - specs_.fill_ = fill; - } - FMT_CONSTEXPR void on_plus() - { - specs_.flags_ |= SIGN_FLAG | PLUS_FLAG; - } - FMT_CONSTEXPR void on_minus() - { - specs_.flags_ |= MINUS_FLAG; - } - FMT_CONSTEXPR void on_space() - { - specs_.flags_ |= SIGN_FLAG; - } - FMT_CONSTEXPR void on_hash() - { - specs_.flags_ |= HASH_FLAG; - } - - FMT_CONSTEXPR void on_zero() - { - specs_.align_ = ALIGN_NUMERIC; - specs_.fill_ = '0'; - } - - FMT_CONSTEXPR void on_width(unsigned width) - { - specs_.width_ = width; - } - FMT_CONSTEXPR void on_precision(unsigned precision) - { - specs_.precision_ = static_cast(precision); - } - FMT_CONSTEXPR void end_precision() {} - - FMT_CONSTEXPR void on_type(Char type) - { - specs_.type_ = type; - } - -protected: - basic_format_specs &specs_; -}; - -// A format specifier handler that checks if specifiers are consistent with the -// argument type. -template -class specs_checker : public Handler -{ -public: - FMT_CONSTEXPR specs_checker(const Handler &handler, internal::type arg_type) - : Handler(handler) - , arg_type_(arg_type) - { - } - - FMT_CONSTEXPR specs_checker(const specs_checker &other) - : Handler(other) - , arg_type_(other.arg_type_) - { - } - - FMT_CONSTEXPR void on_align(alignment align) - { - if (align == ALIGN_NUMERIC) - require_numeric_argument(); - Handler::on_align(align); - } - - FMT_CONSTEXPR void on_plus() - { - check_sign(); - Handler::on_plus(); - } - - FMT_CONSTEXPR void on_minus() - { - check_sign(); - Handler::on_minus(); - } - - FMT_CONSTEXPR void on_space() - { - check_sign(); - Handler::on_space(); - } - - FMT_CONSTEXPR void on_hash() - { - require_numeric_argument(); - Handler::on_hash(); - } - - FMT_CONSTEXPR void on_zero() - { - require_numeric_argument(); - Handler::on_zero(); - } - - FMT_CONSTEXPR void end_precision() - { - if (is_integral(arg_type_) || arg_type_ == pointer_type) - this->on_error("precision not allowed for this argument type"); - } - -private: - FMT_CONSTEXPR void require_numeric_argument() - { - if (!is_arithmetic(arg_type_)) - this->on_error("format specifier requires numeric argument"); - } - - FMT_CONSTEXPR void check_sign() - { - require_numeric_argument(); - if (is_integral(arg_type_) && arg_type_ != int_type && arg_type_ != long_long_type && arg_type_ != internal::char_type) - { - this->on_error("format specifier requires signed argument"); - } - } - - internal::type arg_type_; -}; - -template class Handler, typename T, typename Context, typename ErrorHandler> -FMT_CONSTEXPR void set_dynamic_spec(T &value, basic_format_arg arg, ErrorHandler eh) -{ - unsigned long long big_value = visit(Handler(eh), arg); - if (big_value > (std::numeric_limits::max)()) - eh.on_error("number is too big"); - value = static_cast(big_value); -} - -struct auto_id -{ -}; - -// The standard format specifier handler with checking. -template -class specs_handler : public specs_setter -{ -public: - typedef typename Context::char_type char_type; - - FMT_CONSTEXPR specs_handler(basic_format_specs &specs, Context &ctx) - : specs_setter(specs) - , context_(ctx) - { - } - - template - FMT_CONSTEXPR void on_dynamic_width(Id arg_id) - { - set_dynamic_spec(this->specs_.width_, get_arg(arg_id), context_.error_handler()); - } - - template - FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) - { - set_dynamic_spec(this->specs_.precision_, get_arg(arg_id), context_.error_handler()); - } - - void on_error(const char *message) - { - context_.on_error(message); - } - -private: - FMT_CONSTEXPR basic_format_arg get_arg(auto_id) - { - return context_.next_arg(); - } - - template - FMT_CONSTEXPR basic_format_arg get_arg(Id arg_id) - { - context_.parse_context().check_arg_id(arg_id); - return context_.get_arg(arg_id); - } - - Context &context_; -}; - -// An argument reference. -template -struct arg_ref -{ - enum Kind - { - NONE, - INDEX, - NAME - }; - - FMT_CONSTEXPR arg_ref() - : kind(NONE) - , index(0) - { - } - FMT_CONSTEXPR explicit arg_ref(unsigned index) - : kind(INDEX) - , index(index) - { - } - explicit arg_ref(basic_string_view name) - : kind(NAME) - , name(name) - { - } - - FMT_CONSTEXPR arg_ref &operator=(unsigned idx) - { - kind = INDEX; - index = idx; - return *this; - } - - Kind kind; - FMT_UNION - { - unsigned index; - basic_string_view name; - }; -}; - -// Format specifiers with width and precision resolved at formatting rather -// than parsing time to allow re-using the same parsed specifiers with -// differents sets of arguments (precompilation of format strings). -template -struct dynamic_format_specs : basic_format_specs -{ - arg_ref width_ref; - arg_ref precision_ref; -}; - -// Format spec handler that saves references to arguments representing dynamic -// width and precision to be resolved at formatting time. -template -class dynamic_specs_handler : public specs_setter -{ -public: - typedef typename ParseContext::char_type char_type; - - FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs &specs, ParseContext &ctx) - : specs_setter(specs) - , specs_(specs) - , context_(ctx) - { - } - - FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other) - : specs_setter(other) - , specs_(other.specs_) - , context_(other.context_) - { - } - - template - FMT_CONSTEXPR void on_dynamic_width(Id arg_id) - { - specs_.width_ref = make_arg_ref(arg_id); - } - - template - FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) - { - specs_.precision_ref = make_arg_ref(arg_id); - } - - FMT_CONSTEXPR void on_error(const char *message) - { - context_.on_error(message); - } - -private: - typedef arg_ref arg_ref_type; - - template - FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) - { - context_.check_arg_id(arg_id); - return arg_ref_type(arg_id); - } - - FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) - { - return arg_ref_type(context_.next_arg_id()); - } - - dynamic_format_specs &specs_; - ParseContext &context_; -}; - -template -FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler) -{ - typedef typename std::iterator_traits::value_type char_type; - char_type c = *it; - if (c == '}' || c == ':') - { - handler(); - return it; - } - if (c >= '0' && c <= '9') - { - unsigned index = parse_nonnegative_int(it, handler); - if (*it != '}' && *it != ':') - { - handler.on_error("invalid format string"); - return it; - } - handler(index); - return it; - } - if (!is_name_start(c)) - { - handler.on_error("invalid format string"); - return it; - } - auto start = it; - do - { - c = *++it; - } while (is_name_start(c) || ('0' <= c && c <= '9')); - handler(basic_string_view(pointer_from(start), to_unsigned(it - start))); - return it; -} - -// Adapts SpecHandler to IDHandler API for dynamic width. -template -struct width_adapter -{ - explicit FMT_CONSTEXPR width_adapter(SpecHandler &h) - : handler(h) - { - } - - FMT_CONSTEXPR void operator()() - { - handler.on_dynamic_width(auto_id()); - } - FMT_CONSTEXPR void operator()(unsigned id) - { - handler.on_dynamic_width(id); - } - FMT_CONSTEXPR void operator()(basic_string_view id) - { - handler.on_dynamic_width(id); - } - - FMT_CONSTEXPR void on_error(const char *message) - { - handler.on_error(message); - } - - SpecHandler &handler; -}; - -// Adapts SpecHandler to IDHandler API for dynamic precision. -template -struct precision_adapter -{ - explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h) - : handler(h) - { - } - - FMT_CONSTEXPR void operator()() - { - handler.on_dynamic_precision(auto_id()); - } - FMT_CONSTEXPR void operator()(unsigned id) - { - handler.on_dynamic_precision(id); - } - FMT_CONSTEXPR void operator()(basic_string_view id) - { - handler.on_dynamic_precision(id); - } - - FMT_CONSTEXPR void on_error(const char *message) - { - handler.on_error(message); - } - - SpecHandler &handler; -}; - -// Parses standard format specifiers and sends notifications about parsed -// components to handler. -// it: an iterator pointing to the beginning of a null-terminated range of -// characters, possibly emulated via null_terminating_iterator, representing -// format specifiers. -template -FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler) -{ - typedef typename std::iterator_traits::value_type char_type; - char_type c = *it; - if (c == '}' || !c) - return it; - - // Parse fill and alignment. - alignment align = ALIGN_DEFAULT; - int i = 1; - do - { - auto p = it + i; - switch (*p) - { - case '<': - align = ALIGN_LEFT; - break; - case '>': - align = ALIGN_RIGHT; - break; - case '=': - align = ALIGN_NUMERIC; - break; - case '^': - align = ALIGN_CENTER; - break; - } - if (align != ALIGN_DEFAULT) - { - if (p != it) - { - if (c == '{') - { - handler.on_error("invalid fill character '{'"); - return it; - } - it += 2; - handler.on_fill(c); - } - else - ++it; - handler.on_align(align); - break; - } - } while (--i >= 0); - - // Parse sign. - switch (*it) - { - case '+': - handler.on_plus(); - ++it; - break; - case '-': - handler.on_minus(); - ++it; - break; - case ' ': - handler.on_space(); - ++it; - break; - } - - if (*it == '#') - { - handler.on_hash(); - ++it; - } - - // Parse zero flag. - if (*it == '0') - { - handler.on_zero(); - ++it; - } - - // Parse width. - if ('0' <= *it && *it <= '9') - { - handler.on_width(parse_nonnegative_int(it, handler)); - } - else if (*it == '{') - { - it = parse_arg_id(it + 1, width_adapter(handler)); - if (*it++ != '}') - { - handler.on_error("invalid format string"); - return it; - } - } - - // Parse precision. - if (*it == '.') - { - ++it; - if ('0' <= *it && *it <= '9') - { - handler.on_precision(parse_nonnegative_int(it, handler)); - } - else if (*it == '{') - { - it = parse_arg_id(it + 1, precision_adapter(handler)); - if (*it++ != '}') - { - handler.on_error("invalid format string"); - return it; - } - } - else - { - handler.on_error("missing precision specifier"); - return it; - } - handler.end_precision(); - } - - // Parse type. - if (*it != '}' && *it) - handler.on_type(*it++); - return it; -} - -template -struct id_adapter -{ - FMT_CONSTEXPR explicit id_adapter(Handler &h) - : handler(h) - { - } - - FMT_CONSTEXPR void operator()() - { - handler.on_arg_id(); - } - FMT_CONSTEXPR void operator()(unsigned id) - { - handler.on_arg_id(id); - } - FMT_CONSTEXPR void operator()(basic_string_view id) - { - handler.on_arg_id(id); - } - - FMT_CONSTEXPR void on_error(const char *message) - { - handler.on_error(message); - } - - Handler &handler; -}; - -template -FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler) -{ - typedef typename std::iterator_traits::value_type char_type; - auto start = it; - while (*it) - { - char_type ch = *it++; - if (ch != '{' && ch != '}') - continue; - if (*it == ch) - { - handler.on_text(start, it); - start = ++it; - continue; - } - if (ch == '}') - { - handler.on_error("unmatched '}' in format string"); - return; - } - handler.on_text(start, it - 1); - - it = parse_arg_id(it, id_adapter(handler)); - if (*it == '}') - { - handler.on_replacement_field(it); - } - else if (*it == ':') - { - ++it; - it = handler.on_format_specs(it); - if (*it != '}') - { - handler.on_error("unknown format specifier"); - return; - } - } - else - { - handler.on_error("missing '}' in format string"); - return; - } - - start = ++it; - } - handler.on_text(start, it); -} - -template -FMT_CONSTEXPR const typename ParseContext::char_type *parse_format_specs(ParseContext &ctx) -{ - // GCC 7.2 requires initializer. - formatter f{}; - return f.parse(ctx); -} - -template -class format_string_checker -{ -public: - explicit FMT_CONSTEXPR format_string_checker(basic_string_view format_str, ErrorHandler eh) - : arg_id_(-1) - , context_(format_str, eh) - , parse_funcs_{&parse_format_specs...} - { - } - - FMT_CONSTEXPR void on_text(const Char *, const Char *) {} - - FMT_CONSTEXPR void on_arg_id() - { - arg_id_ = context_.next_arg_id(); - check_arg_id(); - } - FMT_CONSTEXPR void on_arg_id(unsigned id) - { - arg_id_ = id; - context_.check_arg_id(id); - check_arg_id(); - } - FMT_CONSTEXPR void on_arg_id(basic_string_view) {} - - FMT_CONSTEXPR void on_replacement_field(const Char *) {} - - FMT_CONSTEXPR const Char *on_format_specs(const Char *s) - { - context_.advance_to(s); - return to_unsigned(arg_id_) < NUM_ARGS ? parse_funcs_[arg_id_](context_) : s; - } - - FMT_CONSTEXPR void on_error(const char *message) - { - context_.on_error(message); - } - -private: - typedef basic_parse_context parse_context_type; - enum - { - NUM_ARGS = sizeof...(Args) - }; - - FMT_CONSTEXPR void check_arg_id() - { - if (internal::to_unsigned(arg_id_) >= NUM_ARGS) - context_.on_error("argument index out of range"); - } - - // Format specifier parsing function. - typedef const Char *(*parse_func)(parse_context_type &); - - int arg_id_; - parse_context_type context_; - parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1]; -}; - -template -FMT_CONSTEXPR bool check_format_string(basic_string_view s, ErrorHandler eh = ErrorHandler()) -{ - format_string_checker checker(s, eh); - parse_format_string(s.begin(), checker); - return true; -} - -template -void check_format_string(String format_str) -{ - FMT_CONSTEXPR_DECL bool invalid_format = - internal::check_format_string(string_view(format_str.data(), format_str.size())); - (void)invalid_format; -} - -// Specifies whether to format T using the standard formatter. -// It is not possible to use get_type in formatter specialization directly -// because of a bug in MSVC. -template -struct format_type : std::integral_constant::value != custom_type> -{ -}; - -// Specifies whether to format enums. -template -struct format_enum : std::integral_constant::value> -{ -}; - -template class Handler, typename Spec, typename Context> -void handle_dynamic_spec(Spec &value, arg_ref ref, Context &ctx) -{ - typedef typename Context::char_type char_type; - switch (ref.kind) - { - case arg_ref::NONE: - break; - case arg_ref::INDEX: - internal::set_dynamic_spec(value, ctx.get_arg(ref.index), ctx.error_handler()); - break; - case arg_ref::NAME: - internal::set_dynamic_spec(value, ctx.get_arg(ref.name), ctx.error_handler()); - break; - } -} -} // namespace internal - -/** The default argument formatter. */ -template -class arg_formatter : public internal::function::iterator>, - public internal::arg_formatter_base -{ -private: - typedef typename Range::value_type char_type; - typedef internal::arg_formatter_base base; - typedef basic_format_context context_type; - - context_type &ctx_; - -public: - typedef Range range; - typedef typename base::iterator iterator; - typedef typename base::format_specs format_specs; - - /** - \rst - Constructs an argument formatter object. - *ctx* is a reference to the formatting context, - *spec* contains format specifier information for standard argument types. - \endrst - */ - arg_formatter(context_type &ctx, format_specs &spec) - : base(Range(ctx.out()), spec) - , ctx_(ctx) - { - } - - using base::operator(); - - /** Formats an argument of a user-defined type. */ - iterator operator()(typename basic_format_arg::handle handle) - { - handle.format(ctx_); - return this->out(); - } -}; - -/** - An error returned by an operating system or a language runtime, - for example a file opening error. -*/ -class system_error : public std::runtime_error -{ -private: - FMT_API void init(int err_code, string_view format_str, format_args args); - -protected: - int error_code_; - - system_error() - : std::runtime_error("") - { - } - -public: - /** - \rst - Constructs a :class:`fmt::system_error` 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 system_error 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::system_error(errno, "cannot open file '{}'", filename); - \endrst - */ - template - system_error(int error_code, string_view message, const Args &... args) - : std::runtime_error("") - { - init(error_code, message, make_format_args(args...)); - } - - 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:: - **: ** - - where ** is the passed message and ** 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(internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT; - -/** - This template provides operations for formatting and writing data into a - character range. - */ -template -class basic_writer -{ -public: - typedef typename Range::value_type char_type; - typedef decltype(internal::declval().begin()) iterator; - typedef basic_format_specs format_specs; - -private: - // Output iterator. - iterator out_; - - std::unique_ptr locale_; - - FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer); - - iterator out() const - { - return out_; - } - - // Attempts to reserve space for n extra characters in the output range. - // Returns a pointer to the reserved range or a reference to out_. - auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) - { - return internal::reserve(out_, n); - } - - // Writes a value in the format - // - // where is written by f(it). - template - void write_padded(std::size_t size, const align_spec &spec, F f); - - template - struct padded_int_writer - { - string_view prefix; - char_type fill; - std::size_t padding; - F f; - - template - void operator()(It &&it) const - { - if (prefix.size() != 0) - it = std::copy_n(prefix.data(), prefix.size(), it); - it = std::fill_n(it, padding, fill); - f(it); - } - }; - - // Writes an integer in the format - // - // where are written by f(it). - template - void write_int(unsigned num_digits, string_view prefix, const Spec &spec, F f) - { - std::size_t size = prefix.size() + num_digits; - char_type fill = static_cast(spec.fill()); - std::size_t padding = 0; - if (spec.align() == ALIGN_NUMERIC) - { - if (spec.width() > size) - { - padding = spec.width() - size; - size = spec.width(); - } - } - else if (spec.precision() > static_cast(num_digits)) - { - size = prefix.size() + static_cast(spec.precision()); - padding = static_cast(spec.precision()) - num_digits; - fill = '0'; - } - align_spec as = spec; - if (spec.align() == ALIGN_DEFAULT) - as.align_ = ALIGN_RIGHT; - write_padded(size, as, padded_int_writer{prefix, fill, padding, f}); - } - - // Writes a decimal integer. - template - void write_decimal(Int value) - { - typedef typename internal::int_traits::main_type main_type; - main_type abs_value = static_cast(value); - bool is_negative = internal::is_negative(value); - if (is_negative) - abs_value = 0 - abs_value; - unsigned num_digits = internal::count_digits(abs_value); - auto &&it = reserve((is_negative ? 1 : 0) + num_digits); - if (is_negative) - *it++ = '-'; - internal::format_decimal(it, abs_value, num_digits); - } - - // The handle_int_type_spec handler that writes an integer. - template - struct int_writer - { - typedef typename internal::int_traits::main_type unsigned_type; - - basic_writer &writer; - const Spec &spec; - unsigned_type abs_value; - char prefix[4]; - unsigned prefix_size; - - string_view get_prefix() const - { - return string_view(prefix, prefix_size); - } - - // Counts the number of digits in abs_value. BITS = log2(radix). - template - unsigned count_digits() const - { - unsigned_type n = abs_value; - unsigned num_digits = 0; - do - { - ++num_digits; - } while ((n >>= BITS) != 0); - return num_digits; - } - - int_writer(basic_writer &w, Int value, const Spec &s) - : writer(w) - , spec(s) - , abs_value(static_cast(value)) - , prefix_size(0) - { - 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; - } - } - - struct dec_writer - { - unsigned_type abs_value; - unsigned num_digits; - - template - void operator()(It &&it) const - { - it = internal::format_decimal(it, abs_value, num_digits); - } - }; - - void on_dec() - { - unsigned num_digits = internal::count_digits(abs_value); - writer.write_int(num_digits, get_prefix(), spec, dec_writer{abs_value, num_digits}); - } - - struct hex_writer - { - int_writer &self; - unsigned num_digits; - - template - void operator()(It &&it) const - { - it = internal::format_uint<4>(it, self.abs_value, num_digits, self.spec.type() != 'x'); - } - }; - - void on_hex() - { - if (spec.flag(HASH_FLAG)) - { - prefix[prefix_size++] = '0'; - prefix[prefix_size++] = static_cast(spec.type()); - } - unsigned num_digits = count_digits<4>(); - writer.write_int(num_digits, get_prefix(), spec, hex_writer{*this, num_digits}); - } - - template - struct bin_writer - { - unsigned_type abs_value; - unsigned num_digits; - - template - void operator()(It &&it) const - { - it = internal::format_uint(it, abs_value, num_digits); - } - }; - - void on_bin() - { - if (spec.flag(HASH_FLAG)) - { - prefix[prefix_size++] = '0'; - prefix[prefix_size++] = static_cast(spec.type()); - } - unsigned num_digits = count_digits<1>(); - writer.write_int(num_digits, get_prefix(), spec, bin_writer<1>{abs_value, num_digits}); - } - - void on_oct() - { - unsigned num_digits = count_digits<3>(); - if (spec.flag(HASH_FLAG) && spec.precision() <= static_cast(num_digits)) - { - // Octal prefix '0' is counted as a digit, so only add it if precision - // is not greater than the number of digits. - prefix[prefix_size++] = '0'; - } - writer.write_int(num_digits, get_prefix(), spec, bin_writer<3>{abs_value, num_digits}); - } - - enum - { - SEP_SIZE = 1 - }; - - struct num_writer - { - unsigned_type abs_value; - unsigned size; - char_type sep; - - template - void operator()(It &&it) const - { - basic_string_view s(&sep, SEP_SIZE); - it = format_decimal(it, abs_value, size, internal::add_thousands_sep(s)); - } - }; - - void on_num() - { - unsigned num_digits = internal::count_digits(abs_value); - char_type sep = internal::thousands_sep(writer.locale_.get()); - unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3); - writer.write_int(size, get_prefix(), spec, num_writer{abs_value, size, sep}); - } - - void on_error() - { - FMT_THROW(format_error("invalid type specifier")); - } - }; - - // Writes a formatted integer. - template - void write_int(T value, const Spec &spec) - { - internal::handle_int_type_spec(spec.type(), int_writer(*this, value, spec)); - } - - enum - { - INF_SIZE = 3 - }; // This is an enum to workaround a bug in MSVC. - - struct inf_or_nan_writer - { - char sign; - const char *str; - - template - void operator()(It &&it) const - { - if (sign) - *it++ = sign; - it = std::copy_n(str, static_cast(INF_SIZE), it); - } - }; - - struct double_writer - { - size_t n; - char sign; - basic_memory_buffer &buffer; - - template - void operator()(It &&it) - { - if (sign) - { - *it++ = sign; - --n; - } - it = std::copy_n(buffer.begin(), n, it); - } - }; - - // Formats a floating-point number (double or long double). - template - void write_double(T value, const format_specs &spec); - template - void write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer &buffer); - - template - struct str_writer - { - const Char *s; - std::size_t size; - - template - void operator()(It &&it) const - { - it = std::copy_n(s, size, it); - } - }; - - // Writes a formatted string. - template - void write_str(const Char *s, std::size_t size, const align_spec &spec) - { - write_padded(size, spec, str_writer{s, size}); - } - - template - void write_str(basic_string_view str, const format_specs &spec); - - // Appends floating-point length specifier to the format string. - // The second argument is only used for overload resolution. - void append_float_length(char_type *&format_ptr, long double) - { - *format_ptr++ = 'L'; - } - - template - void append_float_length(char_type *&, T) - { - } - - template - friend class internal::arg_formatter_base; - -public: - /** Constructs a ``basic_writer`` object. */ - explicit basic_writer(Range out) - : out_(out.begin()) - { - } - - void write(int value) - { - write_decimal(value); - } - void write(long value) - { - write_decimal(value); - } - void write(long long value) - { - write_decimal(value); - } - - void write(unsigned value) - { - write_decimal(value); - } - void write(unsigned long value) - { - write_decimal(value); - } - void write(unsigned long long value) - { - write_decimal(value); - } - - /** - \rst - Formats *value* and writes it to the buffer. - \endrst - */ - template - typename std::enable_if::value, void>::type write(T value, FormatSpec spec, FormatSpecs... specs) - { - format_specs s(spec, specs...); - s.align_ = ALIGN_RIGHT; - write_int(value, s); - } - - void write(double value) - { - write_double(value, format_specs()); - } - - /** - \rst - Formats *value* using the general format for floating-point numbers - (``'g'``) and writes it to the buffer. - \endrst - */ - void write(long double value) - { - write_double(value, format_specs()); - } - - /** Writes a character to the buffer. */ - void write(char value) - { - *reserve(1) = value; - } - - void write(wchar_t value) - { - internal::require_wchar(); - *reserve(1) = value; - } - - /** - \rst - Writes *value* to the buffer. - \endrst - */ - void write(string_view value) - { - auto &&it = reserve(value.size()); - it = std::copy(value.begin(), value.end(), it); - } - - void write(wstring_view value) - { - internal::require_wchar(); - auto &&it = reserve(value.size()); - it = std::uninitialized_copy(value.begin(), value.end(), it); - } - - template - void write(basic_string_view str, FormatSpecs... specs) - { - write_str(str, format_specs(specs...)); - } - - template - typename std::enable_if::value>::type write(const T *p) - { - format_specs specs; - specs.flags_ = HASH_FLAG; - specs.type_ = 'x'; - write_int(reinterpret_cast(p), specs); - } -}; - -template -template -void basic_writer::write_padded(std::size_t size, const align_spec &spec, F f) -{ - unsigned width = spec.width(); - if (width <= size) - return f(reserve(size)); - auto &&it = reserve(width); - char_type fill = static_cast(spec.fill()); - std::size_t padding = width - size; - if (spec.align() == ALIGN_RIGHT) - { - it = std::fill_n(it, padding, fill); - f(it); - } - else if (spec.align() == ALIGN_CENTER) - { - std::size_t left_padding = padding / 2; - it = std::fill_n(it, left_padding, fill); - f(it); - it = std::fill_n(it, padding - left_padding, fill); - } - else - { - f(it); - it = std::fill_n(it, padding, fill); - } -} - -template -template -void basic_writer::write_str(basic_string_view s, const format_specs &spec) -{ - const Char *data = s.data(); - std::size_t size = s.size(); - std::size_t precision = static_cast(spec.precision_); - if (spec.precision_ >= 0 && precision < size) - size = precision; - write_str(data, size, spec); -} - -template -struct float_spec_handler -{ - Char type; - bool upper; - - explicit float_spec_handler(Char t) - : type(t) - , upper(false) - { - } - - void on_general() - { - if (type == 'G') - upper = true; - else - type = 'g'; - } - - void on_exp() - { - if (type == 'E') - upper = true; - } - - void on_fixed() - { - if (type == 'F') - { - upper = true; -#if FMT_MSC_VER - // MSVC's printf doesn't support 'F'. - type = 'f'; -#endif - } - } - - void on_hex() - { - if (type == 'A') - upper = true; - } - - void on_error() - { - FMT_THROW(format_error("invalid type specifier")); - } -}; - -template -template -void basic_writer::write_double(T value, const format_specs &spec) -{ - // Check type. - float_spec_handler handler(spec.type()); - internal::handle_float_type_spec(spec.type(), handler); - - char sign = 0; - // Use isnegative instead of value < 0 because the latter is always - // false for NaN. - if (internal::fputil::isnegative(static_cast(value))) - { - sign = '-'; - value = -value; - } - else if (spec.flag(SIGN_FLAG)) - { - sign = spec.flag(PLUS_FLAG) ? '+' : ' '; - } - - struct write_inf_or_nan_t - { - basic_writer &writer; - format_specs spec; - char sign; - void operator()(const char *str) const - { - writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec, inf_or_nan_writer{sign, str}); - } - } write_inf_or_nan = {*this, spec, sign}; - - // Format NaN and ininity ourselves because sprintf's output is not consistent - // across platforms. - if (internal::fputil::isnotanumber(value)) - return write_inf_or_nan(handler.upper ? "NAN" : "nan"); - if (internal::fputil::isinfinity(value)) - return write_inf_or_nan(handler.upper ? "INF" : "inf"); - - basic_memory_buffer buffer; - if (FMT_USE_GRISU && sizeof(T) <= sizeof(double) && std::numeric_limits::is_iec559) - { - internal::fp fp_value(static_cast(value)); - fp_value.normalize(); - // Find a cached power of 10 close to 1 / fp_value. - int dec_exp = 0; - const int min_exp = -60; - auto dec_pow = internal::get_cached_power(min_exp - (fp_value.e + internal::fp::significand_size), dec_exp); - internal::fp product = fp_value * dec_pow; - // Generate output. - internal::fp one(1ull << -product.e, product.e); - uint64_t hi = product.f >> -one.e; - uint64_t f = product.f & (one.f - 1); - typedef back_insert_range> range; - basic_writer w{range(buffer)}; - w.write(hi); - size_t digits = buffer.size(); - w.write('.'); - const unsigned max_digits = 18; - while (digits++ < max_digits) - { - f *= 10; - w.write(static_cast('0' + (f >> -one.e))); - f &= one.f - 1; - } - w.write('e'); - w.write(-dec_exp); - } - else - { - format_specs normalized_spec(spec); - normalized_spec.type_ = handler.type; - write_double_sprintf(value, normalized_spec, buffer); - } - size_t n = buffer.size(); - align_spec as = spec; - if (spec.align() == ALIGN_NUMERIC) - { - if (sign) - { - auto &&it = reserve(1); - *it++ = sign; - sign = 0; - if (as.width_) - --as.width_; - } - as.align_ = ALIGN_RIGHT; - } - else - { - if (spec.align() == ALIGN_DEFAULT) - as.align_ = ALIGN_RIGHT; - if (sign) - ++n; - } - write_padded(n, as, double_writer{n, sign, buffer}); -} - -template -template -void basic_writer::write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer &buffer) -{ - // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. - FMT_ASSERT(buffer.capacity() != 0, "empty buffer"); - - // Build format string. - enum - { - MAX_FORMAT_SIZE = 10 - }; // longest format: %#-*.*Lg - char_type format[MAX_FORMAT_SIZE]; - char_type *format_ptr = format; - *format_ptr++ = '%'; - if (spec.flag(HASH_FLAG)) - *format_ptr++ = '#'; - if (spec.precision() >= 0) - { - *format_ptr++ = '.'; - *format_ptr++ = '*'; - } - - append_float_length(format_ptr, value); - *format_ptr++ = spec.type(); - *format_ptr = '\0'; - - // Format using snprintf. - char_type *start = FMT_NULL; - for (;;) - { - std::size_t buffer_size = buffer.capacity(); - start = &buffer[0]; - int result = internal::char_traits::format_float(start, buffer_size, format, spec.precision(), value); - if (result >= 0) - { - unsigned n = internal::to_unsigned(result); - if (n < buffer.capacity()) - { - buffer.resize(n); - break; // The buffer is large enough - continue with formatting. - } - buffer.reserve(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); - } - } -} - -// 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, string_view message) FMT_NOEXCEPT; - -#if FMT_USE_WINDOWS_H - -/** A Windows error. */ -class windows_error : public system_error -{ -private: - FMT_API void init(int error_code, string_view format_str, format_args args); - -public: - /** - \rst - Constructs a :class:`fmt::windows_error` object with the description - of the form - - .. parsed-literal:: - **: ** - - where ** is the formatted message and ** 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 windows_error 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::windows_error(GetLastError(), - "cannot open file '{}'", filename); - } - \endrst - */ - template - windows_error(int error_code, string_view message, const Args &... args) - { - init(error_code, message, make_format_args(args...)); - } -}; - -// 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, string_view message) FMT_NOEXCEPT; - -#endif - -/** Fast integer formatter. */ -class format_int -{ -private: - // Buffer should be large enough to hold all digits (digits10 + 1), - // a sign and a null character. - enum - { - BUFFER_SIZE = std::numeric_limits::digits10 + 3 - }; - mutable char buffer_[BUFFER_SIZE]; - char *str_; - - // Formats value in reverse and returns a pointer to the beginning. - char *format_decimal(unsigned long long value) - { - char *ptr = 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((value % 100) * 2); - value /= 100; - *--ptr = internal::data::DIGITS[index + 1]; - *--ptr = internal::data::DIGITS[index]; - } - if (value < 10) - { - *--ptr = static_cast('0' + value); - return ptr; - } - unsigned index = static_cast(value * 2); - *--ptr = internal::data::DIGITS[index + 1]; - *--ptr = internal::data::DIGITS[index]; - return ptr; - } - - void format_signed(long long value) - { - unsigned long long abs_value = static_cast(value); - bool negative = value < 0; - if (negative) - abs_value = 0 - abs_value; - str_ = format_decimal(abs_value); - if (negative) - *--str_ = '-'; - } - -public: - explicit format_int(int value) - { - format_signed(value); - } - explicit format_int(long value) - { - format_signed(value); - } - explicit format_int(long long value) - { - format_signed(value); - } - explicit format_int(unsigned value) - : str_(format_decimal(value)) - { - } - explicit format_int(unsigned long value) - : str_(format_decimal(value)) - { - } - explicit format_int(unsigned long long 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 -inline void format_decimal(char *&buffer, T value) -{ - typedef typename internal::int_traits::main_type main_type; - main_type abs_value = static_cast(value); - if (internal::is_negative(value)) - { - *buffer++ = '-'; - abs_value = 0 - abs_value; - } - if (abs_value < 100) - { - if (abs_value < 10) - { - *buffer++ = static_cast('0' + abs_value); - return; - } - unsigned index = static_cast(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; -} - -// Formatter of objects of type T. -template -struct formatter::type, T>::value>::type> -{ - - // Parses format specifiers stopping either at the end of the range or at the - // terminating '}'. - template - FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) - { - auto it = internal::null_terminating_iterator(ctx); - typedef internal::dynamic_specs_handler handler_type; - auto type = internal::get_type::type, T>::value; - internal::specs_checker handler(handler_type(specs_, ctx), type); - it = parse_format_specs(it, handler); - auto type_spec = specs_.type(); - auto eh = ctx.error_handler(); - switch (type) - { - case internal::none_type: - case internal::named_arg_type: - FMT_ASSERT(false, "invalid argument type"); - break; - case internal::int_type: - case internal::uint_type: - case internal::long_long_type: - case internal::ulong_long_type: - case internal::bool_type: - handle_int_type_spec(type_spec, internal::int_type_checker(eh)); - break; - case internal::char_type: - handle_char_specs(specs_, internal::char_specs_checker(type_spec, eh)); - break; - case internal::double_type: - case internal::long_double_type: - handle_float_type_spec(type_spec, internal::float_type_checker(eh)); - break; - case internal::cstring_type: - internal::handle_cstring_type_spec(type_spec, internal::cstring_type_checker(eh)); - break; - case internal::string_type: - internal::check_string_type_spec(type_spec, eh); - break; - case internal::pointer_type: - internal::check_pointer_type_spec(type_spec, eh); - break; - case internal::custom_type: - // Custom format specifiers should be checked in parse functions of - // formatter specializations. - break; - } - return pointer_from(it); - } - - template - auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) - { - internal::handle_dynamic_spec(specs_.width_, specs_.width_ref, ctx); - internal::handle_dynamic_spec(specs_.precision_, specs_.precision_ref, ctx); - typedef output_range range_type; - return visit(arg_formatter(ctx, specs_), internal::make_arg(val)); - } - -private: - internal::dynamic_format_specs specs_; -}; - -template -struct formatter::value>::type> : public formatter -{ - template - auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { - return ctx.begin(); - } -}; - -// A formatter for types known only at run time such as variant alternatives. -// -// Usage: -// typedef std::variant variant; -// template <> -// struct formatter: dynamic_formatter<> { -// void format(buffer &buf, const variant &v, context &ctx) { -// visit([&](const auto &val) { format(buf, val, ctx); }, v); -// } -// }; -template -class dynamic_formatter -{ -private: - struct null_handler : internal::error_handler - { - void on_align(alignment) {} - void on_plus() {} - void on_minus() {} - void on_space() {} - void on_hash() {} - }; - -public: - template - auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { - auto it = internal::null_terminating_iterator(ctx); - // Checks are deferred to formatting time when the argument type is known. - internal::dynamic_specs_handler handler(specs_, ctx); - it = parse_format_specs(it, handler); - return pointer_from(it); - } - - template - auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) - { - handle_specs(ctx); - internal::specs_checker checker(null_handler(), internal::get_type::value); - checker.on_align(specs_.align()); - if (specs_.flags_ == 0) - { - // Do nothing. - } - else if (specs_.flag(SIGN_FLAG)) - { - if (specs_.flag(PLUS_FLAG)) - checker.on_plus(); - else - checker.on_space(); - } - else if (specs_.flag(MINUS_FLAG)) - { - checker.on_minus(); - } - else if (specs_.flag(HASH_FLAG)) - { - checker.on_hash(); - } - if (specs_.precision_ != -1) - checker.end_precision(); - typedef output_range range; - visit(arg_formatter(ctx, specs_), internal::make_arg(val)); - return ctx.out(); - } - -private: - template - void handle_specs(Context &ctx) - { - internal::handle_dynamic_spec(specs_.width_, specs_.width_ref, ctx); - internal::handle_dynamic_spec(specs_.precision_, specs_.precision_ref, ctx); - } - - internal::dynamic_format_specs specs_; -}; - -template -typename basic_format_context::format_arg basic_format_context::get_arg(basic_string_view name) -{ - map_.init(this->args()); - format_arg arg = map_.find(name); - if (arg.type() == internal::none_type) - this->on_error("argument not found"); - return arg; -} - -template -struct format_handler : internal::error_handler -{ - typedef internal::null_terminating_iterator iterator; - typedef typename ArgFormatter::range range; - - format_handler(range r, basic_string_view str, basic_format_args format_args) - : context(r.begin(), str, format_args) - { - } - - void on_text(iterator begin, iterator end) - { - auto size = internal::to_unsigned(end - begin); - auto out = context.out(); - auto &&it = internal::reserve(out, size); - it = std::copy_n(begin, size, it); - context.advance_to(out); - } - - void on_arg_id() - { - arg = context.next_arg(); - } - void on_arg_id(unsigned id) - { - context.parse_context().check_arg_id(id); - arg = context.get_arg(id); - } - void on_arg_id(basic_string_view id) - { - arg = context.get_arg(id); - } - - void on_replacement_field(iterator it) - { - context.parse_context().advance_to(pointer_from(it)); - if (visit(internal::custom_formatter(context), arg)) - return; - basic_format_specs specs; - context.advance_to(visit(ArgFormatter(context, specs), arg)); - } - - iterator on_format_specs(iterator it) - { - auto &parse_ctx = context.parse_context(); - parse_ctx.advance_to(pointer_from(it)); - if (visit(internal::custom_formatter(context), arg)) - return iterator(parse_ctx); - basic_format_specs specs; - using internal::specs_handler; - internal::specs_checker> handler(specs_handler(specs, context), arg.type()); - it = parse_format_specs(it, handler); - if (*it != '}') - on_error("missing '}' in format string"); - parse_ctx.advance_to(pointer_from(it)); - context.advance_to(visit(ArgFormatter(context, specs), arg)); - return it; - } - - Context context; - basic_format_arg arg; -}; - -/** Formats arguments and writes the output to the range. */ -template -typename Context::iterator vformat_to(typename ArgFormatter::range out, basic_string_view format_str, basic_format_args args) -{ - typedef internal::null_terminating_iterator iterator; - format_handler h(out, format_str, args); - parse_format_string(iterator(format_str.begin(), format_str.end()), h); - return h.context.out(); -} - -// Casts ``p`` to ``const void*`` for pointer formatting. -// Example: -// auto s = format("{}", ptr(p)); -template -inline const void *ptr(const T *p) -{ - return p; -} - -template -struct arg_join -{ - It begin; - It end; - basic_string_view sep; - - arg_join(It begin, It end, basic_string_view sep) - : begin(begin) - , end(end) - , sep(sep) - { - } -}; - -template -struct formatter, Char> : formatter::value_type, Char> -{ - template - auto format(const arg_join &value, FormatContext &ctx) -> decltype(ctx.out()) - { - typedef formatter::value_type, Char> base; - auto it = value.begin; - auto out = ctx.out(); - if (it != value.end) - { - out = base::format(*it++, ctx); - while (it != value.end) - { - out = std::copy(value.sep.begin(), value.sep.end(), out); - ctx.advance_to(out); - out = base::format(*it++, ctx); - } - } - return out; - } -}; - -template -arg_join join(It begin, It end, string_view sep) -{ - return arg_join(begin, end, sep); -} - -template -arg_join join(It begin, It end, wstring_view sep) -{ - return arg_join(begin, end, sep); -} - -// The following causes ICE in gcc 4.4. -#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405) -template -auto join(const Range &range, string_view sep) -> arg_join -{ - return join(internal::begin(range), internal::end(range), sep); -} - -template -auto join(const Range &range, wstring_view sep) -> arg_join -{ - return join(internal::begin(range), internal::end(range), sep); -} -#endif - -/** - \rst - Converts *value* to ``std::string`` using the default format for type *T*. - - **Example**:: - - #include - - std::string answer = fmt::to_string(42); - \endrst - */ -template -std::string to_string(const T &value) -{ - std::string str; - internal::container_buffer buf(str); - writer(buf).write(value); - return str; -} - -/** - Converts *value* to ``std::wstring`` using the default format for type *T*. - */ -template -std::wstring to_wstring(const T &value) -{ - std::wstring str; - internal::container_buffer buf(str); - wwriter(buf).write(value); - return str; -} - -template -std::basic_string to_string(const basic_memory_buffer &buf) -{ - return std::basic_string(buf.data(), buf.size()); -} - -inline format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args) -{ - typedef back_insert_range range; - return vformat_to>(buf, format_str, args); -} - -inline wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args) -{ - typedef back_insert_range range; - return vformat_to>(buf, format_str, args); -} - -template -inline format_context::iterator format_to(basic_memory_buffer &buf, string_view format_str, const Args &... args) -{ - return vformat_to(buf, format_str, make_format_args(args...)); -} - -template -inline wformat_context::iterator format_to(basic_memory_buffer &buf, wstring_view format_str, const Args &... args) -{ - return vformat_to(buf, format_str, make_format_args(args...)); -} - -template -// using format_context_t = basic_format_context; -struct format_context_t -{ - typedef basic_format_context type; -}; - -template -// using format_args_t = basic_format_args>; -struct format_args_t -{ - typedef basic_format_args::type> type; -}; - -template -inline OutputIt vformat_to(OutputIt out, string_view format_str, typename format_args_t::type args) -{ - typedef output_range range; - return vformat_to>(range(out), format_str, args); -} -template -inline OutputIt vformat_to(OutputIt out, wstring_view format_str, typename format_args_t::type args) -{ - typedef output_range range; - return vformat_to>(range(out), format_str, args); -} - -/** - \rst - Formats arguments, writes the result to the output iterator ``out`` and returns - the iterator past the end of the output range. - - **Example**:: - - std::vector out; - fmt::format_to(std::back_inserter(out), "{}", 42); - \endrst - */ -template -inline OutputIt format_to(OutputIt out, string_view format_str, const Args &... args) -{ - return vformat_to(out, format_str, make_format_args::type>(args...)); -} - -template -inline typename std::enable_if::value, std::back_insert_iterator>::type format_to( - std::back_insert_iterator out, string_view format_str, const Args &... args) -{ - return vformat_to(out, format_str, make_format_args(args...)); -} - -template -inline typename std::enable_if::value, std::back_insert_iterator>::type format_to( - std::back_insert_iterator out, wstring_view format_str, const Args &... args) -{ - return vformat_to(out, format_str, make_format_args(args...)); -} - -template -struct format_to_n_result -{ - /** Iterator past the end of the output range. */ - OutputIt out; - /** Total (not truncated) output size. */ - std::size_t size; -}; - -template -using format_to_n_context = typename fmt::format_context_t>::type; - -template -using format_to_n_args = fmt::basic_format_args>; - -template -inline format_arg_store, Args...> make_format_to_n_args(const Args &... args) -{ - return format_arg_store, Args...>(args...); -} - -template -inline format_to_n_result vformat_to_n(OutputIt out, std::size_t n, string_view format_str, format_to_n_args args) -{ - typedef internal::truncating_iterator It; - auto it = vformat_to(It(out, n), format_str, args); - return {it.base(), it.count()}; -} - -/** - \rst - Formats arguments, writes up to ``n`` characters of the result to the output - iterator ``out`` and returns the total output size and the iterator past the - end - of the output range. - \endrst - */ -template -inline format_to_n_result format_to_n(OutputIt out, std::size_t n, string_view format_str, const Args &... args) -{ - return vformat_to_n(out, n, format_str, make_format_to_n_args(args...)); -} -template -inline format_to_n_result format_to_n(OutputIt out, std::size_t n, wstring_view format_str, const Args &... args) -{ - typedef internal::truncating_iterator It; - auto it = vformat_to(It(out, n), format_str, make_format_args::type>(args...)); - return {it.base(), it.count()}; -} - -inline std::string vformat(string_view format_str, format_args args) -{ - memory_buffer buffer; - vformat_to(buffer, format_str, args); - return fmt::to_string(buffer); -} - -inline std::wstring vformat(wstring_view format_str, wformat_args args) -{ - wmemory_buffer buffer; - vformat_to(buffer, format_str, args); - return to_string(buffer); -} - -template -inline typename std::enable_if::value, std::string>::type format(String format_str, const Args &... args) -{ - internal::check_format_string(format_str); - return vformat(format_str.data(), make_format_args(args...)); -} - -template -inline typename std::enable_if::value>::type print(String format_str, const Args &... args) -{ - internal::check_format_string(format_str); - return vprint(format_str.data(), make_format_args(args...)); -} - -/** - Returns the number of characters in the output of - ``format(format_str, args...)``. - */ -template -inline std::size_t formatted_size(string_view format_str, const Args &... args) -{ - auto it = format_to(internal::counting_iterator(), format_str, args...); - return it.count(); -} - -// Experimental color support. -#ifdef FMT_EXTENDED_COLORS -enum class color : uint32_t -{ - alice_blue = 0xF0F8FF, // rgb(240,248,255) - antique_white = 0xFAEBD7, // rgb(250,235,215) - aqua = 0x00FFFF, // rgb(0,255,255) - aquamarine = 0x7FFFD4, // rgb(127,255,212) - azure = 0xF0FFFF, // rgb(240,255,255) - beige = 0xF5F5DC, // rgb(245,245,220) - bisque = 0xFFE4C4, // rgb(255,228,196) - black = 0x000000, // rgb(0,0,0) - blanched_almond = 0xFFEBCD, // rgb(255,235,205) - blue = 0x0000FF, // rgb(0,0,255) - blue_violet = 0x8A2BE2, // rgb(138,43,226) - brown = 0xA52A2A, // rgb(165,42,42) - burly_wood = 0xDEB887, // rgb(222,184,135) - cadet_blue = 0x5F9EA0, // rgb(95,158,160) - chartreuse = 0x7FFF00, // rgb(127,255,0) - chocolate = 0xD2691E, // rgb(210,105,30) - coral = 0xFF7F50, // rgb(255,127,80) - cornflower_blue = 0x6495ED, // rgb(100,149,237) - cornsilk = 0xFFF8DC, // rgb(255,248,220) - crimson = 0xDC143C, // rgb(220,20,60) - cyan = 0x00FFFF, // rgb(0,255,255) - dark_blue = 0x00008B, // rgb(0,0,139) - dark_cyan = 0x008B8B, // rgb(0,139,139) - dark_golden_rod = 0xB8860B, // rgb(184,134,11) - dark_gray = 0xA9A9A9, // rgb(169,169,169) - dark_green = 0x006400, // rgb(0,100,0) - dark_khaki = 0xBDB76B, // rgb(189,183,107) - dark_magenta = 0x8B008B, // rgb(139,0,139) - dark_olive_green = 0x556B2F, // rgb(85,107,47) - dark_orange = 0xFF8C00, // rgb(255,140,0) - dark_orchid = 0x9932CC, // rgb(153,50,204) - dark_red = 0x8B0000, // rgb(139,0,0) - dark_salmon = 0xE9967A, // rgb(233,150,122) - dark_sea_green = 0x8FBC8F, // rgb(143,188,143) - dark_slate_blue = 0x483D8B, // rgb(72,61,139) - dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) - dark_turquoise = 0x00CED1, // rgb(0,206,209) - dark_violet = 0x9400D3, // rgb(148,0,211) - deep_pink = 0xFF1493, // rgb(255,20,147) - deep_sky_blue = 0x00BFFF, // rgb(0,191,255) - dim_gray = 0x696969, // rgb(105,105,105) - dodger_blue = 0x1E90FF, // rgb(30,144,255) - fire_brick = 0xB22222, // rgb(178,34,34) - floral_white = 0xFFFAF0, // rgb(255,250,240) - forest_green = 0x228B22, // rgb(34,139,34) - fuchsia = 0xFF00FF, // rgb(255,0,255) - gainsboro = 0xDCDCDC, // rgb(220,220,220) - ghost_white = 0xF8F8FF, // rgb(248,248,255) - gold = 0xFFD700, // rgb(255,215,0) - golden_rod = 0xDAA520, // rgb(218,165,32) - gray = 0x808080, // rgb(128,128,128) - green = 0x008000, // rgb(0,128,0) - green_yellow = 0xADFF2F, // rgb(173,255,47) - honey_dew = 0xF0FFF0, // rgb(240,255,240) - hot_pink = 0xFF69B4, // rgb(255,105,180) - indian_red = 0xCD5C5C, // rgb(205,92,92) - indigo = 0x4B0082, // rgb(75,0,130) - ivory = 0xFFFFF0, // rgb(255,255,240) - khaki = 0xF0E68C, // rgb(240,230,140) - lavender = 0xE6E6FA, // rgb(230,230,250) - lavender_blush = 0xFFF0F5, // rgb(255,240,245) - lawn_green = 0x7CFC00, // rgb(124,252,0) - lemon_chiffon = 0xFFFACD, // rgb(255,250,205) - light_blue = 0xADD8E6, // rgb(173,216,230) - light_coral = 0xF08080, // rgb(240,128,128) - light_cyan = 0xE0FFFF, // rgb(224,255,255) - light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) - light_gray = 0xD3D3D3, // rgb(211,211,211) - light_green = 0x90EE90, // rgb(144,238,144) - light_pink = 0xFFB6C1, // rgb(255,182,193) - light_salmon = 0xFFA07A, // rgb(255,160,122) - light_sea_green = 0x20B2AA, // rgb(32,178,170) - light_sky_blue = 0x87CEFA, // rgb(135,206,250) - light_slate_gray = 0x778899, // rgb(119,136,153) - light_steel_blue = 0xB0C4DE, // rgb(176,196,222) - light_yellow = 0xFFFFE0, // rgb(255,255,224) - lime = 0x00FF00, // rgb(0,255,0) - lime_green = 0x32CD32, // rgb(50,205,50) - linen = 0xFAF0E6, // rgb(250,240,230) - magenta = 0xFF00FF, // rgb(255,0,255) - maroon = 0x800000, // rgb(128,0,0) - medium_aquamarine = 0x66CDAA, // rgb(102,205,170) - medium_blue = 0x0000CD, // rgb(0,0,205) - medium_orchid = 0xBA55D3, // rgb(186,85,211) - medium_purple = 0x9370DB, // rgb(147,112,219) - medium_sea_green = 0x3CB371, // rgb(60,179,113) - medium_slate_blue = 0x7B68EE, // rgb(123,104,238) - medium_spring_green = 0x00FA9A, // rgb(0,250,154) - medium_turquoise = 0x48D1CC, // rgb(72,209,204) - medium_violet_red = 0xC71585, // rgb(199,21,133) - midnight_blue = 0x191970, // rgb(25,25,112) - mint_cream = 0xF5FFFA, // rgb(245,255,250) - misty_rose = 0xFFE4E1, // rgb(255,228,225) - moccasin = 0xFFE4B5, // rgb(255,228,181) - navajo_white = 0xFFDEAD, // rgb(255,222,173) - navy = 0x000080, // rgb(0,0,128) - old_lace = 0xFDF5E6, // rgb(253,245,230) - olive = 0x808000, // rgb(128,128,0) - olive_drab = 0x6B8E23, // rgb(107,142,35) - orange = 0xFFA500, // rgb(255,165,0) - orange_red = 0xFF4500, // rgb(255,69,0) - orchid = 0xDA70D6, // rgb(218,112,214) - pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) - pale_green = 0x98FB98, // rgb(152,251,152) - pale_turquoise = 0xAFEEEE, // rgb(175,238,238) - pale_violet_red = 0xDB7093, // rgb(219,112,147) - papaya_whip = 0xFFEFD5, // rgb(255,239,213) - peach_puff = 0xFFDAB9, // rgb(255,218,185) - peru = 0xCD853F, // rgb(205,133,63) - pink = 0xFFC0CB, // rgb(255,192,203) - plum = 0xDDA0DD, // rgb(221,160,221) - powder_blue = 0xB0E0E6, // rgb(176,224,230) - purple = 0x800080, // rgb(128,0,128) - rebecca_purple = 0x663399, // rgb(102,51,153) - red = 0xFF0000, // rgb(255,0,0) - rosy_brown = 0xBC8F8F, // rgb(188,143,143) - royal_blue = 0x4169E1, // rgb(65,105,225) - saddle_brown = 0x8B4513, // rgb(139,69,19) - salmon = 0xFA8072, // rgb(250,128,114) - sandy_brown = 0xF4A460, // rgb(244,164,96) - sea_green = 0x2E8B57, // rgb(46,139,87) - sea_shell = 0xFFF5EE, // rgb(255,245,238) - sienna = 0xA0522D, // rgb(160,82,45) - silver = 0xC0C0C0, // rgb(192,192,192) - sky_blue = 0x87CEEB, // rgb(135,206,235) - slate_blue = 0x6A5ACD, // rgb(106,90,205) - slate_gray = 0x708090, // rgb(112,128,144) - snow = 0xFFFAFA, // rgb(255,250,250) - spring_green = 0x00FF7F, // rgb(0,255,127) - steel_blue = 0x4682B4, // rgb(70,130,180) - tan = 0xD2B48C, // rgb(210,180,140) - teal = 0x008080, // rgb(0,128,128) - thistle = 0xD8BFD8, // rgb(216,191,216) - tomato = 0xFF6347, // rgb(255,99,71) - turquoise = 0x40E0D0, // rgb(64,224,208) - violet = 0xEE82EE, // rgb(238,130,238) - wheat = 0xF5DEB3, // rgb(245,222,179) - white = 0xFFFFFF, // rgb(255,255,255) - white_smoke = 0xF5F5F5, // rgb(245,245,245) - yellow = 0xFFFF00, // rgb(255,255,0) - yellow_green = 0x9ACD32, // rgb(154,205,50) -}; // enum class color - -// rgb is a struct for red, green and blue colors. -// We use rgb as name because some editors will show it as color direct in the -// editor. -struct rgb -{ - FMT_CONSTEXPR_DECL rgb() - : r(0) - , g(0) - , b(0) - { - } - FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_) - : r(r_) - , g(g_) - , b(b_) - { - } - FMT_CONSTEXPR_DECL rgb(uint32_t hex) - : r((hex >> 16) & 0xFF) - , g((hex >> 8) & 0xFF) - , b((hex)&0xFF) - { - } - FMT_CONSTEXPR_DECL rgb(color hex) - : r((uint32_t(hex) >> 16) & 0xFF) - , g((uint32_t(hex) >> 8) & 0xFF) - , b(uint32_t(hex) & 0xFF) - { - } - uint8_t r; - uint8_t g; - uint8_t b; -}; - -void vprint_rgb(rgb fd, string_view format, format_args args); -void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args); - -/** - Formats a string and prints it to stdout using ANSI escape sequences to - specify foreground color 'fd'. - Example: - fmt::print(fmt::color::red, "Elapsed time: {0:.2f} seconds", 1.23); - */ -template -inline void print(rgb fd, string_view format_str, const Args &... args) -{ - vprint_rgb(fd, format_str, make_format_args(args...)); -} - -/** - Formats a string and prints it to stdout using ANSI escape sequences to - specify foreground color 'fd' and background color 'bg'. - Example: - fmt::print(fmt::color::red, fmt::color::black, "Elapsed time: {0:.2f} - seconds", 1.23); - */ -template -inline void print(rgb fd, rgb bg, string_view format_str, const Args &... args) -{ - vprint_rgb(fd, bg, format_str, make_format_args(args...)); -} -#endif // FMT_EXTENDED_COLORS - -#if FMT_USE_USER_DEFINED_LITERALS -namespace internal { - -#if FMT_UDL_TEMPLATE -template -class udl_formatter -{ -public: - template - std::basic_string operator()(const Args &... args) const - { - FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'}; - FMT_CONSTEXPR_DECL bool invalid_format = - check_format_string(basic_string_view(s, sizeof...(CHARS))); - (void)invalid_format; - return format(s, args...); - } -}; -#else -template -struct udl_formatter -{ - const Char *str; - - template - auto operator()(Args &&... args) const -> decltype(format(str, std::forward(args)...)) - { - return format(str, std::forward(args)...); - } -}; -#endif // FMT_UDL_TEMPLATE - -template -struct udl_arg -{ - const Char *str; - - template - named_arg operator=(T &&value) const - { - return {str, std::forward(value)}; - } -}; - -} // namespace internal - -inline namespace literals { - -#if FMT_UDL_TEMPLATE -template -FMT_CONSTEXPR internal::udl_formatter operator""_format() -{ - return {}; -} -#else -/** - \rst - User-defined literal equivalent of :func:`fmt::format`. - - **Example**:: - - using namespace fmt::literals; - std::string message = "The answer is {}"_format(42); - \endrst - */ -inline internal::udl_formatter operator"" _format(const char *s, std::size_t) -{ - return {s}; -} -inline internal::udl_formatter operator"" _format(const wchar_t *s, std::size_t) -{ - return {s}; -} -#endif // FMT_UDL_TEMPLATE - -/** - \rst - User-defined literal equivalent of :func:`fmt::arg`. - - **Example**:: - - using namespace fmt::literals; - fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); - \endrst - */ -inline internal::udl_arg operator"" _a(const char *s, std::size_t) -{ - return {s}; -} -inline internal::udl_arg operator"" _a(const wchar_t *s, std::size_t) -{ - return {s}; -} -} // namespace literals -#endif // FMT_USE_USER_DEFINED_LITERALS -FMT_END_NAMESPACE - -#define FMT_STRING(s) \ - [] { \ - struct S : fmt::format_string \ - { \ - static FMT_CONSTEXPR decltype(s) data() \ - { \ - return s; \ - } \ - static FMT_CONSTEXPR size_t size() \ - { \ - return sizeof(s); \ - } \ - }; \ - return S{}; \ - }() - -#ifndef FMT_NO_FMT_STRING_ALIAS -/** - \rst - Constructs a compile-time format string. - - **Example**:: - - #include - // A compile-time error because 'd' is an invalid specifier for strings. - std::string s = format(fmt("{:d}"), "foo"); - \endrst - */ -#define fmt(s) FMT_STRING(s) -#endif - -#ifdef FMT_HEADER_ONLY -#define FMT_FUNC inline -#include "format-inl.h" -#else -#define FMT_FUNC -#endif - -// Restore warnings. -#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION -#pragma GCC diagnostic pop -#endif - -#endif // FMT_FORMAT_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/locale.h b/spdlog_lib/spdlog/fmt/bundled/locale.h deleted file mode 100644 index 0fa78c8..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/locale.h +++ /dev/null @@ -1,27 +0,0 @@ -// Formatting library for C++ - locale support -// -// Copyright (c) 2012 - 2016, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "format.h" -#include - -namespace fmt { -class locale -{ -private: - std::locale locale_; - -public: - explicit locale(std::locale loc = std::locale()) - : locale_(loc) - { - } - std::locale get() - { - return locale_; - } -}; -} // namespace fmt diff --git a/spdlog_lib/spdlog/fmt/bundled/ostream.h b/spdlog_lib/spdlog/fmt/bundled/ostream.h deleted file mode 100644 index 439ded6..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/ostream.h +++ /dev/null @@ -1,173 +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_ - -#include "format.h" -#include - -FMT_BEGIN_NAMESPACE -namespace internal { - -template -class formatbuf : public std::basic_streambuf -{ -private: - typedef typename std::basic_streambuf::int_type int_type; - typedef typename std::basic_streambuf::traits_type traits_type; - - basic_buffer &buffer_; - -public: - formatbuf(basic_buffer &buffer) - : buffer_(buffer) - { - } - -protected: - // The put-area is actually always empty. This makes the implementation - // simpler and has the advantage that the streambuf and the buffer are always - // in sync and sputc never writes into uninitialized memory. The obvious - // disadvantage is that each call to sputc always results in a (virtual) call - // to overflow. There is no disadvantage here for sputn since this always - // results in a call to xsputn. - - int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE - { - if (!traits_type::eq_int_type(ch, traits_type::eof())) - buffer_.push_back(static_cast(ch)); - return ch; - } - - std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE - { - buffer_.append(s, s + count); - return count; - } -}; - -template -struct test_stream : std::basic_ostream -{ -private: - struct null; - // Hide all operator<< from std::basic_ostream. - void operator<<(null); -}; - -// Checks if T has a user-defined operator<< (e.g. not a member of -// std::ostream). -template -class is_streamable -{ -private: - template - static decltype(internal::declval &>() << internal::declval(), std::true_type()) test(int); - - template - static std::false_type test(...); - - typedef decltype(test(0)) result; - -public: - // std::string operator<< is not considered user-defined because we handle - // strings - // specially. - static const bool value = result::value && !std::is_same::value; -}; - -// Disable conversion to int if T has an overloaded operator<< which is a free -// function (not a member of std::ostream). -template -class convert_to_int -{ -public: - static const bool value = convert_to_int::value && !is_streamable::value; -}; - -// Write the content of buf to os. -template -void write(std::basic_ostream &os, basic_buffer &buf) -{ - const Char *data = buf.data(); - typedef std::make_unsigned::type UnsignedStreamSize; - UnsignedStreamSize size = buf.size(); - UnsignedStreamSize max_size = internal::to_unsigned((std::numeric_limits::max)()); - do - { - UnsignedStreamSize n = size <= max_size ? size : max_size; - os.write(data, static_cast(n)); - data += n; - size -= n; - } while (size != 0); -} - -template -void format_value(basic_buffer &buffer, const T &value) -{ - internal::formatbuf format_buf(buffer); - std::basic_ostream output(&format_buf); - output.exceptions(std::ios_base::failbit | std::ios_base::badbit); - output << value; - buffer.resize(buffer.size()); -} - -// Disable builtin formatting of enums and use operator<< instead. -template -struct format_enum::value>::type> : std::false_type -{ -}; -} // namespace internal - -// Formats an object of type T that has an overloaded ostream operator<<. -template -struct formatter::value>::type> : formatter, Char> -{ - - template - auto format(const T &value, Context &ctx) -> decltype(ctx.out()) - { - basic_memory_buffer buffer; - internal::format_value(buffer, value); - basic_string_view str(buffer.data(), buffer.size()); - formatter, Char>::format(str, ctx); - return ctx.out(); - } -}; - -template -inline void vprint( - std::basic_ostream &os, basic_string_view format_str, basic_format_args::type> args) -{ - basic_memory_buffer buffer; - vformat_to(buffer, format_str, args); - internal::write(os, buffer); -} -/** - \rst - Prints formatted data to the stream *os*. - - **Example**:: - - fmt::print(cerr, "Don't {}!", "panic"); - \endrst - */ -template -inline void print(std::ostream &os, string_view format_str, const Args &... args) -{ - vprint(os, format_str, make_format_args(args...)); -} - -template -inline void print(std::wostream &os, wstring_view format_str, const Args &... args) -{ - vprint(os, format_str, make_format_args(args...)); -} -FMT_END_NAMESPACE - -#endif // FMT_OSTREAM_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/posix.h b/spdlog_lib/spdlog/fmt/bundled/posix.h deleted file mode 100644 index 20c7589..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/posix.h +++ /dev/null @@ -1,484 +0,0 @@ -// A C++ interface to POSIX functions. -// -// Copyright (c) 2012 - 2016, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#ifndef FMT_POSIX_H_ -#define FMT_POSIX_H_ - -#if defined(__MINGW32__) || defined(__CYGWIN__) -// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/. -#undef __STRICT_ANSI__ -#endif - -#include -#include // for O_RDONLY -#include // for locale_t -#include -#include // for strtod_l - -#include - -#if defined __APPLE__ || defined(__FreeBSD__) -#include // for LC_NUMERIC_MASK on OS X -#endif - -#include "format.h" - -#ifndef FMT_POSIX -#if defined(_WIN32) && !defined(__MINGW32__) -// Fix warnings about deprecated symbols. -#define FMT_POSIX(call) _##call -#else -#define FMT_POSIX(call) call -#endif -#endif - -// Calls to system functions are wrapped in FMT_SYSTEM for testability. -#ifdef FMT_SYSTEM -#define FMT_POSIX_CALL(call) FMT_SYSTEM(call) -#else -#define FMT_SYSTEM(call) call -#ifdef _WIN32 -// Fix warnings about deprecated symbols. -#define FMT_POSIX_CALL(call) ::_##call -#else -#define FMT_POSIX_CALL(call) ::call -#endif -#endif - -// Retries the expression while it evaluates to error_result and errno -// equals to EINTR. -#ifndef _WIN32 -#define FMT_RETRY_VAL(result, expression, error_result) \ - do \ - { \ - result = (expression); \ - } while (result == error_result && errno == EINTR) -#else -#define FMT_RETRY_VAL(result, expression, error_result) result = (expression) -#endif - -#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) - -FMT_BEGIN_NAMESPACE - -/** - \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 | - +===============+=============================+ - | cstring_view | basic_cstring_view | - +---------------+-----------------------------+ - | wcstring_view | basic_cstring_view | - +---------------+-----------------------------+ - - This class is most useful as a parameter type to allow passing - different types of strings to a function, for example:: - - template - std::string format(cstring_view format_str, const Args & ... args); - - format("{}", 42); - format(std::string("{}"), 42); - \endrst - */ -template -class basic_cstring_view -{ -private: - const Char *data_; - -public: - /** Constructs a string reference object from a C string. */ - basic_cstring_view(const Char *s) - : data_(s) - { - } - - /** - \rst - Constructs a string reference from an ``std::string`` object. - \endrst - */ - basic_cstring_view(const std::basic_string &s) - : data_(s.c_str()) - { - } - - /** Returns the pointer to a C string. */ - const Char *c_str() const - { - return data_; - } -}; - -typedef basic_cstring_view cstring_view; -typedef basic_cstring_view wcstring_view; - -// An error code. -class error_code -{ -private: - int value_; - -public: - explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {} - - int get() const FMT_NOEXCEPT - { - return value_; - } -}; - -// A buffered file. -class buffered_file -{ -private: - FILE *file_; - - friend class file; - - explicit buffered_file(FILE *f) - : file_(f) - { - } - -public: - // Constructs a buffered_file object which doesn't represent any file. - buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {} - - // Destroys the object closing the file it represents if any. - FMT_API ~buffered_file() FMT_DTOR_NOEXCEPT; - -#if !FMT_USE_RVALUE_REFERENCES - // Emulate a move constructor and a move assignment operator if rvalue - // references are not supported. - -private: - // A proxy object to emulate a move constructor. - // It is private to make it impossible call operator Proxy directly. - struct Proxy - { - FILE *file; - }; - -public: - // A "move constructor" for moving from a temporary. - buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {} - - // A "move constructor" for moving from an lvalue. - buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_) - { - f.file_ = FMT_NULL; - } - - // A "move assignment operator" for moving from a temporary. - buffered_file &operator=(Proxy p) - { - close(); - file_ = p.file; - return *this; - } - - // A "move assignment operator" for moving from an lvalue. - buffered_file &operator=(buffered_file &other) - { - close(); - file_ = other.file_; - other.file_ = FMT_NULL; - return *this; - } - - // Returns a proxy object for moving from a temporary: - // buffered_file file = buffered_file(...); - operator Proxy() FMT_NOEXCEPT - { - Proxy p = {file_}; - file_ = FMT_NULL; - return p; - } - -#else -private: - FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file); - -public: - buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) - { - other.file_ = FMT_NULL; - } - - buffered_file &operator=(buffered_file &&other) - { - close(); - file_ = other.file_; - other.file_ = FMT_NULL; - return *this; - } -#endif - - // Opens a file. - FMT_API buffered_file(cstring_view filename, cstring_view mode); - - // Closes the file. - FMT_API void close(); - - // Returns the pointer to a FILE object representing this file. - FILE *get() const FMT_NOEXCEPT - { - return file_; - } - - // We place parentheses around fileno to workaround a bug in some versions - // of MinGW that define fileno as a macro. - FMT_API int(fileno)() const; - - void vprint(string_view format_str, format_args args) - { - fmt::vprint(file_, format_str, args); - } - - template - inline void print(string_view format_str, const Args &... args) - { - vprint(format_str, make_format_args(args...)); - } -}; - -// A file. Closed file is represented by a file object with descriptor -1. -// Methods that are not declared with FMT_NOEXCEPT may throw -// fmt::system_error in case of failure. Note that some errors such as -// closing the file multiple times will cause a crash on Windows rather -// than an exception. You can get standard behavior by overriding the -// invalid parameter handler with _set_invalid_parameter_handler. -class file -{ -private: - int fd_; // File descriptor. - - // Constructs a file object with a given descriptor. - explicit file(int fd) - : fd_(fd) - { - } - -public: - // Possible values for the oflag argument to the constructor. - enum - { - RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. - WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. - RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing. - }; - - // Constructs a file object which doesn't represent any file. - file() FMT_NOEXCEPT : fd_(-1) {} - - // Opens a file and constructs a file object representing this file. - FMT_API file(cstring_view path, int oflag); - -#if !FMT_USE_RVALUE_REFERENCES - // Emulate a move constructor and a move assignment operator if rvalue - // references are not supported. - -private: - // A proxy object to emulate a move constructor. - // It is private to make it impossible call operator Proxy directly. - struct Proxy - { - int fd; - }; - -public: - // A "move constructor" for moving from a temporary. - file(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {} - - // A "move constructor" for moving from an lvalue. - file(file &other) FMT_NOEXCEPT : fd_(other.fd_) - { - other.fd_ = -1; - } - - // A "move assignment operator" for moving from a temporary. - file &operator=(Proxy p) - { - close(); - fd_ = p.fd; - return *this; - } - - // A "move assignment operator" for moving from an lvalue. - file &operator=(file &other) - { - close(); - fd_ = other.fd_; - other.fd_ = -1; - return *this; - } - - // Returns a proxy object for moving from a temporary: - // file f = file(...); - operator Proxy() FMT_NOEXCEPT - { - Proxy p = {fd_}; - fd_ = -1; - return p; - } - -#else -private: - FMT_DISALLOW_COPY_AND_ASSIGN(file); - -public: - file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) - { - other.fd_ = -1; - } - - file &operator=(file &&other) - { - close(); - fd_ = other.fd_; - other.fd_ = -1; - return *this; - } -#endif - - // Destroys the object closing the file it represents if any. - FMT_API ~file() FMT_DTOR_NOEXCEPT; - - // Returns the file descriptor. - int descriptor() const FMT_NOEXCEPT - { - return fd_; - } - - // Closes the file. - FMT_API void close(); - - // Returns the file size. The size has signed type for consistency with - // stat::st_size. - FMT_API long long size() const; - - // Attempts to read count bytes from the file into the specified buffer. - FMT_API std::size_t read(void *buffer, std::size_t count); - - // Attempts to write count bytes from the specified buffer to the file. - FMT_API std::size_t write(const void *buffer, std::size_t count); - - // Duplicates a file descriptor with the dup function and returns - // the duplicate as a file object. - FMT_API static file dup(int fd); - - // Makes fd be the copy of this file descriptor, closing fd first if - // necessary. - FMT_API void dup2(int fd); - - // Makes fd be the copy of this file descriptor, closing fd first if - // necessary. - FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT; - - // Creates a pipe setting up read_end and write_end file objects for reading - // and writing respectively. - FMT_API static void pipe(file &read_end, file &write_end); - - // Creates a buffered_file object associated with this file and detaches - // this file object from the file. - FMT_API buffered_file fdopen(const char *mode); -}; - -// Returns the memory page size. -long getpagesize(); - -#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__) -#define FMT_LOCALE -#endif - -#ifdef FMT_LOCALE -// A "C" numeric locale. -class Locale -{ -private: -#ifdef _MSC_VER - typedef _locale_t locale_t; - - enum - { - LC_NUMERIC_MASK = LC_NUMERIC - }; - - static locale_t newlocale(int category_mask, const char *locale, locale_t) - { - return _create_locale(category_mask, locale); - } - - static void freelocale(locale_t locale) - { - _free_locale(locale); - } - - static double strtod_l(const char *nptr, char **endptr, _locale_t locale) - { - return _strtod_l(nptr, endptr, locale); - } -#endif - - locale_t locale_; - - FMT_DISALLOW_COPY_AND_ASSIGN(Locale); - -public: - typedef locale_t Type; - - Locale() - : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) - { - if (!locale_) - FMT_THROW(system_error(errno, "cannot create locale")); - } - ~Locale() - { - freelocale(locale_); - } - - Type get() const - { - return locale_; - } - - // Converts string to floating-point number and advances str past the end - // of the parsed input. - double strtod(const char *&str) const - { - char *end = FMT_NULL; - double result = strtod_l(str, &end, locale_); - str = end; - return result; - } -}; -#endif // FMT_LOCALE -FMT_END_NAMESPACE - -#if !FMT_USE_RVALUE_REFERENCES -namespace std { -// For compatibility with C++98. -inline fmt::buffered_file &move(fmt::buffered_file &f) -{ - return f; -} -inline fmt::file &move(fmt::file &f) -{ - return f; -} -} // namespace std -#endif - -#endif // FMT_POSIX_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/printf.h b/spdlog_lib/spdlog/fmt/bundled/printf.h deleted file mode 100644 index 1782c2e..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/printf.h +++ /dev/null @@ -1,807 +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 // std::fill_n -#include // std::numeric_limits - -#include "ostream.h" - -FMT_BEGIN_NAMESPACE -namespace internal { - -// Checks if a value fits in int - used to avoid warnings about comparing -// signed and unsigned integers. -template -struct int_checker -{ - template - static bool fits_in_int(T value) - { - unsigned max = std::numeric_limits::max(); - return value <= max; - } - static bool fits_in_int(bool) - { - return true; - } -}; - -template<> -struct int_checker -{ - template - static bool fits_in_int(T value) - { - return value >= std::numeric_limits::min() && value <= std::numeric_limits::max(); - } - static bool fits_in_int(int) - { - return true; - } -}; - -class printf_precision_handler : public function -{ -public: - template - typename std::enable_if::value, int>::type operator()(T value) - { - if (!int_checker::is_signed>::fits_in_int(value)) - FMT_THROW(format_error("number is too big")); - return static_cast(value); - } - - template - typename std::enable_if::value, int>::type operator()(T) - { - FMT_THROW(format_error("precision is not integer")); - return 0; - } -}; - -// An argument visitor that returns true iff arg is a zero integer. -class is_zero_int : public function -{ -public: - template - typename std::enable_if::value, bool>::type operator()(T value) - { - return value == 0; - } - - template - typename std::enable_if::value, bool>::type operator()(T) - { - return false; - } -}; - -template -struct make_unsigned_or_bool : std::make_unsigned -{ -}; - -template<> -struct make_unsigned_or_bool -{ - typedef bool type; -}; - -template -class arg_converter : public function -{ -private: - typedef typename Context::char_type Char; - - basic_format_arg &arg_; - typename Context::char_type type_; - -public: - arg_converter(basic_format_arg &arg, Char type) - : arg_(arg) - , type_(type) - { - } - - void operator()(bool value) - { - if (type_ != 's') - operator()(value); - } - - template - typename std::enable_if::value>::type operator()(U value) - { - bool is_signed = type_ == 'd' || type_ == 'i'; - typedef typename std::conditional::value, U, T>::type TargetType; - if (const_check(sizeof(TargetType) <= sizeof(int))) - { - // Extra casts are used to silence warnings. - if (is_signed) - { - arg_ = internal::make_arg(static_cast(static_cast(value))); - } - else - { - typedef typename make_unsigned_or_bool::type Unsigned; - arg_ = internal::make_arg(static_cast(static_cast(value))); - } - } - else - { - if (is_signed) - { - // glibc's printf doesn't sign extend arguments of smaller types: - // std::printf("%lld", -42); // prints "4294967254" - // but we don't have to do the same because it's a UB. - arg_ = internal::make_arg(static_cast(value)); - } - else - { - arg_ = internal::make_arg(static_cast::type>(value)); - } - } - } - - template - typename std::enable_if::value>::type operator()(U) - { - // No coversion needed for non-integral types. - } -}; - -// 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 -void convert_arg(basic_format_arg &arg, Char type) -{ - visit(arg_converter(arg, type), arg); -} - -// Converts an integer argument to char for printf. -template -class char_converter : public function -{ -private: - basic_format_arg &arg_; - - FMT_DISALLOW_COPY_AND_ASSIGN(char_converter); - -public: - explicit char_converter(basic_format_arg &arg) - : arg_(arg) - { - } - - template - typename std::enable_if::value>::type operator()(T value) - { - typedef typename Context::char_type Char; - arg_ = internal::make_arg(static_cast(value)); - } - - template - typename std::enable_if::value>::type operator()(T) - { - // No coversion needed for non-integral types. - } -}; - -// Checks if an argument is a valid printf width specifier and sets -// left alignment if it is negative. -template -class printf_width_handler : public function -{ -private: - typedef basic_format_specs format_specs; - - format_specs &spec_; - - FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler); - -public: - explicit printf_width_handler(format_specs &spec) - : spec_(spec) - { - } - - template - typename std::enable_if::value, unsigned>::type operator()(T value) - { - typedef typename internal::int_traits::main_type UnsignedType; - UnsignedType width = static_cast(value); - if (internal::is_negative(value)) - { - spec_.align_ = ALIGN_LEFT; - width = 0 - width; - } - unsigned int_max = std::numeric_limits::max(); - if (width > int_max) - FMT_THROW(format_error("number is too big")); - return static_cast(width); - } - - template - typename std::enable_if::value, unsigned>::type operator()(T) - { - FMT_THROW(format_error("width is not integer")); - return 0; - } -}; -} // namespace internal - -template -class printf_arg_formatter; - -template>>> -class basic_printf_context; - -/** - \rst - The ``printf`` argument formatter. - \endrst - */ -template -class printf_arg_formatter : public internal::function::iterator>, - public internal::arg_formatter_base -{ -private: - typedef typename Range::value_type char_type; - typedef decltype(internal::declval().begin()) iterator; - typedef internal::arg_formatter_base base; - typedef basic_printf_context context_type; - - context_type &context_; - - void write_null_pointer(char) - { - this->spec().type_ = 0; - this->write("(nil)"); - } - - void write_null_pointer(wchar_t) - { - this->spec().type_ = 0; - this->write(L"(nil)"); - } - -public: - typedef typename base::format_specs format_specs; - - /** - \rst - Constructs an argument formatter object. - *buffer* is a reference to the output buffer and *spec* contains format - specifier information for standard argument types. - \endrst - */ - printf_arg_formatter(internal::basic_buffer &buffer, format_specs &spec, context_type &ctx) - : base(back_insert_range>(buffer), spec) - , context_(ctx) - { - } - - template - typename std::enable_if::value, iterator>::type operator()(T value) - { - // MSVC2013 fails to compile separate overloads for bool and char_type so - // use std::is_same instead. - if (std::is_same::value) - { - format_specs &fmt_spec = this->spec(); - if (fmt_spec.type_ != 's') - return base::operator()(value ? 1 : 0); - fmt_spec.type_ = 0; - this->write(value != 0); - } - else if (std::is_same::value) - { - format_specs &fmt_spec = this->spec(); - if (fmt_spec.type_ && fmt_spec.type_ != 'c') - return (*this)(static_cast(value)); - fmt_spec.flags_ = 0; - fmt_spec.align_ = ALIGN_RIGHT; - return base::operator()(value); - } - else - { - return base::operator()(value); - } - return this->out(); - } - - template - typename std::enable_if::value, iterator>::type operator()(T value) - { - return base::operator()(value); - } - - /** Formats a null-terminated C string. */ - iterator operator()(const char *value) - { - if (value) - base::operator()(value); - else if (this->spec().type_ == 'p') - write_null_pointer(char_type()); - else - this->write("(null)"); - return this->out(); - } - - /** Formats a null-terminated wide C string. */ - iterator operator()(const wchar_t *value) - { - if (value) - base::operator()(value); - else if (this->spec().type_ == 'p') - write_null_pointer(char_type()); - else - this->write(L"(null)"); - return this->out(); - } - - iterator operator()(basic_string_view value) - { - return base::operator()(value); - } - - iterator operator()(monostate value) - { - return base::operator()(value); - } - - /** Formats a pointer. */ - iterator operator()(const void *value) - { - if (value) - return base::operator()(value); - this->spec().type_ = 0; - write_null_pointer(char_type()); - return this->out(); - } - - /** Formats an argument of a custom (user-defined) type. */ - iterator operator()(typename basic_format_arg::handle handle) - { - handle.format(context_); - return this->out(); - } -}; - -template -struct printf_formatter -{ - template - auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { - return ctx.begin(); - } - - template - auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) - { - internal::format_value(internal::get_container(ctx.out()), value); - return ctx.out(); - } -}; - -/** This template formats data and writes the output to a writer. */ -template -class basic_printf_context : private internal::context_base, Char> -{ -public: - /** The character type for the output. */ - typedef Char char_type; - - template - struct formatter_type - { - typedef printf_formatter type; - }; - -private: - typedef internal::context_base base; - typedef typename base::format_arg format_arg; - typedef basic_format_specs format_specs; - typedef internal::null_terminating_iterator iterator; - - void parse_flags(format_specs &spec, iterator &it); - - // Returns the argument with specified index or, if arg_index is equal - // to the maximum unsigned value, the next argument. - format_arg get_arg(iterator it, unsigned arg_index = (std::numeric_limits::max)()); - - // Parses argument index, flags and width and returns the argument index. - unsigned parse_header(iterator &it, format_specs &spec); - -public: - /** - \rst - Constructs a ``printf_context`` object. References to the arguments and - the writer are stored in the context object so make sure they have - appropriate lifetimes. - \endrst - */ - basic_printf_context(OutputIt out, basic_string_view format_str, basic_format_args args) - : base(out, format_str, args) - { - } - - using base::advance_to; - using base::out; - using base::parse_context; - - /** Formats stored arguments and writes the output to the range. */ - void format(); -}; - -template -void basic_printf_context::parse_flags(format_specs &spec, iterator &it) -{ - for (;;) - { - switch (*it++) - { - 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: - --it; - return; - } - } -} - -template -typename basic_printf_context::format_arg basic_printf_context::get_arg( - iterator it, unsigned arg_index) -{ - (void)it; - if (arg_index == std::numeric_limits::max()) - return this->do_get_arg(this->parse_context().next_arg_id()); - return base::get_arg(arg_index - 1); -} - -template -unsigned basic_printf_context::parse_header(iterator &it, format_specs &spec) -{ - unsigned arg_index = std::numeric_limits::max(); - char_type c = *it; - if (c >= '0' && c <= '9') - { - // Parse an argument index (if followed by '$') or a width possibly - // preceded with '0' flag(s). - internal::error_handler eh; - unsigned value = parse_nonnegative_int(it, eh); - if (*it == '$') - { // value is an argument index - ++it; - 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, it); - // Parse width. - if (*it >= '0' && *it <= '9') - { - internal::error_handler eh; - spec.width_ = parse_nonnegative_int(it, eh); - } - else if (*it == '*') - { - ++it; - spec.width_ = visit(internal::printf_width_handler(spec), get_arg(it)); - } - return arg_index; -} - -template -void basic_printf_context::format() -{ - auto &buffer = internal::get_container(this->out()); - auto start = iterator(this->parse_context()); - auto it = start; - using internal::pointer_from; - while (*it) - { - char_type c = *it++; - if (c != '%') - continue; - if (*it == c) - { - buffer.append(pointer_from(start), pointer_from(it)); - start = ++it; - continue; - } - buffer.append(pointer_from(start), pointer_from(it) - 1); - - format_specs spec; - spec.align_ = ALIGN_RIGHT; - - // Parse argument index, flags and width. - unsigned arg_index = parse_header(it, spec); - - // Parse precision. - if (*it == '.') - { - ++it; - if ('0' <= *it && *it <= '9') - { - internal::error_handler eh; - spec.precision_ = static_cast(parse_nonnegative_int(it, eh)); - } - else if (*it == '*') - { - ++it; - spec.precision_ = visit(internal::printf_precision_handler(), get_arg(it)); - } - else - { - spec.precision_ = 0; - } - } - - format_arg arg = get_arg(it, arg_index); - if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg)) - spec.flags_ &= ~internal::to_unsigned(HASH_FLAG); - if (spec.fill_ == '0') - { - if (arg.is_arithmetic()) - 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::convert_arg; - switch (*it++) - { - case 'h': - if (*it == 'h') - convert_arg(arg, *++it); - else - convert_arg(arg, *it); - break; - case 'l': - if (*it == 'l') - convert_arg(arg, *++it); - else - convert_arg(arg, *it); - break; - case 'j': - convert_arg(arg, *it); - break; - case 'z': - convert_arg(arg, *it); - break; - case 't': - convert_arg(arg, *it); - break; - case 'L': - // printf produces garbage when 'L' is omitted for long double, no - // need to do the same. - break; - default: - --it; - convert_arg(arg, *it); - } - - // Parse type. - if (!*it) - FMT_THROW(format_error("invalid format string")); - spec.type_ = static_cast(*it++); - if (arg.is_integral()) - { - // Normalize type. - switch (spec.type_) - { - case 'i': - case 'u': - spec.type_ = 'd'; - break; - case 'c': - // TODO: handle wchar_t better? - visit(internal::char_converter(arg), arg); - break; - } - } - - start = it; - - // Format argument. - visit(AF(buffer, spec, *this), arg); - } - buffer.append(pointer_from(start), pointer_from(it)); -} - -template -void printf(internal::basic_buffer &buf, basic_string_view format, basic_format_args args) -{ - Context(std::back_inserter(buf), format, args).format(); -} - -template -struct printf_context -{ - typedef basic_printf_context, typename Buffer::value_type> type; -}; - -template -inline format_arg_store::type, Args...> make_printf_args(const Args &... args) -{ - return format_arg_store::type, Args...>(args...); -} -typedef basic_format_args::type> printf_args; -typedef basic_format_args::type> wprintf_args; - -inline std::string vsprintf(string_view format, printf_args args) -{ - memory_buffer buffer; - printf(buffer, format, args); - return to_string(buffer); -} - -/** - \rst - Formats arguments and returns the result as a string. - - **Example**:: - - std::string message = fmt::sprintf("The answer is %d", 42); - \endrst -*/ -template -inline std::string sprintf(string_view format_str, const Args &... args) -{ - return vsprintf(format_str, make_format_args::type>(args...)); -} - -inline std::wstring vsprintf(wstring_view format, wprintf_args args) -{ - wmemory_buffer buffer; - printf(buffer, format, args); - return to_string(buffer); -} - -template -inline std::wstring sprintf(wstring_view format_str, const Args &... args) -{ - return vsprintf(format_str, make_format_args::type>(args...)); -} - -template -inline int vfprintf( - std::FILE *f, basic_string_view format, basic_format_args>::type> args) -{ - basic_memory_buffer buffer; - printf(buffer, format, args); - std::size_t size = buffer.size(); - return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast(size); -} - -/** - \rst - Prints formatted data to the file *f*. - - **Example**:: - - fmt::fprintf(stderr, "Don't %s!", "panic"); - \endrst - */ -template -inline int fprintf(std::FILE *f, string_view format_str, const Args &... args) -{ - auto vargs = make_format_args::type>(args...); - return vfprintf(f, format_str, vargs); -} - -template -inline int fprintf(std::FILE *f, wstring_view format_str, const Args &... args) -{ - return vfprintf(f, format_str, make_format_args::type>(args...)); -} - -inline int vprintf(string_view format, printf_args args) -{ - return vfprintf(stdout, format, args); -} - -inline int vprintf(wstring_view format, wprintf_args args) -{ - return vfprintf(stdout, format, args); -} - -/** - \rst - Prints formatted data to ``stdout``. - - **Example**:: - - fmt::printf("Elapsed time: %.2f seconds", 1.23); - \endrst - */ -template -inline int printf(string_view format_str, const Args &... args) -{ - return vprintf(format_str, make_format_args::type>(args...)); -} - -template -inline int printf(wstring_view format_str, const Args &... args) -{ - return vprintf(format_str, make_format_args::type>(args...)); -} - -inline int vfprintf(std::ostream &os, string_view format_str, printf_args args) -{ - memory_buffer buffer; - printf(buffer, format_str, args); - internal::write(os, buffer); - return static_cast(buffer.size()); -} - -inline int vfprintf(std::wostream &os, wstring_view format_str, wprintf_args args) -{ - wmemory_buffer buffer; - printf(buffer, format_str, args); - internal::write(os, buffer); - return static_cast(buffer.size()); -} - -/** - \rst - Prints formatted data to the stream *os*. - - **Example**:: - - fmt::fprintf(cerr, "Don't %s!", "panic"); - \endrst - */ -template -inline int fprintf(std::ostream &os, string_view format_str, const Args &... args) -{ - auto vargs = make_format_args::type>(args...); - return vfprintf(os, format_str, vargs); -} - -template -inline int fprintf(std::wostream &os, wstring_view format_str, const Args &... args) -{ - auto vargs = make_format_args::type>(args...); - return vfprintf(os, format_str, vargs); -} -FMT_END_NAMESPACE - -#endif // FMT_PRINTF_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/ranges.h b/spdlog_lib/spdlog/fmt/bundled/ranges.h deleted file mode 100644 index ba2a979..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/ranges.h +++ /dev/null @@ -1,344 +0,0 @@ -// Formatting library for C++ - the core API -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. -// -// Copyright (c) 2018 - present, Remotion (Igor Schulz) -// All Rights Reserved -// {fmt} support for ranges, containers and types tuple interface. - -#ifndef FMT_RANGES_H_ -#define FMT_RANGES_H_ - -#include "format.h" -#include - -// output only up to N items from the range. -#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT -#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256 -#endif - -FMT_BEGIN_NAMESPACE - -template -struct formatting_base -{ - template - FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { - return ctx.begin(); - } -}; - -template -struct formatting_range : formatting_base -{ - static FMT_CONSTEXPR_DECL const std::size_t range_length_limit = FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the - // range. - Char prefix; - Char delimiter; - Char postfix; - formatting_range() - : prefix('{') - , delimiter(',') - , postfix('}') - { - } - static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true; - static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false; -}; - -template -struct formatting_tuple : formatting_base -{ - Char prefix; - Char delimiter; - Char postfix; - formatting_tuple() - : prefix('(') - , delimiter(',') - , postfix(')') - { - } - static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true; - static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false; -}; - -namespace internal { - -template -void copy(const RangeT &range, OutputIterator out) -{ - for (auto it = range.begin(), end = range.end(); it != end; ++it) - *out++ = *it; -} - -template -void copy(const char *str, OutputIterator out) -{ - const char *p_curr = str; - while (*p_curr) - { - *out++ = *p_curr++; - } -} - -template -void copy(char ch, OutputIterator out) -{ - *out++ = ch; -} - -/// Return true value if T has std::string interface, like std::string_view. -template -class is_like_std_string -{ - template - static auto check(U *p) -> decltype(p->find('a'), p->length(), p->data(), int()); - template - static void check(...); - -public: - static FMT_CONSTEXPR_DECL const bool value = !std::is_void(FMT_NULL))>::value; -}; - -template -struct conditional_helper -{ -}; - -template -struct is_range_ : std::false_type -{ -}; - -#if !FMT_MSC_VER || FMT_MSC_VER > 1800 -template -struct is_range_().begin()), decltype(internal::declval().end())>, void>::type> - : std::true_type -{ -}; -#endif - -/// tuple_size and tuple_element check. -template -class is_tuple_like_ -{ - template - static auto check(U *p) -> decltype(std::tuple_size::value, internal::declval::type>(), int()); - template - static void check(...); - -public: - static FMT_CONSTEXPR_DECL const bool value = !std::is_void(FMT_NULL))>::value; -}; - -// Check for integer_sequence -#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900 -template -using integer_sequence = std::integer_sequence; -template -using index_sequence = std::index_sequence; -template -using make_index_sequence = std::make_index_sequence; -#else -template -struct integer_sequence -{ - typedef T value_type; - - static FMT_CONSTEXPR std::size_t size() - { - return sizeof...(N); - } -}; - -template -using index_sequence = integer_sequence; - -template -struct make_integer_sequence : make_integer_sequence -{ -}; -template -struct make_integer_sequence : integer_sequence -{ -}; - -template -using make_index_sequence = make_integer_sequence; -#endif - -template -void for_each(index_sequence, Tuple &&tup, F &&f) FMT_NOEXCEPT -{ - using std::get; - // using free function get(T) now. - const int _[] = {0, ((void)f(get(tup)), 0)...}; - (void)_; // blocks warnings -} - -template -FMT_CONSTEXPR make_index_sequence::value> get_indexes(T const &) -{ - return {}; -} - -template -void for_each(Tuple &&tup, F &&f) -{ - const auto indexes = get_indexes(tup); - for_each(indexes, std::forward(tup), std::forward(f)); -} - -template -FMT_CONSTEXPR const char *format_str_quoted( - bool add_space, const Arg &, typename std::enable_if::type>::value>::type * = nullptr) -{ - return add_space ? " {}" : "{}"; -} - -template -FMT_CONSTEXPR const char *format_str_quoted( - bool add_space, const Arg &, typename std::enable_if::type>::value>::type * = nullptr) -{ - return add_space ? " \"{}\"" : "\"{}\""; -} - -FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *) -{ - return add_space ? " \"{}\"" : "\"{}\""; -} -FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *) -{ - return add_space ? L" \"{}\"" : L"\"{}\""; -} - -FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char) -{ - return add_space ? " '{}'" : "'{}'"; -} -FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t) -{ - return add_space ? L" '{}'" : L"'{}'"; -} - -} // namespace internal - -template -struct is_tuple_like -{ - static FMT_CONSTEXPR_DECL const bool value = internal::is_tuple_like_::value && !internal::is_range_::value; -}; - -template -struct formatter::value>::type> -{ -private: - // C++11 generic lambda for format() - template - struct format_each - { - template - void operator()(const T &v) - { - if (i > 0) - { - if (formatting.add_prepostfix_space) - { - *out++ = ' '; - } - internal::copy(formatting.delimiter, out); - } - format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v); - ++i; - } - - formatting_tuple &formatting; - std::size_t &i; - typename std::add_lvalue_reference().out())>::type out; - }; - -public: - formatting_tuple formatting; - - template - FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { - return formatting.parse(ctx); - } - - template - auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) - { - auto out = ctx.out(); - std::size_t i = 0; - internal::copy(formatting.prefix, out); - - internal::for_each(values, format_each{formatting, i, out}); - if (formatting.add_prepostfix_space) - { - *out++ = ' '; - } - internal::copy(formatting.postfix, out); - - return ctx.out(); - } -}; - -template -struct is_range -{ - static FMT_CONSTEXPR_DECL const bool value = internal::is_range_::value && !internal::is_like_std_string::value; -}; - -template -struct formatter::value>::type> -{ - - formatting_range formatting; - - template - FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { - return formatting.parse(ctx); - } - - template - typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx) - { - auto out = ctx.out(); - internal::copy(formatting.prefix, out); - std::size_t i = 0; - for (auto it = values.begin(), end = values.end(); it != end; ++it) - { - if (i > 0) - { - if (formatting.add_prepostfix_space) - { - *out++ = ' '; - } - internal::copy(formatting.delimiter, out); - } - format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it); - if (++i > formatting.range_length_limit) - { - format_to(out, " ... "); - break; - } - } - if (formatting.add_prepostfix_space) - { - *out++ = ' '; - } - internal::copy(formatting.postfix, out); - return ctx.out(); - } -}; - -FMT_END_NAMESPACE - -#endif // FMT_RANGES_H_ diff --git a/spdlog_lib/spdlog/fmt/bundled/time.h b/spdlog_lib/spdlog/fmt/bundled/time.h deleted file mode 100644 index 3e1443b..0000000 --- a/spdlog_lib/spdlog/fmt/bundled/time.h +++ /dev/null @@ -1,199 +0,0 @@ -// Formatting library for C++ - time formatting -// -// Copyright (c) 2012 - 2016, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#ifndef FMT_TIME_H_ -#define FMT_TIME_H_ - -#include "format.h" -#include - -FMT_BEGIN_NAMESPACE - -namespace internal { -inline null<> localtime_r(...) -{ - return null<>(); -} -inline null<> localtime_s(...) -{ - return null<>(); -} -inline null<> gmtime_r(...) -{ - return null<>(); -} -inline null<> gmtime_s(...) -{ - return null<>(); -} -} // namespace internal - -// Thread-safe replacement for std::localtime -inline std::tm localtime(std::time_t time) -{ - struct dispatcher - { - std::time_t time_; - std::tm tm_; - - dispatcher(std::time_t t) - : time_(t) - { - } - - bool run() - { - using namespace fmt::internal; - return handle(localtime_r(&time_, &tm_)); - } - - bool handle(std::tm *tm) - { - return tm != FMT_NULL; - } - - bool handle(internal::null<>) - { - using namespace fmt::internal; - return fallback(localtime_s(&tm_, &time_)); - } - - bool fallback(int res) - { - return res == 0; - } - - bool fallback(internal::null<>) - { - using namespace fmt::internal; - std::tm *tm = std::localtime(&time_); - if (tm) - tm_ = *tm; - return tm != FMT_NULL; - } - }; - dispatcher lt(time); - if (lt.run()) - return lt.tm_; - // Too big time values may be unsupported. - FMT_THROW(format_error("time_t value out of range")); -} - -// Thread-safe replacement for std::gmtime -inline std::tm gmtime(std::time_t time) -{ - struct dispatcher - { - std::time_t time_; - std::tm tm_; - - dispatcher(std::time_t t) - : time_(t) - { - } - - bool run() - { - using namespace fmt::internal; - return handle(gmtime_r(&time_, &tm_)); - } - - bool handle(std::tm *tm) - { - return tm != FMT_NULL; - } - - bool handle(internal::null<>) - { - using namespace fmt::internal; - return fallback(gmtime_s(&tm_, &time_)); - } - - bool fallback(int res) - { - return res == 0; - } - - bool fallback(internal::null<>) - { - std::tm *tm = std::gmtime(&time_); - if (tm) - tm_ = *tm; - return tm != FMT_NULL; - } - }; - dispatcher gt(time); - if (gt.run()) - return gt.tm_; - // Too big time values may be unsupported. - FMT_THROW(format_error("time_t value out of range")); -} - -namespace internal { -inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time) -{ - return std::strftime(str, count, format, time); -} - -inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format, const std::tm *time) -{ - return std::wcsftime(str, count, format, time); -} -} // namespace internal - -template -struct formatter -{ - template - auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { - auto it = internal::null_terminating_iterator(ctx); - if (*it == ':') - ++it; - auto end = it; - while (*end && *end != '}') - ++end; - tm_format.reserve(end - it + 1); - using internal::pointer_from; - tm_format.append(pointer_from(it), pointer_from(end)); - tm_format.push_back('\0'); - return pointer_from(end); - } - - template - auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) - { - internal::basic_buffer &buf = internal::get_container(ctx.out()); - std::size_t start = buf.size(); - for (;;) - { - std::size_t size = buf.capacity() - start; - std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm); - if (count != 0) - { - buf.resize(start + count); - break; - } - if (size >= tm_format.size() * 256) - { - // If the buffer is 256 times larger than the format string, assume - // that `strftime` gives an empty result. There doesn't seem to be a - // better way to distinguish the two cases: - // https://github.com/fmtlib/fmt/issues/367 - break; - } - const std::size_t MIN_GROWTH = 10; - buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH)); - } - return ctx.out(); - } - - basic_memory_buffer tm_format; -}; -FMT_END_NAMESPACE - -#endif // FMT_TIME_H_ diff --git a/spdlog_lib/spdlog/fmt/fmt.h b/spdlog_lib/spdlog/fmt/fmt.h deleted file mode 100644 index 616af0c..0000000 --- a/spdlog_lib/spdlog/fmt/fmt.h +++ /dev/null @@ -1,25 +0,0 @@ -// -// Copyright(c) 2016-2018 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 "bundled/core.h" -#include "bundled/format.h" -#else // external fmtlib -#include -#include -#endif diff --git a/spdlog_lib/spdlog/fmt/ostr.h b/spdlog_lib/spdlog/fmt/ostr.h deleted file mode 100644 index 9902898..0000000 --- a/spdlog_lib/spdlog/fmt/ostr.h +++ /dev/null @@ -1,18 +0,0 @@ -// -// Copyright(c) 2016 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -// -// include bundled or external copy of fmtlib's ostream support -// -#if !defined(SPDLOG_FMT_EXTERNAL) -#ifndef FMT_HEADER_ONLY -#define FMT_HEADER_ONLY -#endif -#include "bundled/ostream.h" -#include "fmt.h" -#else -#include -#endif diff --git a/spdlog_lib/spdlog/formatter.h b/spdlog_lib/spdlog/formatter.h deleted file mode 100644 index a7ef6b8..0000000 --- a/spdlog_lib/spdlog/formatter.h +++ /dev/null @@ -1,20 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "fmt/fmt.h" -#include "spdlog/details/log_msg.h" - -namespace spdlog { - -class formatter -{ -public: - virtual ~formatter() = default; - virtual void format(const details::log_msg &msg, fmt::memory_buffer &dest) = 0; - virtual std::unique_ptr clone() const = 0; -}; -} // namespace spdlog diff --git a/spdlog_lib/spdlog/logger.h b/spdlog_lib/spdlog/logger.h deleted file mode 100644 index 91eec4b..0000000 --- a/spdlog_lib/spdlog/logger.h +++ /dev/null @@ -1,162 +0,0 @@ -// -// Copyright(c) 2015-2108 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -// Thread safe logger (except for set_pattern(..), set_formatter(..) and -// set_error_handler()) -// 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 and if yes: -// 2. Call the underlying sinks to do the job. -// 3. Each sink use its own private copy of a formatter to format the message -// and send to its destination. -// -// The use of private formatter per sink provides the opportunity to cache some -// formatted data, -// and support customize format per each sink. - -#include "spdlog/common.h" -#include "spdlog/formatter.h" -#include "spdlog/sinks/sink.h" - -#include -#include -#include - -namespace spdlog { - -class logger -{ -public: - logger(std::string name, sink_ptr single_sink); - logger(std::string name, sinks_init_list sinks); - - template - logger(std::string name, const It &begin, const It &end); - - virtual ~logger(); - - logger(const logger &) = delete; - logger &operator=(const logger &) = delete; - - template - void log(level::level_enum lvl, const char *fmt, const Args &... args); - - template - void log(level::level_enum lvl, const char *msg); - - template - void trace(const char *fmt, const Args &... args); - - template - void debug(const char *fmt, const Args &... args); - - template - void info(const char *fmt, const Args &... args); - - template - void warn(const char *fmt, const Args &... args); - - template - void error(const char *fmt, const Args &... args); - - template - void critical(const char *fmt, const Args &... args); - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - template - void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args); - - template - void trace(const wchar_t *fmt, const Args &... args); - - template - void debug(const wchar_t *fmt, const Args &... args); - - template - void info(const wchar_t *fmt, const Args &... args); - - template - void warn(const wchar_t *fmt, const Args &... args); - - template - void error(const wchar_t *fmt, const Args &... args); - - template - void critical(const wchar_t *fmt, const Args &... args); -#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT - - template - void log(level::level_enum lvl, const T &); - - template - void trace(const T &msg); - - template - void debug(const T &msg); - - template - void info(const T &msg); - - template - void warn(const T &msg); - - template - void error(const T &msg); - - template - void critical(const T &msg); - - bool should_log(level::level_enum msg_level) const; - void set_level(level::level_enum log_level); - level::level_enum level() const; - const std::string &name() const; - - // set formatting for the sinks in this logger. - // each sink will get a seperate instance of the formatter object. - void set_formatter(std::unique_ptr formatter); - void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); - - void flush(); - void flush_on(level::level_enum log_level); - - const std::vector &sinks() const; - - std::vector &sinks(); - - void set_error_handler(log_err_handler err_handler); - log_err_handler error_handler(); - -protected: - virtual void sink_it_(details::log_msg &msg); - virtual void flush_(); - - bool should_flush_(const details::log_msg &msg); - - // default error handler: print the error to stderr with the max rate of 1 - // message/minute - void default_err_handler_(const std::string &msg); - - // increment the message count (only if - // defined(SPDLOG_ENABLE_MESSAGE_COUNTER)) - void incr_msg_counter_(details::log_msg &msg); - - const std::string name_; - std::vector sinks_; - spdlog::level_t level_; - spdlog::level_t flush_level_; - log_err_handler err_handler_; - std::atomic last_err_time_; - std::atomic msg_counter_; - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - std::wstring_convert> wstring_converter_; - std::mutex wstring_converter_mutex_; -#endif -}; -} // namespace spdlog - -#include "details/logger_impl.h" diff --git a/spdlog_lib/spdlog/sinks/android_sink.h b/spdlog_lib/spdlog/sinks/android_sink.h deleted file mode 100644 index be70db0..0000000 --- a/spdlog_lib/spdlog/sinks/android_sink.h +++ /dev/null @@ -1,117 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "spdlog/details/fmt_helper.h" -#include "spdlog/details/null_mutex.h" -#include "spdlog/details/os.h" -#include "spdlog/sinks/base_sink.h" - -#include -#include -#include -#include -#include - -#if !defined(SPDLOG_ANDROID_RETRIES) -#define SPDLOG_ANDROID_RETRIES 2 -#endif - -namespace spdlog { -namespace sinks { - -/* - * Android sink (logging using __android_log_write) - */ -template -class android_sink SPDLOG_FINAL : public base_sink -{ -public: - explicit android_sink(const std::string &tag = "spdlog", bool use_raw_msg = false) - : tag_(tag) - , use_raw_msg_(use_raw_msg) - { - } - -protected: - void sink_it_(const details::log_msg &msg) override - { - const android_LogPriority priority = convert_to_android_(msg.level); - fmt::memory_buffer formatted; - if (use_raw_msg_) - { - fmt_helper::append_buf(msg.raw, formatted); - } - else - { - formatter_->format(msg, formatted); - } - formatted.push_back('\0'); - const char *msg_output = formatted.data(); - - // See system/core/liblog/logger_write.c for explanation of return value - int ret = __android_log_write(priority, tag_.c_str(), msg_output); - int retry_count = 0; - while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) - { - details::os::sleep_for_millis(5); - ret = __android_log_write(priority, tag_.c_str(), msg_output); - retry_count++; - } - - 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_; - bool use_raw_msg_; -}; - -using android_sink_mt = android_sink; -using android_sink_st = android_sink; -} // namespace sinks - -// Create and register android syslog logger - -template -inline std::shared_ptr android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog") -{ - return Factory::template create(logger_name, tag); -} - -template -inline std::shared_ptr android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog") -{ - return Factory::template create(logger_name, tag); -} - -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/ansicolor_sink.h b/spdlog_lib/spdlog/sinks/ansicolor_sink.h deleted file mode 100644 index 3b79976..0000000 --- a/spdlog_lib/spdlog/sinks/ansicolor_sink.h +++ /dev/null @@ -1,156 +0,0 @@ -// -// Copyright(c) 2017 spdlog authors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "spdlog/details/console_globals.h" -#include "spdlog/details/null_mutex.h" -#include "spdlog/details/os.h" - -#include -#include -#include -#include - -namespace spdlog { -namespace sinks { - -/** - * This sink prefixes the output with an ANSI escape sequence color code - * depending on the severity - * of the message. - * If no color terminal detected, omit the escape codes. - */ -template -class ansicolor_sink : public sink -{ -public: - using mutex_t = typename ConsoleMutex::mutex_t; - ansicolor_sink() - : target_file_(TargetStream::stream()) - , mutex_(ConsoleMutex::mutex()) - - { - should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal(); - colors_[level::trace] = white; - colors_[level::debug] = cyan; - colors_[level::info] = green; - colors_[level::warn] = yellow + bold; - colors_[level::err] = red + bold; - colors_[level::critical] = bold + on_red; - colors_[level::off] = reset; - } - - ~ansicolor_sink() override = default; - - ansicolor_sink(const ansicolor_sink &other) = delete; - ansicolor_sink &operator=(const ansicolor_sink &other) = delete; - - void set_color(level::level_enum color_level, const std::string &color) - { - std::lock_guard lock(mutex_); - colors_[color_level] = color; - } - - /// Formatting codes - const std::string reset = "\033[m"; - 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"; - const std::string clear_line = "\033[K"; - - // Foreground colors - const std::string black = "\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_black = "\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"; - - void log(const details::log_msg &msg) SPDLOG_FINAL override - { - // Wrap the originally formatted message in color codes. - // If color is not supported in the terminal, log as is instead. - std::lock_guard lock(mutex_); - - fmt::memory_buffer formatted; - formatter_->format(msg, formatted); - if (should_do_colors_ && msg.color_range_end > msg.color_range_start) - { - // before color range - print_range_(formatted, 0, msg.color_range_start); - // in color range - print_ccode_(colors_[msg.level]); - print_range_(formatted, msg.color_range_start, msg.color_range_end); - print_ccode_(reset); - // after color range - print_range_(formatted, msg.color_range_end, formatted.size()); - } - else // no color - { - print_range_(formatted, 0, formatted.size()); - } - fflush(target_file_); - } - - void flush() SPDLOG_FINAL override - { - std::lock_guard lock(mutex_); - fflush(target_file_); - } - - void set_pattern(const std::string &pattern) override SPDLOG_FINAL - { - std::lock_guard lock(mutex_); - formatter_ = std::unique_ptr(new pattern_formatter(pattern)); - } - - void set_formatter(std::unique_ptr sink_formatter) override SPDLOG_FINAL - { - std::lock_guard lock(mutex_); - formatter_ = std::move(sink_formatter); - } - -private: - void print_ccode_(const std::string &color_code) - { - fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); - } - void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end) - { - fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); - } - - FILE *target_file_; - mutex_t &mutex_; - - bool should_do_colors_; - std::unordered_map colors_; -}; - -using ansicolor_stdout_sink_mt = ansicolor_sink; -using ansicolor_stdout_sink_st = ansicolor_sink; - -using ansicolor_stderr_sink_mt = ansicolor_sink; -using ansicolor_stderr_sink_st = ansicolor_sink; - -} // namespace sinks - -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/base_sink.h b/spdlog_lib/spdlog/sinks/base_sink.h deleted file mode 100644 index 5a3821b..0000000 --- a/spdlog_lib/spdlog/sinks/base_sink.h +++ /dev/null @@ -1,63 +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 real) -// concrete implementation should override the sink_it_() and flush_() methods. -// locking is taken care of in this class - no locking needed by the -// implementers.. -// - -#include "spdlog/common.h" -#include "spdlog/details/log_msg.h" -#include "spdlog/formatter.h" -#include "spdlog/sinks/sink.h" - -namespace spdlog { -namespace sinks { -template -class base_sink : public sink -{ -public: - base_sink() - : sink() - { - } - - base_sink(const base_sink &) = delete; - base_sink &operator=(const base_sink &) = delete; - - void log(const details::log_msg &msg) SPDLOG_FINAL override - { - std::lock_guard lock(mutex_); - sink_it_(msg); - } - - void flush() SPDLOG_FINAL override - { - std::lock_guard lock(mutex_); - flush_(); - } - - void set_pattern(const std::string &pattern) SPDLOG_FINAL override - { - std::lock_guard lock(mutex_); - formatter_ = std::unique_ptr(new pattern_formatter(pattern)); - } - - void set_formatter(std::unique_ptr sink_formatter) SPDLOG_FINAL override - { - std::lock_guard lock(mutex_); - formatter_ = std::move(sink_formatter); - } - -protected: - virtual void sink_it_(const details::log_msg &msg) = 0; - virtual void flush_() = 0; - Mutex mutex_; -}; -} // namespace sinks -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/basic_file_sink.h b/spdlog_lib/spdlog/sinks/basic_file_sink.h deleted file mode 100644 index 5db38e8..0000000 --- a/spdlog_lib/spdlog/sinks/basic_file_sink.h +++ /dev/null @@ -1,66 +0,0 @@ -// -// Copyright(c) 2015-2018 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -#include "spdlog/details/file_helper.h" -#include "spdlog/details/null_mutex.h" -#include "spdlog/sinks/base_sink.h" -#include "spdlog/spdlog.h" - -#include -#include - -namespace spdlog { -namespace sinks { -/* - * Trivial file sink with single file as target - */ -template -class basic_file_sink SPDLOG_FINAL : public base_sink -{ -public: - explicit basic_file_sink(const filename_t &filename, bool truncate = false) - { - file_helper_.open(filename, truncate); - } - -protected: - void sink_it_(const details::log_msg &msg) override - { - fmt::memory_buffer formatted; - sink::formatter_->format(msg, formatted); - file_helper_.write(formatted); - } - - void flush_() override - { - file_helper_.flush(); - } - -private: - details::file_helper file_helper_; -}; - -using basic_file_sink_mt = basic_file_sink; -using basic_file_sink_st = basic_file_sink; - -} // namespace sinks - -// -// factory functions -// -template -inline std::shared_ptr basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false) -{ - return Factory::template create(logger_name, filename, truncate); -} - -template -inline std::shared_ptr basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false) -{ - return Factory::template create(logger_name, filename, truncate); -} - -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/daily_file_sink.h b/spdlog_lib/spdlog/sinks/daily_file_sink.h deleted file mode 100644 index 940d55d..0000000 --- a/spdlog_lib/spdlog/sinks/daily_file_sink.h +++ /dev/null @@ -1,132 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -#include "spdlog/details/file_helper.h" -#include "spdlog/details/null_mutex.h" -#include "spdlog/fmt/fmt.h" -#include "spdlog/sinks/base_sink.h" -#include "spdlog/spdlog.h" - -#include -#include -#include -#include -#include - -namespace spdlog { -namespace sinks { - -/* - * Generator of daily log file names in format basename.YYYY-MM-DD.ext - */ -struct daily_filename_calculator -{ - // Create filename for the form basename.YYYY-MM-DD - static filename_t calc_filename(const filename_t &filename, const tm &now_tm) - { - filename_t basename, ext; - std::tie(basename, ext) = details::file_helper::split_by_extenstion(filename); - std::conditional::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w; - fmt::format_to( - w, SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext); - return fmt::to_string(w); - } -}; - -/* - * Rotating file sink based on date. rotates at midnight - */ -template -class daily_file_sink SPDLOG_FINAL : public base_sink -{ -public: - // create daily file sink which rotates on given time - daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false) - : base_filename_(std::move(base_filename)) - , rotation_h_(rotation_hour) - , rotation_m_(rotation_minute) - , truncate_(truncate) - { - if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) - { - throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); - } - auto now = log_clock::now(); - file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(now)), truncate_); - rotation_tp_ = next_rotation_tp_(); - } - -protected: - void sink_it_(const details::log_msg &msg) override - { - - if (msg.time >= rotation_tp_) - { - file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(msg.time)), truncate_); - rotation_tp_ = next_rotation_tp_(); - } - fmt::memory_buffer formatted; - sink::formatter_->format(msg, formatted); - file_helper_.write(formatted); - } - - void flush_() override - { - file_helper_.flush(); - } - -private: - tm now_tm(log_clock::time_point tp) - { - time_t tnow = log_clock::to_time_t(tp); - return spdlog::details::os::localtime(tnow); - } - - log_clock::time_point next_rotation_tp_() - { - auto now = log_clock::now(); - tm date = now_tm(now); - date.tm_hour = rotation_h_; - date.tm_min = rotation_m_; - date.tm_sec = 0; - auto rotation_time = log_clock::from_time_t(std::mktime(&date)); - if (rotation_time > now) - { - return rotation_time; - } - return {rotation_time + std::chrono::hours(24)}; - } - - filename_t base_filename_; - int rotation_h_; - int rotation_m_; - log_clock::time_point rotation_tp_; - details::file_helper file_helper_; - bool truncate_; -}; - -using daily_file_sink_mt = daily_file_sink; -using daily_file_sink_st = daily_file_sink; - -} // namespace sinks - -// -// factory functions -// -template -inline std::shared_ptr daily_logger_mt( - const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false) -{ - return Factory::template create(logger_name, filename, hour, minute, truncate); -} - -template -inline std::shared_ptr daily_logger_st( - const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false) -{ - return Factory::template create(logger_name, filename, hour, minute, truncate); -} -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/dist_sink.h b/spdlog_lib/spdlog/sinks/dist_sink.h deleted file mode 100644 index 8d2f6f9..0000000 --- a/spdlog_lib/spdlog/sinks/dist_sink.h +++ /dev/null @@ -1,68 +0,0 @@ -// -// Copyright (c) 2015 David Schury, Gabi Melman -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "base_sink.h" -#include "spdlog/details/log_msg.h" -#include "spdlog/details/null_mutex.h" - -#include -#include -#include -#include - -// Distribution sink (mux). Stores a vector of sinks which get called when log -// is called - -namespace spdlog { -namespace sinks { - -template -class dist_sink : public base_sink -{ -public: - dist_sink() = default; - dist_sink(const dist_sink &) = delete; - dist_sink &operator=(const dist_sink &) = delete; - - void add_sink(std::shared_ptr sink) - { - std::lock_guard lock(base_sink::mutex_); - sinks_.push_back(sink); - } - - void remove_sink(std::shared_ptr sink) - { - std::lock_guard lock(base_sink::mutex_); - sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end()); - } - -protected: - void sink_it_(const details::log_msg &msg) override - { - - for (auto &sink : sinks_) - { - if (sink->should_log(msg.level)) - { - sink->log(msg); - } - } - } - - void flush_() override - { - for (auto &sink : sinks_) - sink->flush(); - } - std::vector> sinks_; -}; - -using dist_sink_mt = dist_sink; -using dist_sink_st = dist_sink; - -} // namespace sinks -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/msvc_sink.h b/spdlog_lib/spdlog/sinks/msvc_sink.h deleted file mode 100644 index a028496..0000000 --- a/spdlog_lib/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(_WIN32) - -#include "spdlog/details/null_mutex.h" -#include "spdlog/sinks/base_sink.h" - -#include - -#include -#include - -namespace spdlog { -namespace sinks { -/* - * MSVC sink (logging using OutputDebugStringA) - */ -template -class msvc_sink : public base_sink -{ -public: - explicit msvc_sink() {} - -protected: - void sink_it_(const details::log_msg &msg) override - { - - fmt::memory_buffer formatted; - sink::formatter_->format(msg, formatted); - OutputDebugStringA(fmt::to_string(formatted).c_str()); - } - - void flush_() override {} -}; - -using msvc_sink_mt = msvc_sink; -using msvc_sink_st = msvc_sink; - -using windebug_sink_mt = msvc_sink_mt; -using windebug_sink_st = msvc_sink_st; - -} // namespace sinks -} // namespace spdlog - -#endif diff --git a/spdlog_lib/spdlog/sinks/null_sink.h b/spdlog_lib/spdlog/sinks/null_sink.h deleted file mode 100644 index 73b8c2b..0000000 --- a/spdlog_lib/spdlog/sinks/null_sink.h +++ /dev/null @@ -1,28 +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 - -namespace spdlog { -namespace sinks { - -template -class null_sink : public base_sink -{ -protected: - void sink_it_(const details::log_msg &) override {} - void flush_() override {} -}; - -using null_sink_mt = null_sink; -using null_sink_st = null_sink; - -} // namespace sinks -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/ostream_sink.h b/spdlog_lib/spdlog/sinks/ostream_sink.h deleted file mode 100644 index 5f31993..0000000 --- a/spdlog_lib/spdlog/sinks/ostream_sink.h +++ /dev/null @@ -1,51 +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 -#include - -namespace spdlog { -namespace sinks { -template -class ostream_sink SPDLOG_FINAL : public base_sink -{ -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; - -protected: - void sink_it_(const details::log_msg &msg) override - { - fmt::memory_buffer formatted; - sink::formatter_->format(msg, formatted); - ostream_.write(formatted.data(), formatted.size()); - if (force_flush_) - ostream_.flush(); - } - - void flush_() override - { - ostream_.flush(); - } - - std::ostream &ostream_; - bool force_flush_; -}; - -using ostream_sink_mt = ostream_sink; -using ostream_sink_st = ostream_sink; - -} // namespace sinks -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/rotating_file_sink.h b/spdlog_lib/spdlog/sinks/rotating_file_sink.h deleted file mode 100644 index 7ed2385..0000000 --- a/spdlog_lib/spdlog/sinks/rotating_file_sink.h +++ /dev/null @@ -1,144 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -#include "spdlog/details/file_helper.h" -#include "spdlog/details/null_mutex.h" -#include "spdlog/fmt/fmt.h" -#include "spdlog/sinks/base_sink.h" -#include "spdlog/spdlog.h" - -#include -#include -#include -#include -#include -#include - -namespace spdlog { -namespace sinks { - -// -// Rotating file sink based on size -// -template -class rotating_file_sink SPDLOG_FINAL : public base_sink -{ -public: - rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files) - : base_filename_(std::move(base_filename)) - , max_size_(max_size) - , max_files_(max_files) - { - file_helper_.open(calc_filename(base_filename_, 0)); - current_size_ = file_helper_.size(); // expensive. called only once - } - - // calc filename according to index and file extension if exists. - // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". - static filename_t calc_filename(const filename_t &filename, std::size_t index) - { - typename std::conditional::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w; - if (index != 0u) - { - filename_t basename, ext; - std::tie(basename, ext) = details::file_helper::split_by_extenstion(filename); - fmt::format_to(w, SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext); - } - else - { - fmt::format_to(w, SPDLOG_FILENAME_T("{}"), filename); - } - return fmt::to_string(w); - } - -protected: - void sink_it_(const details::log_msg &msg) override - { - fmt::memory_buffer formatted; - sink::formatter_->format(msg, formatted); - current_size_ += formatted.size(); - if (current_size_ > max_size_) - { - rotate_(); - current_size_ = formatted.size(); - } - file_helper_.write(formatted); - } - - void flush_() override - { - file_helper_.flush(); - } - -private: - // Rotate files: - // log.txt -> log.1.txt - // log.1.txt -> log.2.txt - // log.2.txt -> log.3.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); - filename_t target = calc_filename(base_filename_, i); - - 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) != 0) - { - // if failed try again after small delay. - // this is a workaround to a windows issue, where very high rotation - // rates sometimes fail (because of antivirus?). - details::os::sleep_for_millis(20); - details::os::remove(target); - if (details::os::rename(src, target) != 0) - { - throw spdlog_ex( - "rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno); - } - } - } - file_helper_.reopen(true); - } - - filename_t base_filename_; - std::size_t max_size_; - std::size_t max_files_; - std::size_t current_size_; - details::file_helper file_helper_; -}; - -using rotating_file_sink_mt = rotating_file_sink; -using rotating_file_sink_st = rotating_file_sink; - -} // namespace sinks - -// -// factory functions -// - -template -inline std::shared_ptr rotating_logger_mt( - const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files) -{ - return Factory::template create(logger_name, filename, max_file_size, max_files); -} - -template -inline std::shared_ptr rotating_logger_st( - const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files) -{ - return Factory::template create(logger_name, filename, max_file_size, max_files); -} -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/sink.h b/spdlog_lib/spdlog/sinks/sink.h deleted file mode 100644 index 288d543..0000000 --- a/spdlog_lib/spdlog/sinks/sink.h +++ /dev/null @@ -1,57 +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 "spdlog/details/pattern_formatter.h" -#include "spdlog/formatter.h" - -namespace spdlog { -namespace sinks { -class sink -{ -public: - sink() - : level_(level::trace) - , formatter_(new pattern_formatter("%+")) - { - } - - sink(std::unique_ptr formatter) - : level_(level::trace) - , formatter_(std::move(formatter)){}; - - virtual ~sink() = default; - virtual void log(const details::log_msg &msg) = 0; - virtual void flush() = 0; - virtual void set_pattern(const std::string &pattern) = 0; - virtual void set_formatter(std::unique_ptr sink_formatter) = 0; - - bool should_log(level::level_enum msg_level) const - { - return msg_level >= level_.load(std::memory_order_relaxed); - } - - void set_level(level::level_enum log_level) - { - level_.store(log_level); - } - - level::level_enum level() const - { - return static_cast(level_.load(std::memory_order_relaxed)); - } - -protected: - // sink log level - default is all - level_t level_; - - // sink formatter - default is full format - std::unique_ptr formatter_; -}; - -} // namespace sinks -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/stdout_color_sinks.h b/spdlog_lib/spdlog/sinks/stdout_color_sinks.h deleted file mode 100644 index 761e32a..0000000 --- a/spdlog_lib/spdlog/sinks/stdout_color_sinks.h +++ /dev/null @@ -1,53 +0,0 @@ -// -// Copyright(c) 2018 spdlog -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "spdlog/spdlog.h" -#ifdef _WIN32 -#include "spdlog/sinks/wincolor_sink.h" -#else -#include "spdlog/sinks/ansicolor_sink.h" -#endif - -namespace spdlog { -namespace sinks { -#ifdef _WIN32 -using stdout_color_sink_mt = wincolor_stdout_sink_mt; -using stdout_color_sink_st = wincolor_stdout_sink_st; -using stderr_color_sink_mt = wincolor_stderr_sink_mt; -using stderr_color_sink_st = wincolor_stderr_sink_st; -#else -using stdout_color_sink_mt = ansicolor_stdout_sink_mt; -using stdout_color_sink_st = ansicolor_stdout_sink_st; -using stderr_color_sink_mt = ansicolor_stderr_sink_mt; -using stderr_color_sink_st = ansicolor_stderr_sink_st; -#endif -} // namespace sinks - -template -inline std::shared_ptr stdout_color_mt(const std::string &logger_name) -{ - return Factory::template create(logger_name); -} - -template -inline std::shared_ptr stdout_color_st(const std::string &logger_name) -{ - return Factory::template create(logger_name); -} - -template -inline std::shared_ptr stderr_color_mt(const std::string &logger_name) -{ - return Factory::template create(logger_name); -} - -template -inline std::shared_ptr stderr_color_st(const std::string &logger_name) -{ - return Factory::template create(logger_name); -} -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/stdout_sinks.h b/spdlog_lib/spdlog/sinks/stdout_sinks.h deleted file mode 100644 index 64c0ab7..0000000 --- a/spdlog_lib/spdlog/sinks/stdout_sinks.h +++ /dev/null @@ -1,100 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "spdlog/details/console_globals.h" -#include "spdlog/details/null_mutex.h" -#include "spdlog/spdlog.h" - -#include -#include -#include -#include - -namespace spdlog { - -namespace sinks { - -template -class stdout_sink : public sink -{ -public: - using mutex_t = typename ConsoleMutex::mutex_t; - stdout_sink() - : mutex_(ConsoleMutex::mutex()) - , file_(TargetStream::stream()) - { - } - ~stdout_sink() = default; - - stdout_sink(const stdout_sink &other) = delete; - stdout_sink &operator=(const stdout_sink &other) = delete; - - void log(const details::log_msg &msg) override - { - std::lock_guard lock(mutex_); - fmt::memory_buffer formatted; - formatter_->format(msg, formatted); - fwrite(formatted.data(), sizeof(char), formatted.size(), file_); - fflush(TargetStream::stream()); - } - - void flush() override - { - std::lock_guard lock(mutex_); - fflush(file_); - } - - void set_pattern(const std::string &pattern) override SPDLOG_FINAL - { - std::lock_guard lock(mutex_); - formatter_ = std::unique_ptr(new pattern_formatter(pattern)); - } - - void set_formatter(std::unique_ptr sink_formatter) override SPDLOG_FINAL - { - std::lock_guard lock(mutex_); - formatter_ = std::move(sink_formatter); - } - -private: - mutex_t &mutex_; - FILE *file_; -}; - -using stdout_sink_mt = stdout_sink; -using stdout_sink_st = stdout_sink; - -using stderr_sink_mt = stdout_sink; -using stderr_sink_st = stdout_sink; - -} // namespace sinks - -// factory methods -template -inline std::shared_ptr stdout_logger_mt(const std::string &logger_name) -{ - return Factory::template create(logger_name); -} - -template -inline std::shared_ptr stdout_logger_st(const std::string &logger_name) -{ - return Factory::template create(logger_name); -} - -template -inline std::shared_ptr stderr_logger_mt(const std::string &logger_name) -{ - return Factory::template create(logger_name); -} - -template -inline std::shared_ptr stderr_logger_st(const std::string &logger_name) -{ - return Factory::template create(logger_name); -} -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/syslog_sink.h b/spdlog_lib/spdlog/sinks/syslog_sink.h deleted file mode 100644 index e171bf9..0000000 --- a/spdlog_lib/spdlog/sinks/syslog_sink.h +++ /dev/null @@ -1,91 +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/spdlog.h" - -#include -#include -#include - -namespace spdlog { -namespace sinks { -/** - * Sink that write to syslog using the `syscall()` library call. - * - * Locking is not needed, as `syslog()` itself is thread-safe. - */ -template -class syslog_sink : public base_sink -{ -public: - // - syslog_sink(const std::string &ident = "", int syslog_option = 0, int syslog_facility = LOG_USER) - : ident_(ident) - { - priorities_[static_cast(level::trace)] = LOG_DEBUG; - priorities_[static_cast(level::debug)] = LOG_DEBUG; - priorities_[static_cast(level::info)] = LOG_INFO; - priorities_[static_cast(level::warn)] = LOG_WARNING; - priorities_[static_cast(level::err)] = LOG_ERR; - priorities_[static_cast(level::critical)] = LOG_CRIT; - priorities_[static_cast(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() override - { - ::closelog(); - } - - syslog_sink(const syslog_sink &) = delete; - syslog_sink &operator=(const syslog_sink &) = delete; - -protected: - void sink_it_(const details::log_msg &msg) override - { - ::syslog(syslog_prio_from_level(msg), "%s", fmt::to_string(msg.raw).c_str()); - } - - void flush_() override {} - -private: - std::array 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(msg.level)]; - } -}; - -using syslog_sink_mt = syslog_sink; -using syslog_sink_st = syslog_sink; -} // namespace sinks - -// Create and register a syslog logger -template -inline std::shared_ptr syslog_logger_mt( - const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = (1 << 3)) -{ - return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility); -} - -template -inline std::shared_ptr syslog_logger_st( - const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = (1 << 3)) -{ - return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility); -} -} // namespace spdlog diff --git a/spdlog_lib/spdlog/sinks/wincolor_sink.h b/spdlog_lib/spdlog/sinks/wincolor_sink.h deleted file mode 100644 index 8c63e7f..0000000 --- a/spdlog_lib/spdlog/sinks/wincolor_sink.h +++ /dev/null @@ -1,139 +0,0 @@ -// -// Copyright(c) 2016 spdlog -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "spdlog/common.h" -#include "spdlog/details/console_globals.h" -#include "spdlog/details/null_mutex.h" -#include "spdlog/sinks/sink.h" - -#include -#include -#include -#include -#include - -namespace spdlog { -namespace sinks { -/* - * Windows color console sink. Uses WriteConsoleA to write to the console with - * colors - */ -template -class wincolor_sink : public sink -{ -public: - const WORD BOLD = FOREGROUND_INTENSITY; - const WORD RED = FOREGROUND_RED; - const WORD GREEN = FOREGROUND_GREEN; - 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() - : out_handle_(OutHandle::handle()) - , mutex_(ConsoleMutex::mutex()) - { - colors_[level::trace] = WHITE; - colors_[level::debug] = CYAN; - colors_[level::info] = GREEN; - 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; - } - - ~wincolor_sink() override - { - this->flush(); - } - - wincolor_sink(const wincolor_sink &other) = delete; - wincolor_sink &operator=(const wincolor_sink &other) = delete; - - // change the color for the given level - void set_color(level::level_enum level, WORD color) - { - std::lock_guard lock(mutex_); - colors_[level] = color; - } - - void log(const details::log_msg &msg) SPDLOG_FINAL override - { - std::lock_guard lock(mutex_); - fmt::memory_buffer formatted; - formatter_->format(msg, formatted); - if (msg.color_range_end > msg.color_range_start) - { - // before color range - print_range_(formatted, 0, msg.color_range_start); - - // in color range - auto orig_attribs = set_console_attribs(colors_[msg.level]); - print_range_(formatted, msg.color_range_start, msg.color_range_end); - ::SetConsoleTextAttribute(out_handle_, - orig_attribs); // reset to orig colors - // after color range - print_range_(formatted, msg.color_range_end, formatted.size()); - } - else // print without colors if color range is invalid - { - print_range_(formatted, 0, formatted.size()); - } - } - - void flush() SPDLOG_FINAL override - { - // windows console always flushed? - } - - void set_pattern(const std::string &pattern) override SPDLOG_FINAL - { - std::lock_guard lock(mutex_); - formatter_ = std::unique_ptr(new pattern_formatter(pattern)); - } - - void set_formatter(std::unique_ptr sink_formatter) override SPDLOG_FINAL - { - std::lock_guard lock(mutex_); - formatter_ = std::move(sink_formatter); - } - -private: - using mutex_t = typename ConsoleMutex::mutex_t; - // 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); - WORD back_color = orig_buffer_info.wAttributes; - // retrieve the current background color - back_color &= static_cast(~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY)); - // keep the background color unchanged - ::SetConsoleTextAttribute(out_handle_, attribs | back_color); - return orig_buffer_info.wAttributes; // return orig attribs - } - - // print a range of formatted message to console - void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end) - { - auto size = static_cast(end - start); - ::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr, nullptr); - } - - HANDLE out_handle_; - mutex_t &mutex_; - std::unordered_map colors_; -}; - -using wincolor_stdout_sink_mt = wincolor_sink; -using wincolor_stdout_sink_st = wincolor_sink; - -using wincolor_stderr_sink_mt = wincolor_sink; -using wincolor_stderr_sink_st = wincolor_sink; - -} // namespace sinks -} // namespace spdlog diff --git a/spdlog_lib/spdlog/spdlog.h b/spdlog_lib/spdlog/spdlog.h deleted file mode 100644 index 2963a2a..0000000 --- a/spdlog_lib/spdlog/spdlog.h +++ /dev/null @@ -1,161 +0,0 @@ -// -// Copyright(c) 2015-2018 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/common.h" -#include "spdlog/details/registry.h" -#include "spdlog/logger.h" -#include "spdlog/version.h" - -#include -#include -#include -#include - -namespace spdlog { - -// Default logger factory- creates synchronous loggers -struct synchronous_factory -{ - template - - static std::shared_ptr create(std::string logger_name, SinkArgs &&... args) - { - auto sink = std::make_shared(std::forward(args)...); - auto new_logger = std::make_shared(std::move(logger_name), std::move(sink)); - details::registry::instance().register_and_init(new_logger); - return new_logger; - } -}; - -using default_factory = synchronous_factory; - -// Create and register a logger with a templated sink type -// The logger's level, formatter and flush level will be set according the -// global settings. -// Example: -// spdlog::create("logger_name", "dailylog_filename", 11, 59); -template -inline std::shared_ptr create(std::string logger_name, SinkArgs &&... sink_args) -{ - return default_factory::create(std::move(logger_name), std::forward(sink_args)...); -} - -// Return an existing logger or nullptr if a logger with such name doesn't -// exist. -// example: spdlog::get("my_logger")->info("hello {}", "world"); -inline std::shared_ptr get(const std::string &name) -{ - return details::registry::instance().get(name); -} - -// Set global formatter. Each sink in each logger will get a clone of this object -inline void set_formatter(std::unique_ptr formatter) -{ - details::registry::instance().set_formatter(std::move(formatter)); -} - -// Set global format string. -// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); -inline void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local) -{ - set_formatter(std::unique_ptr(new pattern_formatter(pattern, time_type))); -} - -// Set global logging level -inline void set_level(level::level_enum log_level) -{ - details::registry::instance().set_level(log_level); -} - -// Set global flush level -inline void flush_on(level::level_enum log_level) -{ - details::registry::instance().flush_on(log_level); -} - -// Start/Restart a periodic flusher thread -// Warning: Use only if all your loggers are thread safe! -inline void flush_every(std::chrono::seconds interval) -{ - details::registry::instance().flush_every(interval); -} - -// Set global error handler -inline void set_error_handler(log_err_handler handler) -{ - details::registry::instance().set_error_handler(std::move(handler)); -} - -// Register the given logger with the given name -inline void register_logger(std::shared_ptr logger) -{ - details::registry::instance().register_logger(std::move(logger)); -} - -// Apply a user defined function on all registered loggers -// Example: -// spdlog::apply_all([&](std::shared_ptr l) {l->flush();}); -inline void apply_all(std::function)> fun) -{ - details::registry::instance().apply_all(std::move(fun)); -} - -// Drop the reference to the given logger -inline void drop(const std::string &name) -{ - details::registry::instance().drop(name); -} - -// Drop all references from the registry -inline void drop_all() -{ - details::registry::instance().drop_all(); -} - -// stop any running threads started by spdlog and clean registry loggers -inline void shutdown() -{ - details::registry::instance().shutdown(); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Trace & Debug can be switched on/off at compile time for zero cost debug -// statements. -// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in tweakme.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) -#ifdef _MSC_VER -#define SPDLOG_TRACE(logger, ...) logger->trace("[ " __FILE__ "(" SPDLOG_STR_HELPER(__LINE__) ") ] " __VA_ARGS__) -#else -#define SPDLOG_TRACE(logger, ...) \ - logger->trace("[ " __FILE__ ":" SPDLOG_STR_HELPER(__LINE__) " ]" \ - " " __VA_ARGS__) -#endif -#else -#define SPDLOG_TRACE(logger, ...) (void)0 -#endif - -#ifdef SPDLOG_DEBUG_ON -#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__) -#else -#define SPDLOG_DEBUG(logger, ...) (void)0 -#endif - -} // namespace spdlog diff --git a/spdlog_lib/spdlog/tweakme.h b/spdlog_lib/spdlog/tweakme.h deleted file mode 100644 index 5325645..0000000 --- a/spdlog_lib/spdlog/tweakme.h +++ /dev/null @@ -1,132 +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 querying 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 querying 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 to prevent spdlog from caching thread ids in thread local storage. -// By default spdlog saves thread ids in tls to gain a few micros for each call. -// -// WARNING: if your program forks, UNCOMMENT this flag to prevent undefined -// thread ids in the children logs. -// -// #define SPDLOG_DISABLE_TID_CACHING -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// 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 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 so set your -I flag -// accordingly. -// -// #define SPDLOG_FMT_EXTERNAL -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to enable wchar_t support (convert to utf8) -// -// #define SPDLOG_WCHAR_TO_UTF8_SUPPORT -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to prevent child processes from inheriting log file descriptors -// -// #define SPDLOG_PREVENT_CHILD_FD -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment if your compiler doesn't support the "final" keyword. -// The final keyword allows more optimizations in release -// mode with recent compilers. See GCC's documentation for -Wsuggest-final-types -// for instance. -// -// #define SPDLOG_NO_FINAL -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to enable message counting feature. -// Use the %i in the logger pattern to display log message sequence id. -// -// #define SPDLOG_ENABLE_MESSAGE_COUNTER -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to customize level names (e.g. "MT TRACE") -// -// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", -// "MY ERROR", "MY CRITICAL", "OFF" } -/////////////////////////////////////////////////////////////////////////////// diff --git a/spdlog_lib/spdlog/version.h b/spdlog_lib/spdlog/version.h deleted file mode 100644 index 729fcba..0000000 --- a/spdlog_lib/spdlog/version.h +++ /dev/null @@ -1,12 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#define SPDLOG_VER_MAJOR 1 -#define SPDLOG_VER_MINOR 0 -#define SPDLOG_VER_PATCH 0 - -#define SPDLOG_VERSION (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH) From ec1f1349bdc33f524927a63166be005cca553949 Mon Sep 17 00:00:00 2001 From: cks Date: Thu, 9 Aug 2018 15:26:23 +0700 Subject: [PATCH 05/11] Changing the use of set_pattern --- example.cpp | 12 ++----- logfmt.cpp | 102 +++++++++++++++++++++------------------------------- logfmt.h | 6 ++-- 3 files changed, 46 insertions(+), 74 deletions(-) diff --git a/example.cpp b/example.cpp index d34f0fe..903dc34 100644 --- a/example.cpp +++ b/example.cpp @@ -14,23 +14,17 @@ int main() spdlog::set_level(spdlog::level::trace); log.WithField(log.custom_field={{"animal", "walrus"}, {"total", 100}}).info("INFO of WALRUS and its total"); - log.info("No Walrus "); - log.WithField(log.custom_field={{"animal", "horse"}, {"total", 90}}).debug("DEBUG of HORSE and its total"); - log.debug("No Horse"); - - log.OutputJSON(); //output in JSON format - log.WithField(log.custom_field={{"animal", "bird"}, {"total", 40.5}}).trace("TRACE of BIRD and its total"); - log.trace("No Bird"); + log.info("No Walrus"); log.WithField(log.custom_field={{"animal", "dog"}, {"total", float_test}}).warn("WARN of DOG and its total"); log.warn("No Dog"); - log.OutputDefault(); //output in default format + + log.OutputJSON(); //output in JSON format log.WithField(log.custom_field={{"animal", "cat"}, {"total", long_test}}).critical("CRITICAL of CAT and its total"); log.critical("No Cat"); log.WithField(log.custom_field={{"animal", "falcon"}, {"total", 10}}).error("ERROR of FALCON and its total"); log.error("No Falcon"); - log.OutputJSON(); auto staticformat = log.WithField(log.custom_field={{"float",float_test}, {"long", long_test}, {"string", a}}); staticformat.info("This is INFO with custom key"); staticformat.debug("This is DEBUG with custom key"); diff --git a/logfmt.cpp b/logfmt.cpp index 25161ce..72682ba 100644 --- a/logfmt.cpp +++ b/logfmt.cpp @@ -10,32 +10,21 @@ std::string logfmt::Entry::AddQuotation(std::string msg) //return quotation in m return "\"" + msg + "\""; } -std::string logfmt::Entry::JSONformatter() //return json formatter +void logfmt::Entry::processKey(std::string& msg) { - return "\"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : \"%v\" "; -} + std::string pattern =" "; -std::string logfmt::Entry::processPattern(std::string pattern) -{ - if(JSON) //jsonform is true - { - return "{ " + JSONformatter() + pattern + "}"; - } - else //jsonform is false + for (auto& [key,val] : entry_field) { - return "%+ " + pattern; + pattern = pattern + casting(key, val); } -} -std::string logfmt::Entry::processKey() -{ - std::string pattern =""; - - for (auto& [key,val] : entry_field) + if(JSON) { - pattern = pattern + casting(key, val); + msg = AddQuotation(msg); } - return processPattern(pattern); + + msg = msg + pattern; } std::string logfmt::Entry::casting(std::string key, std::any val) //casting the value in map into string @@ -157,37 +146,37 @@ logfmt::Entry& logfmt::Entry::WithField(std::map& keyMap) } void logfmt::Entry::info(std::string msg) { - entry_log -> set_pattern(processKey()); + processKey(msg); entry_log -> info(msg); } void logfmt::Entry::trace(std::string msg) { - entry_log -> set_pattern(processKey()); + processKey(msg); entry_log -> trace(msg); } void logfmt::Entry::debug(std::string msg) { - entry_log -> set_pattern(processKey()); + processKey(msg); entry_log -> debug(msg); } void logfmt::Entry::warn(std::string msg) { - entry_log -> set_pattern(processKey()); + processKey(msg); entry_log -> warn(msg); } void logfmt::Entry::error(std::string msg) { - entry_log -> set_pattern(processKey()); + processKey(msg); entry_log -> error(msg); } void logfmt::Entry::critical(std::string msg) { - entry_log -> set_pattern(processKey()); + processKey(msg); entry_log -> critical(msg); } //////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -213,11 +202,13 @@ logfmt::logfmt(std::string name, bool to_file) //constructor void logfmt::OutputJSON() { JSONstatus = true; + logger -> set_pattern(JSONformatter()); } void logfmt::OutputDefault() { JSONstatus = false; + logger -> set_pattern("%+"); } logfmt::Entry& logfmt::WithField(std::map& keyMap) @@ -226,82 +217,69 @@ logfmt::Entry& logfmt::WithField(std::map& keyMap) return loggerEntry.WithField(keyMap); } +std::string logfmt::AddQuotation(std::string msg) //return quotation in message input +{ + return "\"" + msg + "\" "; +} + std::string logfmt::JSONformatter() { - return "\"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : \"%v\" "; + return "{ \"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : %v}"; } //basic logging void logfmt::info(std::string msg) { - if(JSONstatus) + if (JSONstatus) { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); + msg = AddQuotation(msg); } + logger -> info(msg); } void logfmt::trace(std::string msg) { - if(JSONstatus) + if (JSONstatus) { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); + msg = AddQuotation(msg); } + logger -> trace(msg); } void logfmt::debug(std::string msg) { - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else + if (JSONstatus) { - logger -> set_pattern("%+"); + msg = AddQuotation(msg); } + logger -> debug(msg); } void logfmt::warn(std::string msg) { - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else + if (JSONstatus) { - logger -> set_pattern("%+"); + msg = AddQuotation(msg); } + logger -> warn(msg); } void logfmt::error(std::string msg) { - if(JSONstatus) - { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else + if (JSONstatus) { - logger -> set_pattern("%+"); + msg = AddQuotation(msg); } + logger -> error(msg); } void logfmt::critical(std::string msg) { - if(JSONstatus) + if (JSONstatus) { - logger -> set_pattern("{ " + JSONformatter() + "}"); - } - else - { - logger -> set_pattern("%+"); + msg = AddQuotation(msg); } + logger -> critical(msg); } diff --git a/logfmt.h b/logfmt.h index bb41613..70e99a8 100644 --- a/logfmt.h +++ b/logfmt.h @@ -21,9 +21,7 @@ class logfmt bool JSON; //function std::string AddQuotation(std::string msg); - std::string JSONformatter(); - std::string processPattern(std::string pattern); - std::string processKey(); + void processKey(std::string& msg); std::string casting(std::string key, std::any val); public: Entry(); //default ctor @@ -50,6 +48,8 @@ class logfmt void OutputDefault(); logfmt::Entry& WithField(std::map& keyMap); std::string JSONformatter(); + std::string AddQuotation(std::string msg); + //basic logging void info(std::string msg); void trace(std::string msg); From 15eed380ba89ef44fc955cb2bd6c5fdc226b69de Mon Sep 17 00:00:00 2001 From: cks Date: Thu, 9 Aug 2018 17:46:25 +0700 Subject: [PATCH 06/11] change function format --- example.cpp | 16 ++-- logfmt.cpp | 243 +++++++++++++++++++++++++++------------------------- logfmt.h | 28 +++--- 3 files changed, 149 insertions(+), 138 deletions(-) diff --git a/example.cpp b/example.cpp index 903dc34..364ad76 100644 --- a/example.cpp +++ b/example.cpp @@ -13,19 +13,19 @@ int main() logfmt log("test", toFile); spdlog::set_level(spdlog::level::trace); - log.WithField(log.custom_field={{"animal", "walrus"}, {"total", 100}}).info("INFO of WALRUS and its total"); + log.with_field(log.custom_field={{"animal", "walrus"}, {"total", 100}}).info("INFO of WALRUS and its total"); log.info("No Walrus"); - log.WithField(log.custom_field={{"animal", "dog"}, {"total", float_test}}).warn("WARN of DOG and its total"); + log.with_field(log.custom_field={{"animal", "dog"}, {"total", float_test}}).warn("WARN of DOG and its total"); log.warn("No Dog"); - log.OutputJSON(); //output in JSON format - log.WithField(log.custom_field={{"animal", "cat"}, {"total", long_test}}).critical("CRITICAL of CAT and its total"); + log.JSON_output(); //output in JSON format + log.with_field(log.custom_field={{"animal", "cat"}, {"total", long_test}}).critical("CRITICAL of CAT and its total"); log.critical("No Cat"); - log.WithField(log.custom_field={{"animal", "falcon"}, {"total", 10}}).error("ERROR of FALCON and its total"); + log.with_field(log.custom_field={{"animal", "falcon"}, {"total", 10}}).error("ERROR of FALCON and its total"); log.error("No Falcon"); - auto staticformat = log.WithField(log.custom_field={{"float",float_test}, {"long", long_test}, {"string", a}}); + auto staticformat = log.with_field(log.custom_field={{"float",float_test}, {"long", long_test}, {"string", a}}); staticformat.info("This is INFO with custom key"); staticformat.debug("This is DEBUG with custom key"); staticformat.trace("This is TRACE with custom key"); @@ -33,8 +33,8 @@ int main() staticformat.critical("This is CRITICAL with custom key"); staticformat.error("This is ERROR with custom key"); - log.OutputDefault(); - auto staticformat2 = log.WithField(log.custom_field={{"animal","griffin"}, {"rider", "azure"}, {"weapon", "spear"}}); + log.default_output(); + auto staticformat2 = log.with_field(log.custom_field={{"animal","griffin"}, {"rider", "azure"}, {"weapon", "spear"}}); staticformat2.info("This is INFO with custom key"); staticformat2.debug("This is DEBUG with custom key"); staticformat2.trace("This is TRACE with custom key"); diff --git a/logfmt.cpp b/logfmt.cpp index 72682ba..6754f0e 100644 --- a/logfmt.cpp +++ b/logfmt.cpp @@ -5,128 +5,137 @@ //class Entry //private -std::string logfmt::Entry::AddQuotation(std::string msg) //return quotation in message input +std::string logfmt::Entry::add_quotation(std::string msg) //return quotation in message input { return "\"" + msg + "\""; } -void logfmt::Entry::processKey(std::string& msg) +void logfmt::Entry::process_key(std::string& msg) { std::string pattern =" "; for (auto& [key,val] : entry_field) { - pattern = pattern + casting(key, val); + if (JSON) + { + pattern = pattern + cast_JSON(key, val); + } + else + { + pattern = pattern + cast_default(key, val); + } } if(JSON) { - msg = AddQuotation(msg); + msg = add_quotation(msg); } msg = msg + pattern; } -std::string logfmt::Entry::casting(std::string key, std::any val) //casting the value in map into string +std::string logfmt::Entry::cast_default(std::string key, std::any val) //casting the value in map into default format { std::string custom_string; - if(JSON) + + custom_string = custom_string + key + " = " ; + if (val.type() == typeid(char)) { - custom_string = custom_string + ", " + AddQuotation(key) + " : " ; - //check type for any_cast - if (val.type() == typeid(char)) //char - { - custom_string = custom_string + "\""; - custom_string += (std::any_cast(val)); - custom_string = custom_string + "\" "; - } - else if (val.type() == typeid(const char *)) //array of char - { - std::string temp(std::any_cast(val)); - custom_string = custom_string + AddQuotation(temp) + " "; - } - else if (val.type() == typeid(int)) //integer - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(float)) //float - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(double)) //double - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(bool)) //boolean - { - if (std::any_cast(val) == 1) - { - custom_string = custom_string + "true "; - } - else if (std::any_cast(val) == 0) - { - custom_string = custom_string + "false "; - } - } - else if (val.type() == typeid(std::string)) //string - { - custom_string = custom_string + AddQuotation(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(long)) //long - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } + custom_string = custom_string + "\""; + custom_string += (std::any_cast(val)); + custom_string = custom_string + "\" "; } - else + else if (val.type() == typeid(const char *)) { - custom_string = custom_string + key + " = " ; - if (val.type() == typeid(char)) - { - custom_string = custom_string + "\""; - custom_string += (std::any_cast(val)); - custom_string = custom_string + "\" "; - } - else if (val.type() == typeid(const char *)) - { - std::string temp(std::any_cast(val)); - custom_string = custom_string + AddQuotation(temp) + " "; - } - else if (val.type() == typeid(int)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(float)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(double)) + std::string temp(std::any_cast(val)); + custom_string = custom_string + add_quotation(temp) + " "; + } + else if (val.type() == typeid(int)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(float)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(double)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(bool)) + { + if (std::any_cast(val) == 1) { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + custom_string = custom_string + "true "; } - else if (val.type() == typeid(bool)) + else if (std::any_cast(val) == 0) { - if (std::any_cast(val) == 1) - { - custom_string = custom_string + "true "; - } - else if (std::any_cast(val) == 0) - { - custom_string = custom_string + "false "; - } + custom_string = custom_string + "false "; } - else if (val.type() == typeid(std::string)) + } + else if (val.type() == typeid(std::string)) + { + custom_string = custom_string + add_quotation(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(long)) + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + + return custom_string; +} + +std::string logfmt::Entry::cast_JSON(std::string key, std::any val) //casting the value in map into json format +{ + std::string custom_string = ", " + add_quotation(key) + " : " ; + //check type for any_cast + if (val.type() == typeid(char)) //char + { + custom_string = custom_string + "\""; + custom_string += (std::any_cast(val)); + custom_string = custom_string + "\" "; + } + else if (val.type() == typeid(const char *)) //array of char + { + std::string temp(std::any_cast(val)); + custom_string = custom_string + add_quotation(temp) + " "; + } + else if (val.type() == typeid(int)) //integer + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(float)) //float + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(double)) //double + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(bool)) //boolean + { + if (std::any_cast(val) == 1) { - custom_string = custom_string + AddQuotation(std::any_cast(val)) + " "; + custom_string = custom_string + "true "; } - else if (val.type() == typeid(long)) + else if (std::any_cast(val) == 0) { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + custom_string = custom_string + "false "; } } + else if (val.type() == typeid(std::string)) //string + { + custom_string = custom_string + add_quotation(std::any_cast(val)) + " "; + } + else if (val.type() == typeid(long)) //long + { + custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + } return custom_string; } + //public logfmt::Entry::Entry() { @@ -139,44 +148,44 @@ logfmt::Entry::Entry(std::shared_ptr& log, bool JSON ) //ctor this -> JSON = JSON; } -logfmt::Entry& logfmt::Entry::WithField(std::map& keyMap) +logfmt::Entry& logfmt::Entry::with_field(std::map& keyMap) { entry_field = keyMap; return *this; } void logfmt::Entry::info(std::string msg) { - processKey(msg); + process_key(msg); entry_log -> info(msg); } void logfmt::Entry::trace(std::string msg) { - processKey(msg); + process_key(msg); entry_log -> trace(msg); } void logfmt::Entry::debug(std::string msg) { - processKey(msg); + process_key(msg); entry_log -> debug(msg); } void logfmt::Entry::warn(std::string msg) { - processKey(msg); + process_key(msg); entry_log -> warn(msg); } void logfmt::Entry::error(std::string msg) { - processKey(msg); + process_key(msg); entry_log -> error(msg); } void logfmt::Entry::critical(std::string msg) { - processKey(msg); + process_key(msg); entry_log -> critical(msg); } //////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -194,35 +203,35 @@ logfmt::logfmt(std::string name, bool to_file) //constructor { logger = spdlog::stdout_color_mt(name); } - WriteFile = to_file; - JSONstatus = false; + write_file = to_file; + JSON_status = false; } // function -void logfmt::OutputJSON() +void logfmt::JSON_output() { - JSONstatus = true; - logger -> set_pattern(JSONformatter()); + JSON_status = true; + logger -> set_pattern(JSON_formatter()); } -void logfmt::OutputDefault() +void logfmt::default_output() { - JSONstatus = false; + JSON_status = false; logger -> set_pattern("%+"); } -logfmt::Entry& logfmt::WithField(std::map& keyMap) +logfmt::Entry& logfmt::with_field(std::map& keyMap) { - loggerEntry = Entry(logger, JSONstatus); - return loggerEntry.WithField(keyMap); + logger_entry = Entry(logger, JSON_status); + return logger_entry.with_field(keyMap); } -std::string logfmt::AddQuotation(std::string msg) //return quotation in message input +std::string logfmt::add_quotation(std::string msg) //return quotation in message input { return "\"" + msg + "\" "; } -std::string logfmt::JSONformatter() +std::string logfmt::JSON_formatter() { return "{ \"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : %v}"; } @@ -230,9 +239,9 @@ std::string logfmt::JSONformatter() //basic logging void logfmt::info(std::string msg) { - if (JSONstatus) + if (JSON_status) { - msg = AddQuotation(msg); + msg = add_quotation(msg); } logger -> info(msg); @@ -240,45 +249,45 @@ void logfmt::info(std::string msg) void logfmt::trace(std::string msg) { - if (JSONstatus) + if (JSON_status) { - msg = AddQuotation(msg); + msg = add_quotation(msg); } logger -> trace(msg); } void logfmt::debug(std::string msg) { - if (JSONstatus) + if (JSON_status) { - msg = AddQuotation(msg); + msg = add_quotation(msg); } logger -> debug(msg); } void logfmt::warn(std::string msg) { - if (JSONstatus) + if (JSON_status) { - msg = AddQuotation(msg); + msg = add_quotation(msg); } logger -> warn(msg); } void logfmt::error(std::string msg) { - if (JSONstatus) + if (JSON_status) { - msg = AddQuotation(msg); + msg = add_quotation(msg); } logger -> error(msg); } void logfmt::critical(std::string msg) { - if (JSONstatus) + if (JSON_status) { - msg = AddQuotation(msg); + msg = add_quotation(msg); } logger -> critical(msg); diff --git a/logfmt.h b/logfmt.h index 70e99a8..32742d8 100644 --- a/logfmt.h +++ b/logfmt.h @@ -20,13 +20,14 @@ class logfmt std::shared_ptr entry_log; bool JSON; //function - std::string AddQuotation(std::string msg); - void processKey(std::string& msg); - std::string casting(std::string key, std::any val); + std::string add_quotation(std::string msg); + void process_key(std::string& msg); + std::string cast_default(std::string key, std::any val); + std::string cast_JSON(std::string key, std::any val); public: Entry(); //default ctor Entry(std::shared_ptr& log, bool JSON ); //ctor with parameter - Entry& WithField(std::map& keyMap); + Entry& with_field(std::map& keyMap); void info(std::string msg); void trace(std::string msg); void debug(std::string msg); @@ -34,22 +35,23 @@ class logfmt void error(std::string msg); void critical(std::string msg); }; - Entry loggerEntry; + Entry logger_entry; std::shared_ptr logger; - bool JSONstatus; // make this true to make log in JSON form / false in normal form - bool WriteFile; // make this true to write log into file + bool JSON_status; // make this true to make log in JSON form / false in normal form + bool write_file; // make this true to write log into file + //private function + std::string JSON_formatter(); // make the log in JSON format + std::string add_quotation(std::string msg); public: //member std::map custom_field; //ctor logfmt(std::string name, bool to_file); //function - void OutputJSON(); - void OutputDefault(); - logfmt::Entry& WithField(std::map& keyMap); - std::string JSONformatter(); - std::string AddQuotation(std::string msg); - + void JSON_output(); + void default_output(); + logfmt::Entry& with_field(std::map& keyMap); + //basic logging void info(std::string msg); void trace(std::string msg); From 02eb8faae566ac1e727530def4a1e20fe442ffdb Mon Sep 17 00:00:00 2001 From: cks Date: Thu, 9 Aug 2018 17:47:48 +0700 Subject: [PATCH 07/11] Add logs/ into .gitignore --- .gitignore | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index d99efa9..f762ec5 100644 --- a/.gitignore +++ b/.gitignore @@ -29,4 +29,7 @@ # Executables *.exe *.out -*.app \ No newline at end of file +*.app + +# Logs +logs/ \ No newline at end of file From bbbd67143a5e93f131e916ad5264ebec8d8e1f79 Mon Sep 17 00:00:00 2001 From: cks Date: Thu, 9 Aug 2018 17:48:15 +0700 Subject: [PATCH 08/11] delete basic-log.txt --- logs/basic-log.txt | 48 ---------------------------------------------- 1 file changed, 48 deletions(-) delete mode 100644 logs/basic-log.txt diff --git a/logs/basic-log.txt b/logs/basic-log.txt deleted file mode 100644 index db8e863..0000000 --- a/logs/basic-log.txt +++ /dev/null @@ -1,48 +0,0 @@ -[2018-08-07 17:18:01.153] [test] [info] INFO of WALRUS and its total animal = "walrus" total = 100 -[2018-08-07 17:18:01.155] [test] [info] No Walrus -[2018-08-07 17:18:01.155] [test] [debug] DEBUG of HORSE and its total animal = "horse" total = 90 -[2018-08-07 17:18:01.155] [test] [debug] No Horse -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "trace" , "message" : "TRACE of BIRD and its total" , "animal" : "bird" , "total" : 40.500000 } -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "trace" , "message" : "No Bird" } -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "warning" , "message" : "WARN of DOG and its total" , "animal" : "dog" , "total" : 2.800000 } -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "warning" , "message" : "No Dog" } -[2018-08-07 17:18:01.156] [test] [critical] CRITICAL of CAT and its total animal = "cat" total = 100 -[2018-08-07 17:18:01.156] [test] [critical] No Cat -[2018-08-07 17:18:01.156] [test] [error] ERROR of FALCON and its total animal = "falcon" total = 10 -[2018-08-07 17:18:01.156] [test] [error] No Falcon -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "info" , "message" : "This is INFO with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "debug" , "message" : "This is DEBUG with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "trace" , "message" : "This is TRACE with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "warning" , "message" : "This is WARN with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "critical" , "message" : "This is CRITICAL with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:18:01" , "name" : "test" , "level" : "error" , "message" : "This is ERROR with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -[2018-08-07 17:18:01.156] [test] [info] This is INFO with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:18:01.156] [test] [debug] This is DEBUG with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:18:01.156] [test] [trace] This is TRACE with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:18:01.156] [test] [warning] This is WARN with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:18:01.156] [test] [critical] This is CRITICAL with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:18:01.156] [test] [error] This is ERROR with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:20:39.675] [test] [info] INFO of WALRUS and its total animal = "walrus" total = 100 -[2018-08-07 17:20:39.677] [test] [info] No Walrus -[2018-08-07 17:20:39.677] [test] [debug] DEBUG of HORSE and its total animal = "horse" total = 90 -[2018-08-07 17:20:39.677] [test] [debug] No Horse -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "trace" , "message" : "TRACE of BIRD and its total" , "animal" : "bird" , "total" : 40.500000 } -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "trace" , "message" : "No Bird" } -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "warning" , "message" : "WARN of DOG and its total" , "animal" : "dog" , "total" : 2.800000 } -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "warning" , "message" : "No Dog" } -[2018-08-07 17:20:39.677] [test] [critical] CRITICAL of CAT and its total animal = "cat" total = 100 -[2018-08-07 17:20:39.677] [test] [critical] No Cat -[2018-08-07 17:20:39.677] [test] [error] ERROR of FALCON and its total animal = "falcon" total = 10 -[2018-08-07 17:20:39.677] [test] [error] No Falcon -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "info" , "message" : "This is INFO with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "debug" , "message" : "This is DEBUG with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "trace" , "message" : "This is TRACE with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "warning" , "message" : "This is WARN with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "critical" , "message" : "This is CRITICAL with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -{ "date" : "07-08-2018" , "time" : "17:20:39" , "name" : "test" , "level" : "error" , "message" : "This is ERROR with custom key" , "float" : 2.800000 , "long" : 100 , "string" : "testing" } -[2018-08-07 17:20:39.677] [test] [info] This is INFO with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:20:39.677] [test] [debug] This is DEBUG with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:20:39.677] [test] [trace] This is TRACE with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:20:39.677] [test] [warning] This is WARN with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:20:39.677] [test] [critical] This is CRITICAL with custom key animal = "griffin" rider = "azure" weapon = "spear" -[2018-08-07 17:20:39.677] [test] [error] This is ERROR with custom key animal = "griffin" rider = "azure" weapon = "spear" From 0ff8a7036283d7b7ee1c040268fa14ac58928881 Mon Sep 17 00:00:00 2001 From: cks Date: Fri, 10 Aug 2018 11:43:05 +0700 Subject: [PATCH 09/11] add .clang-format --- .clang-format | 95 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 .clang-format diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..6010e81 --- /dev/null +++ b/.clang-format @@ -0,0 +1,95 @@ +--- +Language: Cpp +BasedOnStyle: Google +AccessModifierOffset: -1 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlinesLeft: true +AlignOperands: true +AlignTrailingComments: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: true +AllowShortLoopsOnASingleLine: true +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: true +AlwaysBreakTemplateDeclarations: true +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Attach +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: true +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ] +IncludeCategories: + - Regex: '^<.*\.h>' + Priority: 1 + - Regex: '^<.*' + Priority: 2 + - Regex: '.*' + Priority: 3 +IncludeIsMainRegex: '([-_](test|unittest))?$' +IndentCaseLabels: true +IndentWidth: 2 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: false +PenaltyBreakBeforeFirstCallParameter: 1 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 200 +PointerAlignment: Left +ReflowComments: true +SortIncludes: true +SpaceAfterCStyleCast: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 2 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Auto +TabWidth: 8 +UseTab: Never +... From d7f8ac7cdd964ea6f0c53163560dcc87a760ba96 Mon Sep 17 00:00:00 2001 From: cks Date: Fri, 10 Aug 2018 11:45:40 +0700 Subject: [PATCH 10/11] Change style with clang-format --- example.cpp | 33 ++++--- logfmt.cpp | 273 ++++++++++++++++++++++------------------------------ logfmt.h | 79 +++++++-------- 3 files changed, 174 insertions(+), 211 deletions(-) diff --git a/example.cpp b/example.cpp index 364ad76..fa7bf72 100644 --- a/example.cpp +++ b/example.cpp @@ -2,30 +2,35 @@ #define toFile false -// Compile with "g++ example.cpp logfmt.cpp -o example -Wall -Wextra -pedantic -std=c++17 -pthread -Iexternal/spdlog/include -fmax-errors=1 -O3 -march=native" -// dont forget to create logs folder if logging to file +// Compile with "g++ example.cpp logfmt.cpp -o example -Wall -Wextra -pedantic +// -std=c++17 -pthread -Iexternal/spdlog/include -fmax-errors=1 -O3 +// -march=native" dont forget to create logs folder if logging to file -int main() -{ - std::string a ="testing"; +int main() { + std::string a = "testing"; float float_test = 2.8; long long_test = 100; logfmt log("test", toFile); spdlog::set_level(spdlog::level::trace); - log.with_field(log.custom_field={{"animal", "walrus"}, {"total", 100}}).info("INFO of WALRUS and its total"); + log.with_field(log.custom_field = {{"animal", "walrus"}, {"total", 100}}) + .info("INFO of WALRUS and its total"); log.info("No Walrus"); - log.with_field(log.custom_field={{"animal", "dog"}, {"total", float_test}}).warn("WARN of DOG and its total"); + log.with_field(log.custom_field = {{"animal", "dog"}, {"total", float_test}}) + .warn("WARN of DOG and its total"); log.warn("No Dog"); - - log.JSON_output(); //output in JSON format - log.with_field(log.custom_field={{"animal", "cat"}, {"total", long_test}}).critical("CRITICAL of CAT and its total"); + log.JSON_output(); // output in JSON format + log.with_field(log.custom_field = {{"animal", "cat"}, {"total", long_test}}) + .critical("CRITICAL of CAT and its total"); log.critical("No Cat"); - log.with_field(log.custom_field={{"animal", "falcon"}, {"total", 10}}).error("ERROR of FALCON and its total"); + log.with_field(log.custom_field = {{"animal", "falcon"}, {"total", 10}}) + .error("ERROR of FALCON and its total"); log.error("No Falcon"); - auto staticformat = log.with_field(log.custom_field={{"float",float_test}, {"long", long_test}, {"string", a}}); + auto staticformat = log.with_field(log.custom_field = {{"float", float_test}, + {"long", long_test}, + {"string", a}}); staticformat.info("This is INFO with custom key"); staticformat.debug("This is DEBUG with custom key"); staticformat.trace("This is TRACE with custom key"); @@ -34,7 +39,9 @@ int main() staticformat.error("This is ERROR with custom key"); log.default_output(); - auto staticformat2 = log.with_field(log.custom_field={{"animal","griffin"}, {"rider", "azure"}, {"weapon", "spear"}}); + auto staticformat2 = log.with_field(log.custom_field = {{"animal", "griffin"}, + {"rider", "azure"}, + {"weapon", "spear"}}); staticformat2.info("This is INFO with custom key"); staticformat2.debug("This is DEBUG with custom key"); staticformat2.trace("This is TRACE with custom key"); diff --git a/logfmt.cpp b/logfmt.cpp index 6754f0e..30956cd 100644 --- a/logfmt.cpp +++ b/logfmt.cpp @@ -2,205 +2,174 @@ //////////////////////////////////////////////////////////////////////////////////////////////////////// -//class Entry +// class Entry -//private -std::string logfmt::Entry::add_quotation(std::string msg) //return quotation in message input +// private +std::string logfmt::Entry::add_quotation( + std::string msg) // return quotation in message input { return "\"" + msg + "\""; } -void logfmt::Entry::process_key(std::string& msg) -{ - std::string pattern =" "; +void logfmt::Entry::process_key(std::string& msg) { + std::string pattern = " "; - for (auto& [key,val] : entry_field) - { - if (JSON) - { + for (auto& [key, val] : entry_field) { + if (JSON) { pattern = pattern + cast_JSON(key, val); - } - else - { + } else { pattern = pattern + cast_default(key, val); } } - if(JSON) - { + if (JSON) { msg = add_quotation(msg); } msg = msg + pattern; } -std::string logfmt::Entry::cast_default(std::string key, std::any val) //casting the value in map into default format +std::string logfmt::Entry::cast_default( + std::string key, + std::any val) // casting the value in map into default format { std::string custom_string; - - custom_string = custom_string + key + " = " ; - if (val.type() == typeid(char)) - { + + custom_string = custom_string + key + " = "; + if (val.type() == typeid(char)) { custom_string = custom_string + "\""; custom_string += (std::any_cast(val)); custom_string = custom_string + "\" "; - } - else if (val.type() == typeid(const char *)) - { - std::string temp(std::any_cast(val)); + } else if (val.type() == typeid(const char*)) { + std::string temp(std::any_cast(val)); custom_string = custom_string + add_quotation(temp) + " "; - } - else if (val.type() == typeid(int)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(float)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(double)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(bool)) - { - if (std::any_cast(val) == 1) - { + } else if (val.type() == typeid(int)) { + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(float)) { + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(double)) { + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(bool)) { + if (std::any_cast(val) == 1) { custom_string = custom_string + "true "; - } - else if (std::any_cast(val) == 0) - { + } else if (std::any_cast(val) == 0) { custom_string = custom_string + "false "; } + } else if (val.type() == typeid(std::string)) { + custom_string = + custom_string + add_quotation(std::any_cast(val)) + " "; + } else if (val.type() == typeid(long)) { + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; } - else if (val.type() == typeid(std::string)) - { - custom_string = custom_string + add_quotation(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(long)) - { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - + return custom_string; } -std::string logfmt::Entry::cast_JSON(std::string key, std::any val) //casting the value in map into json format +std::string logfmt::Entry::cast_JSON( + std::string key, std::any val) // casting the value in map into json format { - std::string custom_string = ", " + add_quotation(key) + " : " ; - //check type for any_cast - if (val.type() == typeid(char)) //char + std::string custom_string = ", " + add_quotation(key) + " : "; + // check type for any_cast + if (val.type() == typeid(char)) // char { custom_string = custom_string + "\""; custom_string += (std::any_cast(val)); custom_string = custom_string + "\" "; - } - else if (val.type() == typeid(const char *)) //array of char + } else if (val.type() == typeid(const char*)) // array of char { - std::string temp(std::any_cast(val)); + std::string temp(std::any_cast(val)); custom_string = custom_string + add_quotation(temp) + " "; - } - else if (val.type() == typeid(int)) //integer + } else if (val.type() == typeid(int)) // integer { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(float)) //float + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(float)) // float { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(double)) //double + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(double)) // double { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(bool)) //boolean + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(bool)) // boolean { - if (std::any_cast(val) == 1) - { + if (std::any_cast(val) == 1) { custom_string = custom_string + "true "; - } - else if (std::any_cast(val) == 0) - { + } else if (std::any_cast(val) == 0) { custom_string = custom_string + "false "; } - } - else if (val.type() == typeid(std::string)) //string + } else if (val.type() == typeid(std::string)) // string { - custom_string = custom_string + add_quotation(std::any_cast(val)) + " "; - } - else if (val.type() == typeid(long)) //long + custom_string = + custom_string + add_quotation(std::any_cast(val)) + " "; + } else if (val.type() == typeid(long)) // long { - custom_string = custom_string + std::to_string(std::any_cast(val)) + " "; + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; } return custom_string; } - -//public -logfmt::Entry::Entry() -{ - //default ctor (not used) +// public +logfmt::Entry::Entry() { + // default ctor (not used) } -logfmt::Entry::Entry(std::shared_ptr& log, bool JSON ) //ctor +logfmt::Entry::Entry(std::shared_ptr& log, bool JSON) // ctor { entry_log = log; - this -> JSON = JSON; + this->JSON = JSON; } -logfmt::Entry& logfmt::Entry::with_field(std::map& keyMap) -{ +logfmt::Entry& logfmt::Entry::with_field( + std::map& keyMap) { entry_field = keyMap; return *this; } -void logfmt::Entry::info(std::string msg) -{ +void logfmt::Entry::info(std::string msg) { process_key(msg); - entry_log -> info(msg); + entry_log->info(msg); } -void logfmt::Entry::trace(std::string msg) -{ +void logfmt::Entry::trace(std::string msg) { process_key(msg); - entry_log -> trace(msg); + entry_log->trace(msg); } -void logfmt::Entry::debug(std::string msg) -{ +void logfmt::Entry::debug(std::string msg) { process_key(msg); - entry_log -> debug(msg); + entry_log->debug(msg); } -void logfmt::Entry::warn(std::string msg) -{ +void logfmt::Entry::warn(std::string msg) { process_key(msg); - entry_log -> warn(msg); + entry_log->warn(msg); } -void logfmt::Entry::error(std::string msg) -{ +void logfmt::Entry::error(std::string msg) { process_key(msg); - entry_log -> error(msg); + entry_log->error(msg); } -void logfmt::Entry::critical(std::string msg) -{ +void logfmt::Entry::critical(std::string msg) { process_key(msg); - entry_log -> critical(msg); + entry_log->critical(msg); } //////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////// // logfmt implementation -logfmt::logfmt(std::string name, bool to_file) //constructor +logfmt::logfmt(std::string name, bool to_file) // constructor { - if (to_file) - { - logger = spdlog::basic_logger_mt(name , "logs/basic-log.txt"); - } - else - { + if (to_file) { + logger = spdlog::basic_logger_mt(name, "logs/basic-log.txt"); + } else { logger = spdlog::stdout_color_mt(name); } write_file = to_file; @@ -208,87 +177,73 @@ logfmt::logfmt(std::string name, bool to_file) //constructor } // function -void logfmt::JSON_output() -{ +void logfmt::JSON_output() { JSON_status = true; - logger -> set_pattern(JSON_formatter()); + logger->set_pattern(JSON_formatter()); } -void logfmt::default_output() -{ +void logfmt::default_output() { JSON_status = false; - logger -> set_pattern("%+"); + logger->set_pattern("%+"); } -logfmt::Entry& logfmt::with_field(std::map& keyMap) -{ +logfmt::Entry& logfmt::with_field(std::map& keyMap) { logger_entry = Entry(logger, JSON_status); return logger_entry.with_field(keyMap); } -std::string logfmt::add_quotation(std::string msg) //return quotation in message input +std::string logfmt::add_quotation( + std::string msg) // return quotation in message input { return "\"" + msg + "\" "; } -std::string logfmt::JSON_formatter() -{ - return "{ \"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : \"%n\" , \"level\" : \"%^%l%$\" , \"message\" : %v}"; +std::string logfmt::JSON_formatter() { + return "{ \"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : " + "\"%n\" , \"level\" : \"%^%l%$\" , \"message\" : %v}"; } -//basic logging -void logfmt::info(std::string msg) -{ - if (JSON_status) - { +// basic logging +void logfmt::info(std::string msg) { + if (JSON_status) { msg = add_quotation(msg); } - logger -> info(msg); + logger->info(msg); } -void logfmt::trace(std::string msg) -{ - if (JSON_status) - { +void logfmt::trace(std::string msg) { + if (JSON_status) { msg = add_quotation(msg); } - logger -> trace(msg); + logger->trace(msg); } -void logfmt::debug(std::string msg) -{ - if (JSON_status) - { +void logfmt::debug(std::string msg) { + if (JSON_status) { msg = add_quotation(msg); } - logger -> debug(msg); + logger->debug(msg); } -void logfmt::warn(std::string msg) -{ - if (JSON_status) - { +void logfmt::warn(std::string msg) { + if (JSON_status) { msg = add_quotation(msg); } - logger -> warn(msg); + logger->warn(msg); } -void logfmt::error(std::string msg) -{ - if (JSON_status) - { +void logfmt::error(std::string msg) { + if (JSON_status) { msg = add_quotation(msg); } - logger -> error(msg); + logger->error(msg); } -void logfmt::critical(std::string msg) -{ - if (JSON_status) - { +void logfmt::critical(std::string msg) { + if (JSON_status) { msg = add_quotation(msg); } - logger -> critical(msg); + logger->critical(msg); } diff --git a/logfmt.h b/logfmt.h index 32742d8..9149799 100644 --- a/logfmt.h +++ b/logfmt.h @@ -1,58 +1,59 @@ #pragma once +#include #include #include -#include #include -#include "spdlog/spdlog.h" -#include "spdlog/sinks/stdout_color_sinks.h" #include "spdlog/sinks/basic_file_sink.h" +#include "spdlog/sinks/stdout_color_sinks.h" +#include "spdlog/spdlog.h" + +class logfmt { + private: + // member + class Entry { + private: + // member + std::map entry_field; + std::shared_ptr entry_log; + bool JSON; + // function + std::string add_quotation(std::string msg); + void process_key(std::string& msg); + std::string cast_default(std::string key, std::any val); + std::string cast_JSON(std::string key, std::any val); -class logfmt -{ -private: - //member - class Entry - { - private: - //member - std::map entry_field; - std::shared_ptr entry_log; - bool JSON; - //function - std::string add_quotation(std::string msg); - void process_key(std::string& msg); - std::string cast_default(std::string key, std::any val); - std::string cast_JSON(std::string key, std::any val); - public: - Entry(); //default ctor - Entry(std::shared_ptr& log, bool JSON ); //ctor with parameter - Entry& with_field(std::map& keyMap); - void info(std::string msg); - void trace(std::string msg); - void debug(std::string msg); - void warn(std::string msg); - void error(std::string msg); - void critical(std::string msg); + public: + Entry(); // default ctor + Entry(std::shared_ptr& log, + bool JSON); // ctor with parameter + Entry& with_field(std::map& keyMap); + void info(std::string msg); + void trace(std::string msg); + void debug(std::string msg); + void warn(std::string msg); + void error(std::string msg); + void critical(std::string msg); }; Entry logger_entry; std::shared_ptr logger; - bool JSON_status; // make this true to make log in JSON form / false in normal form - bool write_file; // make this true to write log into file - //private function - std::string JSON_formatter(); // make the log in JSON format + bool JSON_status; + bool write_file; // make this true to write log into file + // private function + std::string JSON_formatter(); // make the log in JSON format std::string add_quotation(std::string msg); -public: - //member + + public: + // member std::map custom_field; - //ctor + // ctor logfmt(std::string name, bool to_file); - //function + // function void JSON_output(); void default_output(); logfmt::Entry& with_field(std::map& keyMap); - - //basic logging + + // basic logging void info(std::string msg); void trace(std::string msg); void debug(std::string msg); From 29b24f078db8613524ea3b7a40c055e3774198fa Mon Sep 17 00:00:00 2001 From: cks Date: Mon, 13 Aug 2018 11:37:26 +0700 Subject: [PATCH 11/11] Refactor cast_json and cast_default --- .clang-format | 91 ----------- logfmt.cpp | 444 ++++++++++++++++++++++---------------------------- logfmt.h | 128 ++++++++------- 3 files changed, 260 insertions(+), 403 deletions(-) diff --git a/.clang-format b/.clang-format index 6010e81..06ea346 100644 --- a/.clang-format +++ b/.clang-format @@ -1,95 +1,4 @@ --- Language: Cpp BasedOnStyle: Google -AccessModifierOffset: -1 -AlignAfterOpenBracket: Align -AlignConsecutiveAssignments: false -AlignConsecutiveDeclarations: false -AlignEscapedNewlinesLeft: true -AlignOperands: true -AlignTrailingComments: true -AllowAllParametersOfDeclarationOnNextLine: true -AllowShortBlocksOnASingleLine: false -AllowShortCaseLabelsOnASingleLine: false -AllowShortFunctionsOnASingleLine: All -AllowShortIfStatementsOnASingleLine: true -AllowShortLoopsOnASingleLine: true -AlwaysBreakAfterDefinitionReturnType: None -AlwaysBreakAfterReturnType: None -AlwaysBreakBeforeMultilineStrings: true -AlwaysBreakTemplateDeclarations: true -BinPackArguments: true -BinPackParameters: true -BraceWrapping: - AfterClass: false - AfterControlStatement: false - AfterEnum: false - AfterFunction: false - AfterNamespace: false - AfterObjCDeclaration: false - AfterStruct: false - AfterUnion: false - BeforeCatch: false - BeforeElse: false - IndentBraces: false -BreakBeforeBinaryOperators: None -BreakBeforeBraces: Attach -BreakBeforeTernaryOperators: true -BreakConstructorInitializersBeforeComma: false -BreakAfterJavaFieldAnnotations: false -BreakStringLiterals: true -ColumnLimit: 80 -CommentPragmas: '^ IWYU pragma:' -ConstructorInitializerAllOnOneLineOrOnePerLine: true -ConstructorInitializerIndentWidth: 4 -ContinuationIndentWidth: 4 -Cpp11BracedListStyle: true -DerivePointerAlignment: true -DisableFormat: false -ExperimentalAutoDetectBinPacking: false -ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ] -IncludeCategories: - - Regex: '^<.*\.h>' - Priority: 1 - - Regex: '^<.*' - Priority: 2 - - Regex: '.*' - Priority: 3 -IncludeIsMainRegex: '([-_](test|unittest))?$' -IndentCaseLabels: true -IndentWidth: 2 -IndentWrappedFunctionNames: false -JavaScriptQuotes: Leave -JavaScriptWrapImports: true -KeepEmptyLinesAtTheStartOfBlocks: false -MacroBlockBegin: '' -MacroBlockEnd: '' -MaxEmptyLinesToKeep: 1 -NamespaceIndentation: None -ObjCBlockIndentWidth: 2 -ObjCSpaceAfterProperty: false -ObjCSpaceBeforeProtocolList: false -PenaltyBreakBeforeFirstCallParameter: 1 -PenaltyBreakComment: 300 -PenaltyBreakFirstLessLess: 120 -PenaltyBreakString: 1000 -PenaltyExcessCharacter: 1000000 -PenaltyReturnTypeOnItsOwnLine: 200 -PointerAlignment: Left -ReflowComments: true -SortIncludes: true -SpaceAfterCStyleCast: false -SpaceAfterTemplateKeyword: true -SpaceBeforeAssignmentOperators: true -SpaceBeforeParens: ControlStatements -SpaceInEmptyParentheses: false -SpacesBeforeTrailingComments: 2 -SpacesInAngles: false -SpacesInContainerLiterals: true -SpacesInCStyleCastParentheses: false -SpacesInParentheses: false -SpacesInSquareBrackets: false -Standard: Auto -TabWidth: 8 -UseTab: Never ... diff --git a/logfmt.cpp b/logfmt.cpp index 30956cd..ade0af5 100644 --- a/logfmt.cpp +++ b/logfmt.cpp @@ -1,249 +1,195 @@ -#include "logfmt.h" - -//////////////////////////////////////////////////////////////////////////////////////////////////////// - -// class Entry - -// private -std::string logfmt::Entry::add_quotation( - std::string msg) // return quotation in message input -{ - return "\"" + msg + "\""; -} - -void logfmt::Entry::process_key(std::string& msg) { - std::string pattern = " "; - - for (auto& [key, val] : entry_field) { - if (JSON) { - pattern = pattern + cast_JSON(key, val); - } else { - pattern = pattern + cast_default(key, val); - } - } - - if (JSON) { - msg = add_quotation(msg); - } - - msg = msg + pattern; -} - -std::string logfmt::Entry::cast_default( - std::string key, - std::any val) // casting the value in map into default format -{ - std::string custom_string; - - custom_string = custom_string + key + " = "; - if (val.type() == typeid(char)) { - custom_string = custom_string + "\""; - custom_string += (std::any_cast(val)); - custom_string = custom_string + "\" "; - } else if (val.type() == typeid(const char*)) { - std::string temp(std::any_cast(val)); - custom_string = custom_string + add_quotation(temp) + " "; - } else if (val.type() == typeid(int)) { - custom_string = - custom_string + std::to_string(std::any_cast(val)) + " "; - } else if (val.type() == typeid(float)) { - custom_string = - custom_string + std::to_string(std::any_cast(val)) + " "; - } else if (val.type() == typeid(double)) { - custom_string = - custom_string + std::to_string(std::any_cast(val)) + " "; - } else if (val.type() == typeid(bool)) { - if (std::any_cast(val) == 1) { - custom_string = custom_string + "true "; - } else if (std::any_cast(val) == 0) { - custom_string = custom_string + "false "; - } - } else if (val.type() == typeid(std::string)) { - custom_string = - custom_string + add_quotation(std::any_cast(val)) + " "; - } else if (val.type() == typeid(long)) { - custom_string = - custom_string + std::to_string(std::any_cast(val)) + " "; - } - - return custom_string; -} - -std::string logfmt::Entry::cast_JSON( - std::string key, std::any val) // casting the value in map into json format -{ - std::string custom_string = ", " + add_quotation(key) + " : "; - // check type for any_cast - if (val.type() == typeid(char)) // char - { - custom_string = custom_string + "\""; - custom_string += (std::any_cast(val)); - custom_string = custom_string + "\" "; - } else if (val.type() == typeid(const char*)) // array of char - { - std::string temp(std::any_cast(val)); - custom_string = custom_string + add_quotation(temp) + " "; - } else if (val.type() == typeid(int)) // integer - { - custom_string = - custom_string + std::to_string(std::any_cast(val)) + " "; - } else if (val.type() == typeid(float)) // float - { - custom_string = - custom_string + std::to_string(std::any_cast(val)) + " "; - } else if (val.type() == typeid(double)) // double - { - custom_string = - custom_string + std::to_string(std::any_cast(val)) + " "; - } else if (val.type() == typeid(bool)) // boolean - { - if (std::any_cast(val) == 1) { - custom_string = custom_string + "true "; - } else if (std::any_cast(val) == 0) { - custom_string = custom_string + "false "; - } - } else if (val.type() == typeid(std::string)) // string - { - custom_string = - custom_string + add_quotation(std::any_cast(val)) + " "; - } else if (val.type() == typeid(long)) // long - { - custom_string = - custom_string + std::to_string(std::any_cast(val)) + " "; - } - - return custom_string; -} - -// public -logfmt::Entry::Entry() { - // default ctor (not used) -} - -logfmt::Entry::Entry(std::shared_ptr& log, bool JSON) // ctor -{ - entry_log = log; - this->JSON = JSON; -} - -logfmt::Entry& logfmt::Entry::with_field( - std::map& keyMap) { - entry_field = keyMap; - return *this; -} -void logfmt::Entry::info(std::string msg) { - process_key(msg); - entry_log->info(msg); -} - -void logfmt::Entry::trace(std::string msg) { - process_key(msg); - entry_log->trace(msg); -} - -void logfmt::Entry::debug(std::string msg) { - process_key(msg); - entry_log->debug(msg); -} - -void logfmt::Entry::warn(std::string msg) { - process_key(msg); - entry_log->warn(msg); -} - -void logfmt::Entry::error(std::string msg) { - process_key(msg); - entry_log->error(msg); -} - -void logfmt::Entry::critical(std::string msg) { - process_key(msg); - entry_log->critical(msg); -} -//////////////////////////////////////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////////////////////////////////////// -// logfmt implementation - -logfmt::logfmt(std::string name, bool to_file) // constructor -{ - if (to_file) { - logger = spdlog::basic_logger_mt(name, "logs/basic-log.txt"); - } else { - logger = spdlog::stdout_color_mt(name); - } - write_file = to_file; - JSON_status = false; -} - -// function -void logfmt::JSON_output() { - JSON_status = true; - logger->set_pattern(JSON_formatter()); -} - -void logfmt::default_output() { - JSON_status = false; - logger->set_pattern("%+"); -} - -logfmt::Entry& logfmt::with_field(std::map& keyMap) { - logger_entry = Entry(logger, JSON_status); - return logger_entry.with_field(keyMap); -} - -std::string logfmt::add_quotation( - std::string msg) // return quotation in message input -{ - return "\"" + msg + "\" "; -} - -std::string logfmt::JSON_formatter() { - return "{ \"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : " - "\"%n\" , \"level\" : \"%^%l%$\" , \"message\" : %v}"; -} - -// basic logging -void logfmt::info(std::string msg) { - if (JSON_status) { - msg = add_quotation(msg); - } - - logger->info(msg); -} - -void logfmt::trace(std::string msg) { - if (JSON_status) { - msg = add_quotation(msg); - } - - logger->trace(msg); -} -void logfmt::debug(std::string msg) { - if (JSON_status) { - msg = add_quotation(msg); - } - - logger->debug(msg); -} -void logfmt::warn(std::string msg) { - if (JSON_status) { - msg = add_quotation(msg); - } - - logger->warn(msg); -} -void logfmt::error(std::string msg) { - if (JSON_status) { - msg = add_quotation(msg); - } - - logger->error(msg); -} -void logfmt::critical(std::string msg) { - if (JSON_status) { - msg = add_quotation(msg); - } - - logger->critical(msg); -} +#include "logfmt.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////////// + +// class Entry + +// private +std::string logfmt::Entry::add_quotation(std::string msg) { + return "\"" + msg + "\""; +} + +void logfmt::Entry::process_key(std::string& msg) { + std::string pattern = " "; + + for (auto& [key, val] : entry_field) { + pattern = pattern + cast_key(key, val); + } + + if (JSON) { + msg = add_quotation(msg); + } + + msg = msg + pattern; +} + +std::string logfmt::Entry::cast_key(std::string key, std::any val) { + std::string custom_string; + + if (JSON) { + custom_string = ", " + add_quotation(key) + " : "; + } else { + custom_string = custom_string + key + " = "; + } + if (val.type() == typeid(char)) { + custom_string = custom_string + "\""; + custom_string += (std::any_cast(val)); + custom_string = custom_string + "\" "; + } else if (val.type() == typeid(const char*)) { + std::string temp(std::any_cast(val)); + custom_string = custom_string + add_quotation(temp) + " "; + } else if (val.type() == typeid(int)) { + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(float)) { + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(double)) { + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } else if (val.type() == typeid(bool)) { + if (std::any_cast(val) == 1) { + custom_string = custom_string + "true "; + } else if (std::any_cast(val) == 0) { + custom_string = custom_string + "false "; + } + } else if (val.type() == typeid(std::string)) { + custom_string = + custom_string + add_quotation(std::any_cast(val)) + " "; + } else if (val.type() == typeid(long)) { + custom_string = + custom_string + std::to_string(std::any_cast(val)) + " "; + } + + return custom_string; +} + +// public +logfmt::Entry::Entry() { + // default ctor (not used) +} + +logfmt::Entry::Entry(std::shared_ptr& log, bool JSON) { + entry_log = log; + this->JSON = JSON; +} + +logfmt::Entry& logfmt::Entry::with_field( + std::map& key_map) { + entry_field = key_map; + return *this; +} +void logfmt::Entry::info(std::string msg) { + process_key(msg); + entry_log->info(msg); +} + +void logfmt::Entry::trace(std::string msg) { + process_key(msg); + entry_log->trace(msg); +} + +void logfmt::Entry::debug(std::string msg) { + process_key(msg); + entry_log->debug(msg); +} + +void logfmt::Entry::warn(std::string msg) { + process_key(msg); + entry_log->warn(msg); +} + +void logfmt::Entry::error(std::string msg) { + process_key(msg); + entry_log->error(msg); +} + +void logfmt::Entry::critical(std::string msg) { + process_key(msg); + entry_log->critical(msg); +} +//////////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////////// +// logfmt implementation + +// ctor +logfmt::logfmt(std::string name, bool to_file) { + if (to_file) { + logger = spdlog::basic_logger_mt(name, "logs/basic-log.txt"); + } else { + logger = spdlog::stdout_color_mt(name); + } + write_file = to_file; + JSON_status = false; +} + +// function +void logfmt::JSON_output() { + JSON_status = true; + logger->set_pattern(JSON_formatter()); +} + +void logfmt::default_output() { + JSON_status = false; + logger->set_pattern("%+"); +} + +logfmt::Entry& logfmt::with_field(std::map& key_map) { + logger_entry = Entry(logger, JSON_status); + return logger_entry.with_field(key_map); +} + +std::string logfmt::add_quotation(std::string msg) { + return "\"" + msg + "\" "; +} + +std::string logfmt::JSON_formatter() { + return "{ \"date\" : \"%d-%m-%Y\" , \"time\" : \"%H:%M:%S\" , \"name\" : " + "\"%n\" , \"level\" : \"%^%l%$\" , \"message\" : %v}"; +} + +// basic logging +void logfmt::info(std::string msg) { + if (JSON_status) { + msg = add_quotation(msg); + } + + logger->info(msg); +} + +void logfmt::trace(std::string msg) { + if (JSON_status) { + msg = add_quotation(msg); + } + + logger->trace(msg); +} +void logfmt::debug(std::string msg) { + if (JSON_status) { + msg = add_quotation(msg); + } + + logger->debug(msg); +} +void logfmt::warn(std::string msg) { + if (JSON_status) { + msg = add_quotation(msg); + } + + logger->warn(msg); +} +void logfmt::error(std::string msg) { + if (JSON_status) { + msg = add_quotation(msg); + } + + logger->error(msg); +} +void logfmt::critical(std::string msg) { + if (JSON_status) { + msg = add_quotation(msg); + } + + logger->critical(msg); +} diff --git a/logfmt.h b/logfmt.h index 9149799..b22ba9e 100644 --- a/logfmt.h +++ b/logfmt.h @@ -1,63 +1,65 @@ -#pragma once - -#include -#include -#include -#include -#include "spdlog/sinks/basic_file_sink.h" -#include "spdlog/sinks/stdout_color_sinks.h" -#include "spdlog/spdlog.h" - -class logfmt { - private: - // member - class Entry { - private: - // member - std::map entry_field; - std::shared_ptr entry_log; - bool JSON; - // function - std::string add_quotation(std::string msg); - void process_key(std::string& msg); - std::string cast_default(std::string key, std::any val); - std::string cast_JSON(std::string key, std::any val); - - public: - Entry(); // default ctor - Entry(std::shared_ptr& log, - bool JSON); // ctor with parameter - Entry& with_field(std::map& keyMap); - void info(std::string msg); - void trace(std::string msg); - void debug(std::string msg); - void warn(std::string msg); - void error(std::string msg); - void critical(std::string msg); - }; - Entry logger_entry; - std::shared_ptr logger; - bool JSON_status; - bool write_file; // make this true to write log into file - // private function - std::string JSON_formatter(); // make the log in JSON format - std::string add_quotation(std::string msg); - - public: - // member - std::map custom_field; - // ctor - logfmt(std::string name, bool to_file); - // function - void JSON_output(); - void default_output(); - logfmt::Entry& with_field(std::map& keyMap); - - // basic logging - void info(std::string msg); - void trace(std::string msg); - void debug(std::string msg); - void warn(std::string msg); - void error(std::string msg); - void critical(std::string msg); -}; +#pragma once + +#include +#include +#include +#include +#include "spdlog/sinks/basic_file_sink.h" +#include "spdlog/sinks/stdout_color_sinks.h" +#include "spdlog/spdlog.h" + +class logfmt { + private: + // member of logfmt + class Entry { + // member of Entry + private: + std::map entry_field; + std::shared_ptr entry_log; + bool JSON; + // function + std::string add_quotation(std::string msg); // add quotation into message + void process_key(std::string& msg); // process the custom key + std::string cast_key(std::string key, + std::any val); // cast any type to its original type + public: + // default ctor + Entry(); + // ctor with parameter + Entry(std::shared_ptr& log, bool JSON); + // function + Entry& with_field(std::map& key_map); + void info(std::string msg); + void trace(std::string msg); + void debug(std::string msg); + void warn(std::string msg); + void error(std::string msg); + void critical(std::string msg); + }; + Entry logger_entry; + std::shared_ptr logger; + bool JSON_status; + bool write_file; // make this true to write log into file + + // private function + std::string JSON_formatter(); // make the log in JSON format + std::string add_quotation(std::string msg); + + public: + // member + std::map custom_field; + // ctor + logfmt(std::string name, bool to_file); + // function + void JSON_output(); // make output into JSON format + void default_output(); // make output into default format + logfmt::Entry& with_field(std::map& key_map); + + // basic logging + void info(std::string msg); + void trace(std::string msg); + void debug(std::string msg); + void warn(std::string msg); + void error(std::string msg); + void critical(std::string msg); +};