PM/DYT
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add new spdlog

Browse Source
This commit is contained in:
jiegeaiai 2025-01-03 23:22:57 +08:00
parent 6af67249a3
commit abcd6828aa
110 changed files with 11368 additions and 10861 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
Source/workspace/UILayout.xml
View File

@ -1,41 +1,40 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<Layout> <Layout>
<MainWindow Name="窗口1"> <MainWindow Name="窗口1">
<CentralWidget Name="中心区域"> <CentralWidget Name="中心区域">
<Widget Plugin="QtOsgViewWidget" Name="三维场景"/> <Widget Plugin="QtOsgViewWidget" Name="三维场景"/>
</CentralWidget> </CentralWidget>
<DockLeftArea Name="左侧区域"> <DockLeftArea Name="左侧区域">
<Widget Plugin="PropertyBrowser" Name="属性"/> <Widget Plugin="PropertyBrowser" Name="属性"/>
<Widget Plugin="ModelBrowser" Name="模型"/> <Widget Plugin="ModelBrowser" Name="模型"/>
<Widget Plugin="TargetListWgt" Name="目标上报信息"/> <Widget Plugin="TargetListWgt" Name="目标上报信息"/>
</DockLeftArea> </DockLeftArea>
<DockTopArea Name="上方区域"/> <DockTopArea Name="上方区域"/>
<DockRightArea Name="右侧区域"/> <DockRightArea Name="右侧区域"/>
<DockBottomArea Name="下方区域"/> <DockBottomArea Name="下方区域"/>
</MainWindow> </MainWindow>
<MainWindow Name="窗口2"> <MainWindow Name="窗口2">
<CentralWidget Name="中心区域"> <CentralWidget Name="中心区域"/>
</CentralWidget> <DockLeftArea Name="左侧区域">
<DockLeftArea Name="左侧区域"> <Widget Plugin="SignalIndicatorLampUI" Name="信号指示灯"/>
<Widget Plugin="SignalIndicatorLampUI" Name="信号指示灯"/> <Widget Plugin="TargetListWgt_Table" Name="目标上报信息"/>
<Widget Plugin="TargetListWgt_Table" Name="目标上报信息"/> <DocTab Name="水平分页">
<Widget Plugin="ParamSetting" Name="参数设置"/> <Widget Plugin="WaveCurveDialog" Name="波形曲线图"/>
<DocTab Name="水平分页"> <Widget Plugin="SpeedCurveDialog" Name="距离速度曲线"/>
<Widget Plugin="WaveCurveDialog" Name="波形曲线图"/> <Widget Plugin="3DCurveDialog" Name="3D曲面图"/>
<Widget Plugin="SpeedCurveDialog" Name="距离速度曲线"/> </DocTab>
<Widget Plugin="3DCurveDialog" Name="3D曲面图"/> </DockLeftArea>
</DocTab> <DockTopArea Name="上方区域"/>
</DockLeftArea> <DockRightArea Name="右侧区域"/>
<DockTopArea Name="上方区域"/> <DockBottomArea Name="下方区域"/>
<DockRightArea Name="右侧区域"/> </MainWindow>
<DockBottomArea Name="下方区域"/> <MainWindow Name="新增窗口">
</MainWindow> <CentralWidget Name="中心区域"/>
<MainWindow Name="新增窗口"> <DockLeftArea Name="左侧区域"/>
<CentralWidget Name="中心区域"> <DockTopArea Name="上方区域"/>
</CentralWidget> <DockRightArea Name="右侧区域">
<DockLeftArea Name="左侧区域"/> <Widget Plugin="ParamSetting" Name="参数设置"/>
<DockTopArea Name="上方区域"/> </DockRightArea>
<DockRightArea Name="右侧区域"/> <DockBottomArea Name="下方区域"/>
<DockBottomArea Name="下方区域"/> </MainWindow>
</MainWindow>
</Layout> </Layout>

59
Tool/spdlog/include/spdlog/async.h
View File

@ -18,9 +18,9 @@
#include <spdlog/details/registry.h> #include <spdlog/details/registry.h>
#include <spdlog/details/thread_pool.h> #include <spdlog/details/thread_pool.h>
#include <functional>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <functional>
namespace spdlog { namespace spdlog {
@ -31,12 +31,10 @@ static const size_t default_async_q_size = 8192;
// async logger factory - creates async loggers backed with thread pool. // async logger factory - creates async loggers backed with thread pool.
// if a global thread pool doesn't already exist, create it with default queue // if a global thread pool doesn't already exist, create it with default queue
// size of 8192 items and single thread. // size of 8192 items and single thread.
template<async_overflow_policy OverflowPolicy = async_overflow_policy::block> template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
struct async_factory_impl struct async_factory_impl {
{ template <typename Sink, typename... SinkArgs>
template<typename Sink, typename... SinkArgs> static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) {
static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args)
{
auto &registry_inst = details::registry::instance(); auto &registry_inst = details::registry::instance();
// create global thread pool if not already exists.. // create global thread pool if not already exists..
@ -44,14 +42,14 @@ struct async_factory_impl
auto &mutex = registry_inst.tp_mutex(); auto &mutex = registry_inst.tp_mutex();
std::lock_guard<std::recursive_mutex> tp_lock(mutex); std::lock_guard<std::recursive_mutex> tp_lock(mutex);
auto tp = registry_inst.get_tp(); auto tp = registry_inst.get_tp();
if (tp == nullptr) if (tp == nullptr) {
{
tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U); tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
registry_inst.set_tp(tp); registry_inst.set_tp(tp);
} }
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy); auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink),
std::move(tp), OverflowPolicy);
registry_inst.initialize_logger(new_logger); registry_inst.initialize_logger(new_logger);
return new_logger; return new_logger;
} }
@ -60,40 +58,43 @@ struct async_factory_impl
using async_factory = async_factory_impl<async_overflow_policy::block>; using async_factory = async_factory_impl<async_overflow_policy::block>;
using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>; using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
template<typename Sink, typename... SinkArgs> template <typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&...sink_args) inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
{ SinkArgs &&...sink_args) {
return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return async_factory::create<Sink>(std::move(logger_name),
std::forward<SinkArgs>(sink_args)...);
} }
template<typename Sink, typename... SinkArgs> template <typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&...sink_args) inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name,
{ SinkArgs &&...sink_args) {
return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return async_factory_nonblock::create<Sink>(std::move(logger_name),
std::forward<SinkArgs>(sink_args)...);
} }
// set global thread pool. // set global thread pool.
inline void init_thread_pool( inline void init_thread_pool(size_t q_size,
size_t q_size, size_t thread_count, std::function<void()> on_thread_start, std::function<void()> on_thread_stop) size_t thread_count,
{ std::function<void()> on_thread_start,
auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, on_thread_stop); std::function<void()> on_thread_stop) {
auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start,
on_thread_stop);
details::registry::instance().set_tp(std::move(tp)); details::registry::instance().set_tp(std::move(tp));
} }
inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start) inline void init_thread_pool(size_t q_size,
{ size_t thread_count,
std::function<void()> on_thread_start) {
init_thread_pool(q_size, thread_count, on_thread_start, [] {}); init_thread_pool(q_size, thread_count, on_thread_start, [] {});
} }
inline void init_thread_pool(size_t q_size, size_t thread_count) inline void init_thread_pool(size_t q_size, size_t thread_count) {
{
init_thread_pool( init_thread_pool(
q_size, thread_count, [] {}, [] {}); q_size, thread_count, [] {}, [] {});
} }
// get the global thread pool. // get the global thread pool.
inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
{
return details::registry::instance().get_tp(); return details::registry::instance().get_tp();
} }
} // namespace spdlog } // namespace spdlog

70
Tool/spdlog/include/spdlog/async_logger-inl.h
View File

@ -4,31 +4,38 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/async_logger.h> #include <spdlog/async_logger.h>
#endif #endif
#include <spdlog/sinks/sink.h>
#include <spdlog/details/thread_pool.h> #include <spdlog/details/thread_pool.h>
#include <spdlog/sinks/sink.h>
#include <memory> #include <memory>
#include <string> #include <string>
SPDLOG_INLINE spdlog::async_logger::async_logger( SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,
std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy) sinks_init_list sinks_list,
: async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy) std::weak_ptr<details::thread_pool> tp,
{} async_overflow_policy overflow_policy)
: async_logger(std::move(logger_name),
sinks_list.begin(),
sinks_list.end(),
std::move(tp),
overflow_policy) {}
SPDLOG_INLINE spdlog::async_logger::async_logger( SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,
std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy) sink_ptr single_sink,
: async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) std::weak_ptr<details::thread_pool> tp,
{} async_overflow_policy overflow_policy)
: async_logger(
std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {}
// send the log message to the thread pool // send the log message to the thread pool
SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){ SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){
SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr->post_log(shared_from_this(), msg, overflow_policy_); SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){
pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
} }
else else {
{
throw_spdlog_ex("async log: thread pool doesn't exist anymore"); throw_spdlog_ex("async log: thread pool doesn't exist anymore");
} }
} }
@ -37,10 +44,10 @@ SPDLOG_LOGGER_CATCH(msg.source)
// send flush request to the thread pool // send flush request to the thread pool
SPDLOG_INLINE void spdlog::async_logger::flush_(){ SPDLOG_INLINE void spdlog::async_logger::flush_(){
SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr->post_flush(shared_from_this(), overflow_policy_); SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){
pool_ptr->post_flush(shared_from_this(), overflow_policy_);
} }
else else {
{
throw_spdlog_ex("async flush: thread pool doesn't exist anymore"); throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
} }
} }
@ -50,40 +57,27 @@ SPDLOG_LOGGER_CATCH(source_loc())
// //
// backend functions - called from the thread pool to do the actual job // backend functions - called from the thread pool to do the actual job
// //
SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) {
{ for (auto &sink : sinks_) {
for (auto &sink : sinks_) if (sink->should_log(msg.level)) {
{ SPDLOG_TRY { sink->log(msg); }
if (sink->should_log(msg.level))
{
SPDLOG_TRY
{
sink->log(msg);
}
SPDLOG_LOGGER_CATCH(msg.source) SPDLOG_LOGGER_CATCH(msg.source)
} }
} }
if (should_flush_(msg)) if (should_flush_(msg)) {
{
backend_flush_(); backend_flush_();
} }
} }
SPDLOG_INLINE void spdlog::async_logger::backend_flush_() SPDLOG_INLINE void spdlog::async_logger::backend_flush_() {
{ for (auto &sink : sinks_) {
for (auto &sink : sinks_) SPDLOG_TRY { sink->flush(); }
{
SPDLOG_TRY
{
sink->flush();
}
SPDLOG_LOGGER_CATCH(source_loc()) SPDLOG_LOGGER_CATCH(source_loc())
} }
} }
SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) {
{
auto cloned = std::make_shared<spdlog::async_logger>(*this); auto cloned = std::make_shared<spdlog::async_logger>(*this);
cloned->name_ = std::move(new_name); cloned->name_ = std::move(new_name);
return cloned; return cloned;

46
Tool/spdlog/include/spdlog/async_logger.h
View File

@ -19,35 +19,41 @@
namespace spdlog { namespace spdlog {
// Async overflow policy - block by default. // Async overflow policy - block by default.
enum class async_overflow_policy enum class async_overflow_policy {
{ block, // Block until message can be enqueued
block, // Block until message can be enqueued overrun_oldest, // Discard oldest message in the queue if full when trying to
overrun_oldest // Discard oldest message in the queue if full when trying to // add new item.
// add new item. discard_new // Discard new message if the queue is full when trying to add new item.
}; };
namespace details { namespace details {
class thread_pool; class thread_pool;
} }
class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, public logger class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>,
{ public logger {
friend class details::thread_pool; friend class details::thread_pool;
public: public:
template<typename It> template <typename It>
async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp, async_logger(std::string logger_name,
async_overflow_policy overflow_policy = async_overflow_policy::block) It begin,
: logger(std::move(logger_name), begin, end) It end,
, thread_pool_(std::move(tp)) std::weak_ptr<details::thread_pool> tp,
, overflow_policy_(overflow_policy) async_overflow_policy overflow_policy = async_overflow_policy::block)
{} : logger(std::move(logger_name), begin, end),
thread_pool_(std::move(tp)),
overflow_policy_(overflow_policy) {}
async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_logger(std::string logger_name,
async_overflow_policy overflow_policy = async_overflow_policy::block); sinks_init_list sinks_list,
std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_logger(std::string logger_name,
async_overflow_policy overflow_policy = async_overflow_policy::block); sink_ptr single_sink,
std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
std::shared_ptr<logger> clone(std::string new_name) override; std::shared_ptr<logger> clone(std::string new_name) override;
@ -61,8 +67,8 @@ private:
std::weak_ptr<details::thread_pool> thread_pool_; std::weak_ptr<details::thread_pool> thread_pool_;
async_overflow_policy overflow_policy_; async_overflow_policy overflow_policy_;
}; };
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "async_logger-inl.h" #include "async_logger-inl.h"
#endif #endif

16
Tool/spdlog/include/spdlog/cfg/argv.h
View File

@ -21,24 +21,20 @@ namespace spdlog {
namespace cfg { namespace cfg {
// search for SPDLOG_LEVEL= in the args and use it to init the levels // search for SPDLOG_LEVEL= in the args and use it to init the levels
inline void load_argv_levels(int argc, const char **argv) inline void load_argv_levels(int argc, const char **argv) {
{
const std::string spdlog_level_prefix = "SPDLOG_LEVEL="; const std::string spdlog_level_prefix = "SPDLOG_LEVEL=";
for (int i = 1; i < argc; i++) for (int i = 1; i < argc; i++) {
{
std::string arg = argv[i]; std::string arg = argv[i];
if (arg.find(spdlog_level_prefix) == 0) if (arg.find(spdlog_level_prefix) == 0) {
{
auto levels_string = arg.substr(spdlog_level_prefix.size()); auto levels_string = arg.substr(spdlog_level_prefix.size());
helpers::load_levels(levels_string); helpers::load_levels(levels_string);
} }
} }
} }
inline void load_argv_levels(int argc, char **argv) inline void load_argv_levels(int argc, char **argv) {
{
load_argv_levels(argc, const_cast<const char **>(argv)); load_argv_levels(argc, const_cast<const char **>(argv));
} }
} // namespace cfg } // namespace cfg
} // namespace spdlog } // namespace spdlog

12
Tool/spdlog/include/spdlog/cfg/env.h
View File

@ -3,8 +3,8 @@
#pragma once #pragma once
#include <spdlog/cfg/helpers.h> #include <spdlog/cfg/helpers.h>
#include <spdlog/details/registry.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <spdlog/details/registry.h>
// //
// Init levels and patterns from env variables SPDLOG_LEVEL // Init levels and patterns from env variables SPDLOG_LEVEL
@ -25,14 +25,12 @@
namespace spdlog { namespace spdlog {
namespace cfg { namespace cfg {
inline void load_env_levels() inline void load_env_levels() {
{
auto env_val = details::os::getenv("SPDLOG_LEVEL"); auto env_val = details::os::getenv("SPDLOG_LEVEL");
if (!env_val.empty()) if (!env_val.empty()) {
{
helpers::load_levels(env_val); helpers::load_levels(env_val);
} }
} }
} // namespace cfg } // namespace cfg
} // namespace spdlog } // namespace spdlog

63
Tool/spdlog/include/spdlog/cfg/helpers-inl.h
View File

@ -4,33 +4,32 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/cfg/helpers.h> #include <spdlog/cfg/helpers.h>
#endif #endif
#include <spdlog/spdlog.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <spdlog/details/registry.h> #include <spdlog/details/registry.h>
#include <spdlog/spdlog.h>
#include <algorithm> #include <algorithm>
#include <sstream>
#include <string> #include <string>
#include <utility> #include <utility>
#include <sstream>
namespace spdlog { namespace spdlog {
namespace cfg { namespace cfg {
namespace helpers { namespace helpers {
// inplace convert to lowercase // inplace convert to lowercase
inline std::string &to_lower_(std::string &str) inline std::string &to_lower_(std::string &str) {
{ std::transform(str.begin(), str.end(), str.begin(), [](char ch) {
std::transform( return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch);
str.begin(), str.end(), str.begin(), [](char ch) { return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); }); });
return str; return str;
} }
// inplace trim spaces // inplace trim spaces
inline std::string &trim_(std::string &str) inline std::string &trim_(std::string &str) {
{
const char *spaces = " \n\r\t"; const char *spaces = " \n\r\t";
str.erase(str.find_last_not_of(spaces) + 1); str.erase(str.find_last_not_of(spaces) + 1);
str.erase(0, str.find_first_not_of(spaces)); str.erase(0, str.find_first_not_of(spaces));
@ -44,16 +43,12 @@ inline std::string &trim_(std::string &str)
// "key=" => ("key", "") // "key=" => ("key", "")
// "val" => ("", "val") // "val" => ("", "val")
inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str) inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str) {
{
auto n = str.find(sep); auto n = str.find(sep);
std::string k, v; std::string k, v;
if (n == std::string::npos) if (n == std::string::npos) {
{
v = str; v = str;
} } else {
else
{
k = str.substr(0, n); k = str.substr(0, n);
v = str.substr(n + 1); v = str.substr(n + 1);
} }
@ -62,15 +57,12 @@ inline std::pair<std::string, std::string> extract_kv_(char sep, const std::stri
// return vector of key/value pairs from sequence of "K1=V1,K2=V2,.." // return vector of key/value pairs from sequence of "K1=V1,K2=V2,.."
// "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...} // "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...}
inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str) inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str) {
{
std::string token; std::string token;
std::istringstream token_stream(str); std::istringstream token_stream(str);
std::unordered_map<std::string, std::string> rv{}; std::unordered_map<std::string, std::string> rv{};
while (std::getline(token_stream, token, ',')) while (std::getline(token_stream, token, ',')) {
{ if (token.empty()) {
if (token.empty())
{
continue; continue;
} }
auto kv = extract_kv_('=', token); auto kv = extract_kv_('=', token);
@ -79,10 +71,8 @@ inline std::unordered_map<std::string, std::string> extract_key_vals_(const std:
return rv; return rv;
} }
SPDLOG_INLINE void load_levels(const std::string &input) SPDLOG_INLINE void load_levels(const std::string &input) {
{ if (input.empty() || input.size() > 512) {
if (input.empty() || input.size() > 512)
{
return; return;
} }
@ -91,30 +81,27 @@ SPDLOG_INLINE void load_levels(const std::string &input)
level::level_enum global_level = level::info; level::level_enum global_level = level::info;
bool global_level_found = false; bool global_level_found = false;
for (auto &name_level : key_vals) for (auto &name_level : key_vals) {
{
auto &logger_name = name_level.first; auto &logger_name = name_level.first;
auto level_name = to_lower_(name_level.second); auto level_name = to_lower_(name_level.second);
auto level = level::from_str(level_name); auto level = level::from_str(level_name);
// ignore unrecognized level names // ignore unrecognized level names
if (level == level::off && level_name != "off") if (level == level::off && level_name != "off") {
{
continue; continue;
} }
if (logger_name.empty()) // no logger name indicate global level if (logger_name.empty()) // no logger name indicate global level
{ {
global_level_found = true; global_level_found = true;
global_level = level; global_level = level;
} } else {
else
{
levels[logger_name] = level; levels[logger_name] = level;
} }
} }
details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr); details::registry::instance().set_levels(std::move(levels),
global_level_found ? &global_level : nullptr);
} }
} // namespace helpers } // namespace helpers
} // namespace cfg } // namespace cfg
} // namespace spdlog } // namespace spdlog

10
Tool/spdlog/include/spdlog/cfg/helpers.h
View File

@ -19,11 +19,11 @@ namespace helpers {
// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
// //
SPDLOG_API void load_levels(const std::string &txt); SPDLOG_API void load_levels(const std::string &txt);
} // namespace helpers } // namespace helpers
} // namespace cfg } // namespace cfg
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "helpers-inl.h" #include "helpers-inl.h"
#endif // SPDLOG_HEADER_ONLY #endif // SPDLOG_HEADER_ONLY

40
Tool/spdlog/include/spdlog/common-inl.h
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/common.h> #include <spdlog/common.h>
#endif #endif
#include <algorithm> #include <algorithm>
@ -20,41 +20,34 @@ constexpr
static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES; static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES;
SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {
{
return level_string_views[l]; return level_string_views[l];
} }
SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {
{
return short_level_names[l]; return short_level_names[l];
} }
SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT {
{
auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name); auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name);
if (it != std::end(level_string_views)) if (it != std::end(level_string_views))
return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it)); return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it));
// check also for "warn" and "err" before giving up.. // check also for "warn" and "err" before giving up..
if (name == "warn") if (name == "warn") {
{
return level::warn; return level::warn;
} }
if (name == "err") if (name == "err") {
{
return level::err; return level::err;
} }
return level::off; return level::off;
} }
} // namespace level } // namespace level
SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)
: msg_(std::move(msg)) : msg_(std::move(msg)) {}
{}
SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) {
{
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what(); msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what();
#else #else
@ -64,19 +57,12 @@ SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
#endif #endif
} }
SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); }
{
return msg_.c_str();
}
SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) {
{
SPDLOG_THROW(spdlog_ex(msg, last_errno)); SPDLOG_THROW(spdlog_ex(msg, last_errno));
} }
SPDLOG_INLINE void throw_spdlog_ex(std::string msg) SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); }
{
SPDLOG_THROW(spdlog_ex(std::move(msg)));
}
} // namespace spdlog } // namespace spdlog

356
Tool/spdlog/include/spdlog/common.h
View File

@ -3,112 +3,121 @@
#pragma once #pragma once
#include <spdlog/tweakme.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/tweakme.h>
#include <atomic> #include <atomic>
#include <chrono> #include <chrono>
#include <cstdio>
#include <exception>
#include <functional>
#include <initializer_list> #include <initializer_list>
#include <memory> #include <memory>
#include <exception>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <functional>
#include <cstdio>
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
# include <version> #include <version>
# if __cpp_lib_format >= 202207L #if __cpp_lib_format >= 202207L
# include <format> #include <format>
# else #else
# include <string_view> #include <string_view>
# endif #endif
#endif #endif
#ifdef SPDLOG_COMPILED_LIB #ifdef SPDLOG_COMPILED_LIB
# undef SPDLOG_HEADER_ONLY #undef SPDLOG_HEADER_ONLY
# if defined(SPDLOG_SHARED_LIB) #if defined(SPDLOG_SHARED_LIB)
# if defined(_WIN32) #if defined(_WIN32)
# ifdef spdlog_EXPORTS #ifdef spdlog_EXPORTS
# define SPDLOG_API __declspec(dllexport) #define SPDLOG_API __declspec(dllexport)
# else // !spdlog_EXPORTS #else // !spdlog_EXPORTS
# define SPDLOG_API __declspec(dllimport) #define SPDLOG_API __declspec(dllimport)
# endif #endif
# else // !defined(_WIN32) #else // !defined(_WIN32)
# define SPDLOG_API __attribute__((visibility("default"))) #define SPDLOG_API __attribute__((visibility("default")))
# endif #endif
# else // !defined(SPDLOG_SHARED_LIB) #else // !defined(SPDLOG_SHARED_LIB)
# define SPDLOG_API #define SPDLOG_API
# endif #endif
# define SPDLOG_INLINE #define SPDLOG_INLINE
#else // !defined(SPDLOG_COMPILED_LIB) #else // !defined(SPDLOG_COMPILED_LIB)
# define SPDLOG_API #define SPDLOG_API
# define SPDLOG_HEADER_ONLY #define SPDLOG_HEADER_ONLY
# define SPDLOG_INLINE inline #define SPDLOG_INLINE inline
#endif // #ifdef SPDLOG_COMPILED_LIB #endif // #ifdef SPDLOG_COMPILED_LIB
#include <spdlog/fmt/fmt.h> #include <spdlog/fmt/fmt.h>
#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 #if !defined(SPDLOG_USE_STD_FORMAT) && \
# define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8
# define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string) #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
# if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
# include <spdlog/fmt/xchar.h> #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
# endif #include <spdlog/fmt/xchar.h>
#endif
#else #else
# define SPDLOG_FMT_RUNTIME(format_string) format_string #define SPDLOG_FMT_RUNTIME(format_string) format_string
# define SPDLOG_FMT_STRING(format_string) format_string #define SPDLOG_FMT_STRING(format_string) format_string
#endif #endif
// visual studio up to 2013 does not support noexcept nor constexpr // visual studio up to 2013 does not support noexcept nor constexpr
#if defined(_MSC_VER) && (_MSC_VER < 1900) #if defined(_MSC_VER) && (_MSC_VER < 1900)
# define SPDLOG_NOEXCEPT _NOEXCEPT #define SPDLOG_NOEXCEPT _NOEXCEPT
# define SPDLOG_CONSTEXPR #define SPDLOG_CONSTEXPR
# define SPDLOG_CONSTEXPR_FUNC inline
#else #else
# define SPDLOG_NOEXCEPT noexcept #define SPDLOG_NOEXCEPT noexcept
# define SPDLOG_CONSTEXPR constexpr #define SPDLOG_CONSTEXPR constexpr
# if __cplusplus >= 201402L #endif
# define SPDLOG_CONSTEXPR_FUNC constexpr
# else // If building with std::format, can just use constexpr, otherwise if building with fmt
# define SPDLOG_CONSTEXPR_FUNC inline // SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to avoid situations where
# endif // a constexpr function in spdlog could end up calling a non-constexpr function in fmt
// depending on the compiler
// If fmt determines it can't use constexpr, we should inline the function instead
#ifdef SPDLOG_USE_STD_FORMAT
#define SPDLOG_CONSTEXPR_FUNC constexpr
#else // Being built with fmt
#if FMT_USE_CONSTEXPR
#define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR
#else
#define SPDLOG_CONSTEXPR_FUNC inline
#endif
#endif #endif
#if defined(__GNUC__) || defined(__clang__) #if defined(__GNUC__) || defined(__clang__)
# define SPDLOG_DEPRECATED __attribute__((deprecated)) #define SPDLOG_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
# define SPDLOG_DEPRECATED __declspec(deprecated) #define SPDLOG_DEPRECATED __declspec(deprecated)
#else #else
# define SPDLOG_DEPRECATED #define SPDLOG_DEPRECATED
#endif #endif
// disable thread local on msvc 2013 // disable thread local on msvc 2013
#ifndef SPDLOG_NO_TLS #ifndef SPDLOG_NO_TLS
# if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
# define SPDLOG_NO_TLS 1 #define SPDLOG_NO_TLS 1
# endif #endif
#endif #endif
#ifndef SPDLOG_FUNCTION #ifndef SPDLOG_FUNCTION
# define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__) #define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
#endif #endif
#ifdef SPDLOG_NO_EXCEPTIONS #ifdef SPDLOG_NO_EXCEPTIONS
# define SPDLOG_TRY #define SPDLOG_TRY
# define SPDLOG_THROW(ex) \ #define SPDLOG_THROW(ex) \
do \ do { \
{ \ printf("spdlog fatal error: %s\n", ex.what()); \
printf("spdlog fatal error: %s\n", ex.what()); \ std::abort(); \
std::abort(); \
} while (0) } while (0)
# define SPDLOG_CATCH_STD #define SPDLOG_CATCH_STD
#else #else
# define SPDLOG_TRY try #define SPDLOG_TRY try
# define SPDLOG_THROW(ex) throw(ex) #define SPDLOG_THROW(ex) throw(ex)
# define SPDLOG_CATCH_STD \ #define SPDLOG_CATCH_STD \
catch (const std::exception &) \ catch (const std::exception &) { \
{} }
#endif #endif
namespace spdlog { namespace spdlog {
@ -121,12 +130,12 @@ class sink;
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
using filename_t = std::wstring; using filename_t = std::wstring;
// allow macro expansion to occur in SPDLOG_FILENAME_T // allow macro expansion to occur in SPDLOG_FILENAME_T
# define SPDLOG_FILENAME_T_INNER(s) L##s #define SPDLOG_FILENAME_T_INNER(s) L##s
# define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s) #define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
#else #else
using filename_t = std::string; using filename_t = std::string;
# define SPDLOG_FILENAME_T(s) s #define SPDLOG_FILENAME_T(s) s
#endif #endif
using log_clock = std::chrono::system_clock; using log_clock = std::chrono::system_clock;
@ -139,76 +148,79 @@ namespace fmt_lib = std;
using string_view_t = std::string_view; using string_view_t = std::string_view;
using memory_buf_t = std::string; using memory_buf_t = std::string;
template<typename... Args> template <typename... Args>
# if __cpp_lib_format >= 202207L #if __cpp_lib_format >= 202207L
using format_string_t = std::format_string<Args...>; using format_string_t = std::format_string<Args...>;
# else #else
using format_string_t = std::string_view; using format_string_t = std::string_view;
# endif #endif
template<class T, class Char = char> template <class T, class Char = char>
struct is_convertible_to_basic_format_string : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value> struct is_convertible_to_basic_format_string
{}; : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value> {};
# if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
using wstring_view_t = std::wstring_view; using wstring_view_t = std::wstring_view;
using wmemory_buf_t = std::wstring; using wmemory_buf_t = std::wstring;
template<typename... Args> template <typename... Args>
# if __cpp_lib_format >= 202207L #if __cpp_lib_format >= 202207L
using wformat_string_t = std::wformat_string<Args...>; using wformat_string_t = std::wformat_string<Args...>;
# else #else
using wformat_string_t = std::wstring_view; using wformat_string_t = std::wstring_view;
# endif #endif
# endif #endif
# define SPDLOG_BUF_TO_STRING(x) x #define SPDLOG_BUF_TO_STRING(x) x
#else // use fmt lib instead of std::format #else // use fmt lib instead of std::format
namespace fmt_lib = fmt; namespace fmt_lib = fmt;
using string_view_t = fmt::basic_string_view<char>; using string_view_t = fmt::basic_string_view<char>;
using memory_buf_t = fmt::basic_memory_buffer<char, 250>; using memory_buf_t = fmt::basic_memory_buffer<char, 250>;
template<typename... Args> template <typename... Args>
using format_string_t = fmt::format_string<Args...>; using format_string_t = fmt::format_string<Args...>;
template<class T> template <class T>
using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type; using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
template<typename Char> template <typename Char>
# if FMT_VERSION >= 90101 #if FMT_VERSION >= 90101
using fmt_runtime_string = fmt::runtime_format_string<Char>; using fmt_runtime_string = fmt::runtime_format_string<Char>;
# else #else
using fmt_runtime_string = fmt::basic_runtime<Char>; using fmt_runtime_string = fmt::basic_runtime<Char>;
# endif #endif
// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from basic_format_string here, // clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the
// in addition, fmt::basic_runtime<Char> is only convertible to basic_format_string<Char> but not basic_string_view<Char> // condition from basic_format_string here, in addition, fmt::basic_runtime<Char> is only
template<class T, class Char = char> // convertible to basic_format_string<Char> but not basic_string_view<Char>
template <class T, class Char = char>
struct is_convertible_to_basic_format_string struct is_convertible_to_basic_format_string
: std::integral_constant<bool, : std::integral_constant<bool,
std::is_convertible<T, fmt::basic_string_view<Char>>::value || std::is_same<remove_cvref_t<T>, fmt_runtime_string<Char>>::value> std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
{}; std::is_same<remove_cvref_t<T>, fmt_runtime_string<Char>>::value> {
};
# if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
using wstring_view_t = fmt::basic_string_view<wchar_t>; using wstring_view_t = fmt::basic_string_view<wchar_t>;
using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>; using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
template<typename... Args> template <typename... Args>
using wformat_string_t = fmt::wformat_string<Args...>; using wformat_string_t = fmt::wformat_string<Args...>;
# endif #endif
# define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
#endif #endif
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
# ifndef _WIN32 #ifndef _WIN32
# error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
# endif // _WIN32 #endif // _WIN32
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<class T> template <class T>
struct is_convertible_to_any_format_string : std::integral_constant<bool, is_convertible_to_basic_format_string<T, char>::value || struct is_convertible_to_any_format_string
is_convertible_to_basic_format_string<T, wchar_t>::value> : std::integral_constant<bool,
{}; is_convertible_to_basic_format_string<T, char>::value ||
is_convertible_to_basic_format_string<T, wchar_t>::value> {};
#if defined(SPDLOG_NO_ATOMIC_LEVELS) #if defined(SPDLOG_NO_ATOMIC_LEVELS)
using level_t = details::null_atomic_int; using level_t = details::null_atomic_int;
@ -225,13 +237,12 @@ using level_t = std::atomic<int>;
#define SPDLOG_LEVEL_OFF 6 #define SPDLOG_LEVEL_OFF 6
#if !defined(SPDLOG_ACTIVE_LEVEL) #if !defined(SPDLOG_ACTIVE_LEVEL)
# define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
#endif #endif
// Log level enum // Log level enum
namespace level { namespace level {
enum level_enum : int enum level_enum : int {
{
trace = SPDLOG_LEVEL_TRACE, trace = SPDLOG_LEVEL_TRACE,
debug = SPDLOG_LEVEL_DEBUG, debug = SPDLOG_LEVEL_DEBUG,
info = SPDLOG_LEVEL_INFO, info = SPDLOG_LEVEL_INFO,
@ -251,52 +262,44 @@ enum level_enum : int
#define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3) #define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3)
#if !defined(SPDLOG_LEVEL_NAMES) #if !defined(SPDLOG_LEVEL_NAMES)
# define SPDLOG_LEVEL_NAMES \ #define SPDLOG_LEVEL_NAMES \
{ \ { \
SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, \ SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, \
SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF \ SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \
SPDLOG_LEVEL_NAME_OFF \
} }
#endif #endif
#if !defined(SPDLOG_SHORT_LEVEL_NAMES) #if !defined(SPDLOG_SHORT_LEVEL_NAMES)
# define SPDLOG_SHORT_LEVEL_NAMES \ #define SPDLOG_SHORT_LEVEL_NAMES \
{ \ { "T", "D", "I", "W", "E", "C", "O" }
"T", "D", "I", "W", "E", "C", "O" \
}
#endif #endif
SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT; SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
} // namespace level } // namespace level
// //
// Color mode used by sinks with color support. // Color mode used by sinks with color support.
// //
enum class color_mode enum class color_mode { always, automatic, never };
{
always,
automatic,
never
};
// //
// Pattern time - specific time getting to use for pattern_formatter. // Pattern time - specific time getting to use for pattern_formatter.
// local time by default // local time by default
// //
enum class pattern_time_type enum class pattern_time_type {
{ local, // log localtime
local, // log localtime utc // log utc
utc // log utc
}; };
// //
// Log exception // Log exception
// //
class SPDLOG_API spdlog_ex : public std::exception class SPDLOG_API spdlog_ex : public std::exception {
{
public: public:
explicit spdlog_ex(std::string msg); explicit spdlog_ex(std::string msg);
spdlog_ex(const std::string &msg, int last_errno); spdlog_ex(const std::string &msg, int last_errno);
@ -309,32 +312,25 @@ private:
[[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno); [[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno);
[[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg); [[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg);
struct source_loc struct source_loc {
{
SPDLOG_CONSTEXPR source_loc() = default; SPDLOG_CONSTEXPR source_loc() = default;
SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in) SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in)
: filename{filename_in} : filename{filename_in},
, line{line_in} line{line_in},
, funcname{funcname_in} funcname{funcname_in} {}
{}
SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; }
{
return line == 0;
}
const char *filename{nullptr}; const char *filename{nullptr};
int line{0}; int line{0};
const char *funcname{nullptr}; const char *funcname{nullptr};
}; };
struct file_event_handlers struct file_event_handlers {
{
file_event_handlers() file_event_handlers()
: before_open(nullptr) : before_open(nullptr),
, after_open(nullptr) after_open(nullptr),
, before_close(nullptr) before_close(nullptr),
, after_close(nullptr) after_close(nullptr) {}
{}
std::function<void(const filename_t &filename)> before_open; std::function<void(const filename_t &filename)> before_open;
std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open; std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open;
@ -346,75 +342,77 @@ namespace details {
// to_string_view // to_string_view
SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf)
{ SPDLOG_NOEXCEPT {
return spdlog::string_view_t{buf.data(), buf.size()}; return spdlog::string_view_t{buf.data(), buf.size()};
} }
SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str) SPDLOG_NOEXCEPT SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str)
{ SPDLOG_NOEXCEPT {
return str; return str;
} }
#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) SPDLOG_NOEXCEPT SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf)
{ SPDLOG_NOEXCEPT {
return spdlog::wstring_view_t{buf.data(), buf.size()}; return spdlog::wstring_view_t{buf.data(), buf.size()};
} }
SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) SPDLOG_NOEXCEPT SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str)
{ SPDLOG_NOEXCEPT {
return str; return str;
} }
#endif #endif
#ifndef SPDLOG_USE_STD_FORMAT #ifndef SPDLOG_USE_STD_FORMAT
template<typename T, typename... Args> #if FMT_VERSION >= 110100
inline fmt::basic_string_view<T> to_string_view(fmt::basic_format_string<T, Args...> fmt) template <typename T, typename... Args>
{ inline fmt::basic_string_view<T> to_string_view(fmt::basic_format_arg<T> fmt) {
return fmt; return fmt;
} }
#else
template <typename T, typename... Args>
inline fmt::basic_string_view<T> to_string_view(fmt::basic_format_string<T, Args...> fmt) {
return fmt;
}
#endif
#elif __cpp_lib_format >= 202207L #elif __cpp_lib_format >= 202207L
template<typename T, typename... Args> template <typename T, typename... Args>
SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(
{ std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT {
return fmt.get(); return fmt.get();
} }
#endif #endif
// make_unique support for pre c++14 // make_unique support for pre c++14
#if __cplusplus >= 201402L // C++14 and beyond
#if __cplusplus >= 201402L // C++14 and beyond
using std::enable_if_t; using std::enable_if_t;
using std::make_unique; using std::make_unique;
#else #else
template<bool B, class T = void> template <bool B, class T = void>
using enable_if_t = typename std::enable_if<B, T>::type; using enable_if_t = typename std::enable_if<B, T>::type;
template<typename T, typename... Args> template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&...args) std::unique_ptr<T> make_unique(Args &&...args) {
{
static_assert(!std::is_array<T>::value, "arrays not supported"); static_assert(!std::is_array<T>::value, "arrays not supported");
return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
} }
#endif #endif
// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324) // to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
template<typename T, typename U, enable_if_t<!std::is_same<T, U>::value, int> = 0> template <typename T, typename U, enable_if_t<!std::is_same<T, U>::value, int> = 0>
constexpr T conditional_static_cast(U value) constexpr T conditional_static_cast(U value) {
{
return static_cast<T>(value); return static_cast<T>(value);
} }
template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0> template <typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
constexpr T conditional_static_cast(U value) constexpr T conditional_static_cast(U value) {
{
return value; return value;
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "common-inl.h" #include "common-inl.h"
#endif #endif

38
Tool/spdlog/include/spdlog/details/backtracer-inl.h
View File

@ -4,72 +4,60 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/details/backtracer.h> #include <spdlog/details/backtracer.h>
#endif #endif
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE backtracer::backtracer(const backtracer &other) SPDLOG_INLINE backtracer::backtracer(const backtracer &other) {
{
std::lock_guard<std::mutex> lock(other.mutex_); std::lock_guard<std::mutex> lock(other.mutex_);
enabled_ = other.enabled(); enabled_ = other.enabled();
messages_ = other.messages_; messages_ = other.messages_;
} }
SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT {
{
std::lock_guard<std::mutex> lock(other.mutex_); std::lock_guard<std::mutex> lock(other.mutex_);
enabled_ = other.enabled(); enabled_ = other.enabled();
messages_ = std::move(other.messages_); messages_ = std::move(other.messages_);
} }
SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) {
{
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
enabled_ = other.enabled(); enabled_ = other.enabled();
messages_ = std::move(other.messages_); messages_ = std::move(other.messages_);
return *this; return *this;
} }
SPDLOG_INLINE void backtracer::enable(size_t size) SPDLOG_INLINE void backtracer::enable(size_t size) {
{
std::lock_guard<std::mutex> lock{mutex_}; std::lock_guard<std::mutex> lock{mutex_};
enabled_.store(true, std::memory_order_relaxed); enabled_.store(true, std::memory_order_relaxed);
messages_ = circular_q<log_msg_buffer>{size}; messages_ = circular_q<log_msg_buffer>{size};
} }
SPDLOG_INLINE void backtracer::disable() SPDLOG_INLINE void backtracer::disable() {
{
std::lock_guard<std::mutex> lock{mutex_}; std::lock_guard<std::mutex> lock{mutex_};
enabled_.store(false, std::memory_order_relaxed); enabled_.store(false, std::memory_order_relaxed);
} }
SPDLOG_INLINE bool backtracer::enabled() const SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); }
{
return enabled_.load(std::memory_order_relaxed);
}
SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) {
{
std::lock_guard<std::mutex> lock{mutex_}; std::lock_guard<std::mutex> lock{mutex_};
messages_.push_back(log_msg_buffer{msg}); messages_.push_back(log_msg_buffer{msg});
} }
SPDLOG_INLINE bool backtracer::empty() const SPDLOG_INLINE bool backtracer::empty() const {
{
std::lock_guard<std::mutex> lock{mutex_}; std::lock_guard<std::mutex> lock{mutex_};
return messages_.empty(); return messages_.empty();
} }
// pop all items in the q and apply the given fun on each of them. // pop all items in the q and apply the given fun on each of them.
SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun) SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun) {
{
std::lock_guard<std::mutex> lock{mutex_}; std::lock_guard<std::mutex> lock{mutex_};
while (!messages_.empty()) while (!messages_.empty()) {
{
auto &front_msg = messages_.front(); auto &front_msg = messages_.front();
fun(front_msg); fun(front_msg);
messages_.pop_front(); messages_.pop_front();
} }
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

13
Tool/spdlog/include/spdlog/details/backtracer.h
View File

@ -3,20 +3,19 @@
#pragma once #pragma once
#include <spdlog/details/log_msg_buffer.h>
#include <spdlog/details/circular_q.h> #include <spdlog/details/circular_q.h>
#include <spdlog/details/log_msg_buffer.h>
#include <atomic> #include <atomic>
#include <mutex>
#include <functional> #include <functional>
#include <mutex>
// Store log messages in circular buffer. // Store log messages in circular buffer.
// Useful for storing debug data in case of error/warning happens. // Useful for storing debug data in case of error/warning happens.
namespace spdlog { namespace spdlog {
namespace details { namespace details {
class SPDLOG_API backtracer class SPDLOG_API backtracer {
{
mutable std::mutex mutex_; mutable std::mutex mutex_;
std::atomic<bool> enabled_{false}; std::atomic<bool> enabled_{false};
circular_q<log_msg_buffer> messages_; circular_q<log_msg_buffer> messages_;
@ -38,9 +37,9 @@ public:
void foreach_pop(std::function<void(const details::log_msg &)> fun); void foreach_pop(std::function<void(const details::log_msg &)> fun);
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "backtracer-inl.h" #include "backtracer-inl.h"
#endif #endif

87
Tool/spdlog/include/spdlog/details/circular_q.h
View File

@ -4,14 +4,15 @@
// circular q view of std::vector. // circular q view of std::vector.
#pragma once #pragma once
#include <vector>
#include <cassert> #include <cassert>
#include <vector>
#include "spdlog/common.h"
namespace spdlog { namespace spdlog {
namespace details { namespace details {
template<typename T> template <typename T>
class circular_q class circular_q {
{
size_t max_items_ = 0; size_t max_items_ = 0;
typename std::vector<T>::size_type head_ = 0; typename std::vector<T>::size_type head_ = 0;
typename std::vector<T>::size_type tail_ = 0; typename std::vector<T>::size_type tail_ = 0;
@ -25,35 +26,29 @@ public:
circular_q() = default; circular_q() = default;
explicit circular_q(size_t max_items) explicit circular_q(size_t max_items)
: max_items_(max_items + 1) // one item is reserved as marker for full q : max_items_(max_items + 1) // one item is reserved as marker for full q
, v_(max_items_) ,
{} v_(max_items_) {}
circular_q(const circular_q &) = default; circular_q(const circular_q &) = default;
circular_q &operator=(const circular_q &) = default; circular_q &operator=(const circular_q &) = default;
// move cannot be default, // move cannot be default,
// since we need to reset head_, tail_, etc to zero in the moved object // since we need to reset head_, tail_, etc to zero in the moved object
circular_q(circular_q &&other) SPDLOG_NOEXCEPT circular_q(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); }
{
copy_moveable(std::move(other));
}
circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT {
{
copy_moveable(std::move(other)); copy_moveable(std::move(other));
return *this; return *this;
} }
// push back, overrun (oldest) item if no room left // push back, overrun (oldest) item if no room left
void push_back(T &&item) void push_back(T &&item) {
{ if (max_items_ > 0) {
if (max_items_ > 0)
{
v_[tail_] = std::move(item); v_[tail_] = std::move(item);
tail_ = (tail_ + 1) % max_items_; tail_ = (tail_ + 1) % max_items_;
if (tail_ == head_) // overrun last item if full if (tail_ == head_) // overrun last item if full
{ {
head_ = (head_ + 1) % max_items_; head_ = (head_ + 1) % max_items_;
++overrun_counter_; ++overrun_counter_;
@ -63,73 +58,47 @@ public:
// Return reference to the front item. // Return reference to the front item.
// If there are no elements in the container, the behavior is undefined. // If there are no elements in the container, the behavior is undefined.
const T &front() const const T &front() const { return v_[head_]; }
{
return v_[head_];
}
T &front() T &front() { return v_[head_]; }
{
return v_[head_];
}
// Return number of elements actually stored // Return number of elements actually stored
size_t size() const size_t size() const {
{ if (tail_ >= head_) {
if (tail_ >= head_)
{
return tail_ - head_; return tail_ - head_;
} } else {
else
{
return max_items_ - (head_ - tail_); return max_items_ - (head_ - tail_);
} }
} }
// Return const reference to item by index. // Return const reference to item by index.
// If index is out of range 0…size()-1, the behavior is undefined. // If index is out of range 0…size()-1, the behavior is undefined.
const T &at(size_t i) const const T &at(size_t i) const {
{
assert(i < size()); assert(i < size());
return v_[(head_ + i) % max_items_]; return v_[(head_ + i) % max_items_];
} }
// Pop item from front. // Pop item from front.
// If there are no elements in the container, the behavior is undefined. // If there are no elements in the container, the behavior is undefined.
void pop_front() void pop_front() { head_ = (head_ + 1) % max_items_; }
{
head_ = (head_ + 1) % max_items_;
}
bool empty() const bool empty() const { return tail_ == head_; }
{
return tail_ == head_;
}
bool full() const bool full() const {
{
// head is ahead of the tail by 1 // head is ahead of the tail by 1
if (max_items_ > 0) if (max_items_ > 0) {
{
return ((tail_ + 1) % max_items_) == head_; return ((tail_ + 1) % max_items_) == head_;
} }
return false; return false;
} }
size_t overrun_counter() const size_t overrun_counter() const { return overrun_counter_; }
{
return overrun_counter_;
}
void reset_overrun_counter() void reset_overrun_counter() { overrun_counter_ = 0; }
{
overrun_counter_ = 0;
}
private: private:
// copy from other&& and reset it to disabled state // copy from other&& and reset it to disabled state
void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT {
{
max_items_ = other.max_items_; max_items_ = other.max_items_;
head_ = other.head_; head_ = other.head_;
tail_ = other.tail_; tail_ = other.tail_;
@ -142,5 +111,5 @@ private:
other.overrun_counter_ = 0; other.overrun_counter_ = 0;
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

18
Tool/spdlog/include/spdlog/details/console_globals.h
View File

@ -3,30 +3,26 @@
#pragma once #pragma once
#include <spdlog/details/null_mutex.h>
#include <mutex> #include <mutex>
#include <spdlog/details/null_mutex.h>
namespace spdlog { namespace spdlog {
namespace details { namespace details {
struct console_mutex struct console_mutex {
{
using mutex_t = std::mutex; using mutex_t = std::mutex;
static mutex_t &mutex() static mutex_t &mutex() {
{
static mutex_t s_mutex; static mutex_t s_mutex;
return s_mutex; return s_mutex;
} }
}; };
struct console_nullmutex struct console_nullmutex {
{
using mutex_t = null_mutex; using mutex_t = null_mutex;
static mutex_t &mutex() static mutex_t &mutex() {
{
static mutex_t s_mutex; static mutex_t s_mutex;
return s_mutex; return s_mutex;
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

99
Tool/spdlog/include/spdlog/details/file_helper-inl.h
View File

@ -4,11 +4,11 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/details/file_helper.h> #include <spdlog/details/file_helper.h>
#endif #endif
#include <spdlog/details/os.h>
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/os.h>
#include <cerrno> #include <cerrno>
#include <chrono> #include <chrono>
@ -21,47 +21,36 @@ namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers) SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers)
: event_handlers_(event_handlers) : event_handlers_(event_handlers) {}
{}
SPDLOG_INLINE file_helper::~file_helper() SPDLOG_INLINE file_helper::~file_helper() { close(); }
{
close();
}
SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) {
{
close(); close();
filename_ = fname; filename_ = fname;
auto *mode = SPDLOG_FILENAME_T("ab"); auto *mode = SPDLOG_FILENAME_T("ab");
auto *trunc_mode = SPDLOG_FILENAME_T("wb"); auto *trunc_mode = SPDLOG_FILENAME_T("wb");
if (event_handlers_.before_open) if (event_handlers_.before_open) {
{
event_handlers_.before_open(filename_); event_handlers_.before_open(filename_);
} }
for (int tries = 0; tries < open_tries_; ++tries) for (int tries = 0; tries < open_tries_; ++tries) {
{
// create containing folder if not exists already. // create containing folder if not exists already.
os::create_dir(os::dir_name(fname)); os::create_dir(os::dir_name(fname));
if (truncate) if (truncate) {
{
// Truncate by opening-and-closing a tmp file in "wb" mode, always // Truncate by opening-and-closing a tmp file in "wb" mode, always
// opening the actual log-we-write-to in "ab" mode, since that // opening the actual log-we-write-to in "ab" mode, since that
// interacts more politely with eternal processes that might // interacts more politely with eternal processes that might
// rotate/truncate the file underneath us. // rotate/truncate the file underneath us.
std::FILE *tmp; std::FILE *tmp;
if (os::fopen_s(&tmp, fname, trunc_mode)) if (os::fopen_s(&tmp, fname, trunc_mode)) {
{
continue; continue;
} }
std::fclose(tmp); std::fclose(tmp);
} }
if (!os::fopen_s(&fd_, fname, mode)) if (!os::fopen_s(&fd_, fname, mode)) {
{ if (event_handlers_.after_open) {
if (event_handlers_.after_open)
{
event_handlers_.after_open(filename_, fd_); event_handlers_.after_open(filename_, fd_);
} }
return; return;
@ -70,76 +59,62 @@ SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
details::os::sleep_for_millis(open_interval_); details::os::sleep_for_millis(open_interval_);
} }
throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno); throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing",
errno);
} }
SPDLOG_INLINE void file_helper::reopen(bool truncate) SPDLOG_INLINE void file_helper::reopen(bool truncate) {
{ if (filename_.empty()) {
if (filename_.empty())
{
throw_spdlog_ex("Failed re opening file - was not opened before"); throw_spdlog_ex("Failed re opening file - was not opened before");
} }
this->open(filename_, truncate); this->open(filename_, truncate);
} }
SPDLOG_INLINE void file_helper::flush() SPDLOG_INLINE void file_helper::flush() {
{ if (std::fflush(fd_) != 0) {
if (std::fflush(fd_) != 0)
{
throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno); throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno);
} }
} }
SPDLOG_INLINE void file_helper::sync() SPDLOG_INLINE void file_helper::sync() {
{ if (!os::fsync(fd_)) {
if (!os::fsync(fd_))
{
throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno); throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno);
} }
} }
SPDLOG_INLINE void file_helper::close() SPDLOG_INLINE void file_helper::close() {
{ if (fd_ != nullptr) {
if (fd_ != nullptr) if (event_handlers_.before_close) {
{
if (event_handlers_.before_close)
{
event_handlers_.before_close(filename_, fd_); event_handlers_.before_close(filename_, fd_);
} }
std::fclose(fd_); std::fclose(fd_);
fd_ = nullptr; fd_ = nullptr;
if (event_handlers_.after_close) if (event_handlers_.after_close) {
{
event_handlers_.after_close(filename_); event_handlers_.after_close(filename_);
} }
} }
} }
SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) {
{ if (fd_ == nullptr) return;
size_t msg_size = buf.size(); size_t msg_size = buf.size();
auto data = buf.data(); auto data = buf.data();
if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
{ if (!details::os::fwrite_bytes(data, msg_size, fd_)) {
throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno); throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
} }
} }
SPDLOG_INLINE size_t file_helper::size() const SPDLOG_INLINE size_t file_helper::size() const {
{ if (fd_ == nullptr) {
if (fd_ == nullptr)
{
throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_)); throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_));
} }
return os::filesize(fd_); return os::filesize(fd_);
} }
SPDLOG_INLINE const filename_t &file_helper::filename() const SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_; }
{
return filename_;
}
// //
// return file path and its extension: // return file path and its extension:
@ -154,21 +129,19 @@ SPDLOG_INLINE const filename_t &file_helper::filename() const
// ".mylog" => (".mylog". "") // ".mylog" => (".mylog". "")
// "my_folder/.mylog" => ("my_folder/.mylog", "") // "my_folder/.mylog" => ("my_folder/.mylog", "")
// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname) SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(
{ const filename_t &fname) {
auto ext_index = fname.rfind('.'); auto ext_index = fname.rfind('.');
// no valid extension found - return whole path and empty string as // no valid extension found - return whole path and empty string as
// extension // extension
if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) {
{
return std::make_tuple(fname, filename_t()); return std::make_tuple(fname, filename_t());
} }
// treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile" // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
auto folder_index = fname.find_last_of(details::os::folder_seps_filename); auto folder_index = fname.find_last_of(details::os::folder_seps_filename);
if (folder_index != filename_t::npos && folder_index >= ext_index - 1) if (folder_index != filename_t::npos && folder_index >= ext_index - 1) {
{
return std::make_tuple(fname, filename_t()); return std::make_tuple(fname, filename_t());
} }
@ -176,5 +149,5 @@ SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension
return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

9
Tool/spdlog/include/spdlog/details/file_helper.h
View File

@ -13,8 +13,7 @@ namespace details {
// When failing to open a file, retry several times(5) with a delay interval(10 ms). // When failing to open a file, retry several times(5) with a delay interval(10 ms).
// Throw spdlog_ex exception on errors. // Throw spdlog_ex exception on errors.
class SPDLOG_API file_helper class SPDLOG_API file_helper {
{
public: public:
file_helper() = default; file_helper() = default;
explicit file_helper(const file_event_handlers &event_handlers); explicit file_helper(const file_event_handlers &event_handlers);
@ -54,9 +53,9 @@ private:
filename_t filename_; filename_t filename_;
file_event_handlers event_handlers_; file_event_handlers event_handlers_;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "file_helper-inl.h" #include "file_helper-inl.h"
#endif #endif

121
Tool/spdlog/include/spdlog/details/fmt_helper.h
View File

@ -3,14 +3,14 @@
#pragma once #pragma once
#include <chrono> #include <chrono>
#include <type_traits>
#include <iterator> #include <iterator>
#include <spdlog/fmt/fmt.h>
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/fmt/fmt.h>
#include <type_traits>
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
# include <charconv> #include <charconv>
# include <limits> #include <limits>
#endif #endif
// Some fmt helpers to efficiently format and pad ints and strings // Some fmt helpers to efficiently format and pad ints and strings
@ -18,140 +18,117 @@ namespace spdlog {
namespace details { namespace details {
namespace fmt_helper { namespace fmt_helper {
inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) {
{
auto *buf_ptr = view.data(); auto *buf_ptr = view.data();
dest.append(buf_ptr, buf_ptr + view.size()); dest.append(buf_ptr, buf_ptr + view.size());
} }
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
template<typename T> template <typename T>
inline void append_int(T n, memory_buf_t &dest) inline void append_int(T n, memory_buf_t &dest) {
{
// Buffer should be large enough to hold all digits (digits10 + 1) and a sign // Buffer should be large enough to hold all digits (digits10 + 1) and a sign
SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits<T>::digits10 + 2; SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits<T>::digits10 + 2;
char buf[BUF_SIZE]; char buf[BUF_SIZE];
auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10); auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10);
if (ec == std::errc()) if (ec == std::errc()) {
{
dest.append(buf, ptr); dest.append(buf, ptr);
} } else {
else
{
throw_spdlog_ex("Failed to format int", static_cast<int>(ec)); throw_spdlog_ex("Failed to format int", static_cast<int>(ec));
} }
} }
#else #else
template<typename T> template <typename T>
inline void append_int(T n, memory_buf_t &dest) inline void append_int(T n, memory_buf_t &dest) {
{
fmt::format_int i(n); fmt::format_int i(n);
dest.append(i.data(), i.data() + i.size()); dest.append(i.data(), i.data() + i.size());
} }
#endif #endif
template<typename T> template <typename T>
SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) {
{
// taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912 // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912
unsigned int count = 1; unsigned int count = 1;
for (;;) for (;;) {
{
// Integer division is slow so do it for a group of four digits instead // 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 // of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison. // "Three Optimization Tips for C++". See speed-test for a comparison.
if (n < 10) if (n < 10) return count;
return count; if (n < 100) return count + 1;
if (n < 100) if (n < 1000) return count + 2;
return count + 1; if (n < 10000) return count + 3;
if (n < 1000)
return count + 2;
if (n < 10000)
return count + 3;
n /= 10000u; n /= 10000u;
count += 4; count += 4;
} }
} }
template<typename T> template <typename T>
inline unsigned int count_digits(T n) inline unsigned int count_digits(T n) {
{ using count_type =
using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type; typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
return count_digits_fallback(static_cast<count_type>(n)); return count_digits_fallback(static_cast<count_type>(n));
#else #else
return static_cast<unsigned int>(fmt:: return static_cast<unsigned int>(fmt::
// fmt 7.0.0 renamed the internal namespace to detail. // fmt 7.0.0 renamed the internal namespace to detail.
// See: https://github.com/fmtlib/fmt/issues/1538 // See: https://github.com/fmtlib/fmt/issues/1538
# if FMT_VERSION < 70000 #if FMT_VERSION < 70000
internal internal
# else #else
detail detail
# endif #endif
::count_digits(static_cast<count_type>(n))); ::count_digits(static_cast<count_type>(n)));
#endif #endif
} }
inline void pad2(int n, memory_buf_t &dest) inline void pad2(int n, memory_buf_t &dest) {
{ if (n >= 0 && n < 100) // 0-99
if (n >= 0 && n < 100) // 0-99
{ {
dest.push_back(static_cast<char>('0' + n / 10)); dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10)); dest.push_back(static_cast<char>('0' + n % 10));
} } else // unlikely, but just in case, let fmt deal with it
else // unlikely, but just in case, let fmt deal with it
{ {
fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n); fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n);
} }
} }
template<typename T> template <typename T>
inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) {
{
static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T"); static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
for (auto digits = count_digits(n); digits < width; digits++) for (auto digits = count_digits(n); digits < width; digits++) {
{
dest.push_back('0'); dest.push_back('0');
} }
append_int(n, dest); append_int(n, dest);
} }
template<typename T> template <typename T>
inline void pad3(T n, memory_buf_t &dest) inline void pad3(T n, memory_buf_t &dest) {
{
static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T"); static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
if (n < 1000) if (n < 1000) {
{
dest.push_back(static_cast<char>(n / 100 + '0')); dest.push_back(static_cast<char>(n / 100 + '0'));
n = n % 100; n = n % 100;
dest.push_back(static_cast<char>((n / 10) + '0')); dest.push_back(static_cast<char>((n / 10) + '0'));
dest.push_back(static_cast<char>((n % 10) + '0')); dest.push_back(static_cast<char>((n % 10) + '0'));
} } else {
else
{
append_int(n, dest); append_int(n, dest);
} }
} }
template<typename T> template <typename T>
inline void pad6(T n, memory_buf_t &dest) inline void pad6(T n, memory_buf_t &dest) {
{
pad_uint(n, 6, dest); pad_uint(n, 6, dest);
} }
template<typename T> template <typename T>
inline void pad9(T n, memory_buf_t &dest) inline void pad9(T n, memory_buf_t &dest) {
{
pad_uint(n, 9, dest); pad_uint(n, 9, dest);
} }
// return fraction of a second of the given time_point. // return fraction of a second of the given time_point.
// e.g. // e.g.
// fraction<std::milliseconds>(tp) -> will return the millis part of the second // fraction<std::milliseconds>(tp) -> will return the millis part of the second
template<typename ToDuration> template <typename ToDuration>
inline ToDuration time_fraction(log_clock::time_point tp) inline ToDuration time_fraction(log_clock::time_point tp) {
{
using std::chrono::duration_cast; using std::chrono::duration_cast;
using std::chrono::seconds; using std::chrono::seconds;
auto duration = tp.time_since_epoch(); auto duration = tp.time_since_epoch();
@ -159,6 +136,6 @@ inline ToDuration time_fraction(log_clock::time_point tp)
return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs); return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
} }
} // namespace fmt_helper } // namespace fmt_helper
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

45
Tool/spdlog/include/spdlog/details/log_msg-inl.h
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/details/log_msg.h> #include <spdlog/details/log_msg.h>
#endif #endif
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
@ -12,26 +12,33 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time,
spdlog::level::level_enum lvl, spdlog::string_view_t msg) spdlog::source_loc loc,
: logger_name(a_logger_name) string_view_t a_logger_name,
, level(lvl) spdlog::level::level_enum lvl,
, time(log_time) spdlog::string_view_t msg)
: logger_name(a_logger_name),
level(lvl),
time(log_time)
#ifndef SPDLOG_NO_THREAD_ID #ifndef SPDLOG_NO_THREAD_ID
, thread_id(os::thread_id()) ,
thread_id(os::thread_id())
#endif #endif
, source(loc) ,
, payload(msg) source(loc),
{} payload(msg) {
}
SPDLOG_INLINE log_msg::log_msg( SPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc,
spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) string_view_t a_logger_name,
: log_msg(os::now(), loc, a_logger_name, lvl, msg) spdlog::level::level_enum lvl,
{} spdlog::string_view_t msg)
: log_msg(os::now(), loc, a_logger_name, lvl, msg) {}
SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name,
: log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) spdlog::level::level_enum lvl,
{} spdlog::string_view_t msg)
: log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {}
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

15
Tool/spdlog/include/spdlog/details/log_msg.h
View File

@ -8,10 +8,13 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
struct SPDLOG_API log_msg struct SPDLOG_API log_msg {
{
log_msg() = default; log_msg() = default;
log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); log_msg(log_clock::time_point log_time,
source_loc loc,
string_view_t logger_name,
level::level_enum lvl,
string_view_t msg);
log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg); log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);
log_msg(const log_msg &other) = default; log_msg(const log_msg &other) = default;
@ -29,9 +32,9 @@ struct SPDLOG_API log_msg
source_loc source; source_loc source;
string_view_t payload; string_view_t payload;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "log_msg-inl.h" #include "log_msg-inl.h"
#endif #endif

26
Tool/spdlog/include/spdlog/details/log_msg_buffer-inl.h
View File

@ -4,35 +4,33 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/details/log_msg_buffer.h> #include <spdlog/details/log_msg_buffer.h>
#endif #endif
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg) SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
: log_msg{orig_msg} : log_msg{orig_msg} {
{
buffer.append(logger_name.begin(), logger_name.end()); buffer.append(logger_name.begin(), logger_name.end());
buffer.append(payload.begin(), payload.end()); buffer.append(payload.begin(), payload.end());
update_string_views(); update_string_views();
} }
SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other) SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
: log_msg{other} : log_msg{other} {
{
buffer.append(logger_name.begin(), logger_name.end()); buffer.append(logger_name.begin(), logger_name.end());
buffer.append(payload.begin(), payload.end()); buffer.append(payload.begin(), payload.end());
update_string_views(); update_string_views();
} }
SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)} SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT
{ : log_msg{other},
buffer{std::move(other.buffer)} {
update_string_views(); update_string_views();
} }
SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) {
{
log_msg::operator=(other); log_msg::operator=(other);
buffer.clear(); buffer.clear();
buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size()); buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size());
@ -40,19 +38,17 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &ot
return *this; return *this;
} }
SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT {
{
log_msg::operator=(other); log_msg::operator=(other);
buffer = std::move(other.buffer); buffer = std::move(other.buffer);
update_string_views(); update_string_views();
return *this; return *this;
} }
SPDLOG_INLINE void log_msg_buffer::update_string_views() SPDLOG_INLINE void log_msg_buffer::update_string_views() {
{
logger_name = string_view_t{buffer.data(), logger_name.size()}; logger_name = string_view_t{buffer.data(), logger_name.size()};
payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

9
Tool/spdlog/include/spdlog/details/log_msg_buffer.h
View File

@ -11,8 +11,7 @@ namespace details {
// Extend log_msg with internal buffer to store its payload. // Extend log_msg with internal buffer to store its payload.
// This is needed since log_msg holds string_views that points to stack data. // This is needed since log_msg holds string_views that points to stack data.
class SPDLOG_API log_msg_buffer : public log_msg class SPDLOG_API log_msg_buffer : public log_msg {
{
memory_buf_t buffer; memory_buf_t buffer;
void update_string_views(); void update_string_views();
@ -25,9 +24,9 @@ public:
log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT; log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "log_msg_buffer-inl.h" #include "log_msg_buffer-inl.h"
#endif #endif

99
Tool/spdlog/include/spdlog/details/mpmc_blocking_q.h
View File

@ -12,25 +12,23 @@
#include <spdlog/details/circular_q.h> #include <spdlog/details/circular_q.h>
#include <atomic>
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
namespace spdlog { namespace spdlog {
namespace details { namespace details {
template<typename T> template <typename T>
class mpmc_blocking_queue class mpmc_blocking_queue {
{
public: public:
using item_type = T; using item_type = T;
explicit mpmc_blocking_queue(size_t max_items) explicit mpmc_blocking_queue(size_t max_items)
: q_(max_items) : q_(max_items) {}
{}
#ifndef __MINGW32__ #ifndef __MINGW32__
// try to enqueue and block if no room left // try to enqueue and block if no room left
void enqueue(T &&item) void enqueue(T &&item) {
{
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
pop_cv_.wait(lock, [this] { return !this->q_.full(); }); pop_cv_.wait(lock, [this] { return !this->q_.full(); });
@ -40,8 +38,7 @@ public:
} }
// enqueue immediately. overrun oldest message in the queue if no room left. // enqueue immediately. overrun oldest message in the queue if no room left.
void enqueue_nowait(T &&item) void enqueue_nowait(T &&item) {
{
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
q_.push_back(std::move(item)); q_.push_back(std::move(item));
@ -49,14 +46,29 @@ public:
push_cv_.notify_one(); push_cv_.notify_one();
} }
// dequeue with a timeout. void enqueue_if_have_room(T &&item) {
// Return true, if succeeded dequeue item, false otherwise bool pushed = false;
bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
{
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) if (!q_.full()) {
{ q_.push_back(std::move(item));
pushed = true;
}
}
if (pushed) {
push_cv_.notify_one();
} else {
++discard_counter_;
}
}
// dequeue with a timeout.
// Return true, if succeeded dequeue item, false otherwise
bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
{
std::unique_lock<std::mutex> lock(queue_mutex_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
return false; return false;
} }
popped_item = std::move(q_.front()); popped_item = std::move(q_.front());
@ -67,8 +79,7 @@ public:
} }
// blocking dequeue without a timeout. // blocking dequeue without a timeout.
void dequeue(T &popped_item) void dequeue(T &popped_item) {
{
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
push_cv_.wait(lock, [this] { return !this->q_.empty(); }); push_cv_.wait(lock, [this] { return !this->q_.empty(); });
@ -83,8 +94,7 @@ public:
// so release the mutex at the very end each function. // so release the mutex at the very end each function.
// try to enqueue and block if no room left // try to enqueue and block if no room left
void enqueue(T &&item) void enqueue(T &&item) {
{
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
pop_cv_.wait(lock, [this] { return !this->q_.full(); }); pop_cv_.wait(lock, [this] { return !this->q_.full(); });
q_.push_back(std::move(item)); q_.push_back(std::move(item));
@ -92,20 +102,32 @@ public:
} }
// enqueue immediately. overrun oldest message in the queue if no room left. // enqueue immediately. overrun oldest message in the queue if no room left.
void enqueue_nowait(T &&item) void enqueue_nowait(T &&item) {
{
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
q_.push_back(std::move(item)); q_.push_back(std::move(item));
push_cv_.notify_one(); push_cv_.notify_one();
} }
void enqueue_if_have_room(T &&item) {
bool pushed = false;
std::unique_lock<std::mutex> lock(queue_mutex_);
if (!q_.full()) {
q_.push_back(std::move(item));
pushed = true;
}
if (pushed) {
push_cv_.notify_one();
} else {
++discard_counter_;
}
}
// dequeue with a timeout. // dequeue with a timeout.
// Return true, if succeeded dequeue item, false otherwise // Return true, if succeeded dequeue item, false otherwise
bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
{
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
{
return false; return false;
} }
popped_item = std::move(q_.front()); popped_item = std::move(q_.front());
@ -115,8 +137,7 @@ public:
} }
// blocking dequeue without a timeout. // blocking dequeue without a timeout.
void dequeue(T &popped_item) void dequeue(T &popped_item) {
{
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
push_cv_.wait(lock, [this] { return !this->q_.empty(); }); push_cv_.wait(lock, [this] { return !this->q_.empty(); });
popped_item = std::move(q_.front()); popped_item = std::move(q_.front());
@ -126,29 +147,31 @@ public:
#endif #endif
size_t overrun_counter() size_t overrun_counter() {
{ std::lock_guard<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_);
return q_.overrun_counter(); return q_.overrun_counter();
} }
size_t size() size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); }
{
std::unique_lock<std::mutex> lock(queue_mutex_); size_t size() {
std::lock_guard<std::mutex> lock(queue_mutex_);
return q_.size(); return q_.size();
} }
void reset_overrun_counter() void reset_overrun_counter() {
{ std::lock_guard<std::mutex> lock(queue_mutex_);
std::unique_lock<std::mutex> lock(queue_mutex_);
q_.reset_overrun_counter(); q_.reset_overrun_counter();
} }
void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); }
private: private:
std::mutex queue_mutex_; std::mutex queue_mutex_;
std::condition_variable push_cv_; std::condition_variable push_cv_;
std::condition_variable pop_cv_; std::condition_variable pop_cv_;
spdlog::details::circular_q<T> q_; spdlog::details::circular_q<T> q_;
std::atomic<size_t> discard_counter_{0};
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

28
Tool/spdlog/include/spdlog/details/null_mutex.h
View File

@ -9,37 +9,27 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
struct null_mutex struct null_mutex {
{
void lock() const {} void lock() const {}
void unlock() const {} void unlock() const {}
}; };
struct null_atomic_int struct null_atomic_int {
{
int value; int value;
null_atomic_int() = default; null_atomic_int() = default;
explicit null_atomic_int(int new_value) explicit null_atomic_int(int new_value)
: value(new_value) : value(new_value) {}
{}
int load(std::memory_order = std::memory_order_relaxed) const int load(std::memory_order = std::memory_order_relaxed) const { return value; }
{
return value;
}
void store(int new_value, std::memory_order = std::memory_order_relaxed) void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; }
{
value = new_value;
}
int exchange(int new_value, std::memory_order = std::memory_order_relaxed) int exchange(int new_value, std::memory_order = std::memory_order_relaxed) {
{
std::swap(new_value, value); std::swap(new_value, value);
return new_value; // return value before the call return new_value; // return value before the call
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

445
Tool/spdlog/include/spdlog/details/os-inl.h
View File

@ -4,92 +4,88 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/details/os.h> #include <spdlog/details/os.h>
#endif #endif
#include <spdlog/common.h> #include <spdlog/common.h>
#include <algorithm> #include <algorithm>
#include <array>
#include <chrono> #include <chrono>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <ctime> #include <ctime>
#include <string> #include <string>
#include <thread>
#include <array>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <thread>
#ifdef _WIN32 #ifdef _WIN32
#include <spdlog/details/windows_include.h>
#include <fileapi.h> // for FlushFileBuffers
#include <io.h> // for _get_osfhandle, _isatty, _fileno
#include <process.h> // for _get_pid
# include <io.h> // for _get_osfhandle, _isatty, _fileno #ifdef __MINGW32__
# include <process.h> // for _get_pid #include <share.h>
# include <spdlog/details/windows_include.h> #endif
# include <fileapi.h> // for FlushFileBuffers
# ifdef __MINGW32__ #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
# include <share.h> #include <cassert>
# endif #include <limits>
#endif
# if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES) #include <direct.h> // for _mkdir/_wmkdir
# include <limits>
# include <cassert>
# endif
# include <direct.h> // for _mkdir/_wmkdir #else // unix
#else // unix #include <fcntl.h>
#include <unistd.h>
# include <fcntl.h> #ifdef __linux__
# include <unistd.h> #include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
# ifdef __linux__ #elif defined(_AIX)
# include <sys/syscall.h> //Use gettid() syscall under linux to get thread id #include <pthread.h> // for pthread_getthrds_np
# elif defined(_AIX) #elif defined(__DragonFly__) || defined(__FreeBSD__)
# include <pthread.h> // for pthread_getthrds_np #include <pthread_np.h> // for pthread_getthreadid_np
# elif defined(__DragonFly__) || defined(__FreeBSD__) #elif defined(__NetBSD__)
# include <pthread_np.h> // for pthread_getthreadid_np #include <lwp.h> // for _lwp_self
# elif defined(__NetBSD__) #elif defined(__sun)
# include <lwp.h> // for _lwp_self #include <thread.h> // for thr_self
#endif
# elif defined(__sun) #endif // unix
# include <thread.h> // for thr_self
# endif
#endif // unix
#if defined __APPLE__ #if defined __APPLE__
# include <AvailabilityMacros.h> #include <AvailabilityMacros.h>
#endif #endif
#ifndef __has_feature // Clang - feature checking macros. #ifndef __has_feature // Clang - feature checking macros.
# define __has_feature(x) 0 // Compatibility with non-clang compilers. #define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif #endif
namespace spdlog { namespace spdlog {
namespace details { namespace details {
namespace os { namespace os {
SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {
{
#if defined __linux__ && defined SPDLOG_CLOCK_COARSE #if defined __linux__ && defined SPDLOG_CLOCK_COARSE
timespec ts; timespec ts;
::clock_gettime(CLOCK_REALTIME_COARSE, &ts); ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
return std::chrono::time_point<log_clock, typename log_clock::duration>( return std::chrono::time_point<log_clock, typename log_clock::duration>(
std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec))); std::chrono::duration_cast<typename log_clock::duration>(
std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
#else #else
return log_clock::now(); return log_clock::now();
#endif #endif
} }
SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
std::tm tm; std::tm tm;
::localtime_s(&tm, &time_tt); ::localtime_s(&tm, &time_tt);
@ -100,15 +96,12 @@ SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
return tm; return tm;
} }
SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT {
{
std::time_t now_t = ::time(nullptr); std::time_t now_t = ::time(nullptr);
return localtime(now_t); return localtime(now_t);
} }
SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
std::tm tm; std::tm tm;
::gmtime_s(&tm, &time_tt); ::gmtime_s(&tm, &time_tt);
@ -119,55 +112,49 @@ SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
return tm; return tm;
} }
SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT {
{
std::time_t now_t = ::time(nullptr); std::time_t now_t = ::time(nullptr);
return gmtime(now_t); return gmtime(now_t);
} }
// fopen_s on non windows for writing // fopen_s on non windows for writing
SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) {
{
#ifdef _WIN32 #ifdef _WIN32
# ifdef SPDLOG_WCHAR_FILENAMES #ifdef SPDLOG_WCHAR_FILENAMES
*fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
# else #else
*fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
# endif #endif
# if defined(SPDLOG_PREVENT_CHILD_FD) #if defined(SPDLOG_PREVENT_CHILD_FD)
if (*fp != nullptr) if (*fp != nullptr) {
{
auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp))); auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) {
{
::fclose(*fp); ::fclose(*fp);
*fp = nullptr; *fp = nullptr;
} }
} }
# endif #endif
#else // unix #else // unix
# if defined(SPDLOG_PREVENT_CHILD_FD) #if defined(SPDLOG_PREVENT_CHILD_FD)
const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644)); const int fd =
if (fd == -1) ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
{ if (fd == -1) {
return true; return true;
} }
*fp = ::fdopen(fd, mode.c_str()); *fp = ::fdopen(fd, mode.c_str());
if (*fp == nullptr) if (*fp == nullptr) {
{
::close(fd); ::close(fd);
} }
# else #else
*fp = ::fopen((filename.c_str()), mode.c_str()); *fp = ::fopen((filename.c_str()), mode.c_str());
# endif #endif
#endif #endif
return *fp == nullptr; return *fp == nullptr;
} }
SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT {
{
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return ::_wremove(filename.c_str()); return ::_wremove(filename.c_str());
#else #else
@ -175,13 +162,11 @@ SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
#endif #endif
} }
SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
{
return path_exists(filename) ? remove(filename) : 0; return path_exists(filename) ? remove(filename) : 0;
} }
SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT {
{
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return ::_wrename(filename1.c_str(), filename2.c_str()); return ::_wrename(filename1.c_str(), filename2.c_str());
#else #else
@ -190,115 +175,103 @@ SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename
} }
// Return true if path exists (file or directory) // Return true if path exists (file or directory)
SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
# ifdef SPDLOG_WCHAR_FILENAMES struct _stat buffer;
auto attribs = ::GetFileAttributesW(filename.c_str()); #ifdef SPDLOG_WCHAR_FILENAMES
# else return (::_wstat(filename.c_str(), &buffer) == 0);
auto attribs = ::GetFileAttributesA(filename.c_str()); #else
# endif return (::_stat(filename.c_str(), &buffer) == 0);
return attribs != INVALID_FILE_ATTRIBUTES; #endif
#else // common linux/unix all have the stat system call #else // common linux/unix all have the stat system call
struct stat buffer; struct stat buffer;
return (::stat(filename.c_str(), &buffer) == 0); return (::stat(filename.c_str(), &buffer) == 0);
#endif #endif
} }
#ifdef _MSC_VER #ifdef _MSC_VER
// avoid warning about unreachable statement at the end of filesize() // avoid warning about unreachable statement at the end of filesize()
# pragma warning(push) #pragma warning(push)
# pragma warning(disable : 4702) #pragma warning(disable : 4702)
#endif #endif
// Return file size according to open FILE* object // Return file size according to open FILE* object
SPDLOG_INLINE size_t filesize(FILE *f) SPDLOG_INLINE size_t filesize(FILE *f) {
{ if (f == nullptr) {
if (f == nullptr)
{
throw_spdlog_ex("Failed getting file size. fd is null"); throw_spdlog_ex("Failed getting file size. fd is null");
} }
#if defined(_WIN32) && !defined(__CYGWIN__) #if defined(_WIN32) && !defined(__CYGWIN__)
int fd = ::_fileno(f); int fd = ::_fileno(f);
# if defined(_WIN64) // 64 bits #if defined(_WIN64) // 64 bits
__int64 ret = ::_filelengthi64(fd); __int64 ret = ::_filelengthi64(fd);
if (ret >= 0) if (ret >= 0) {
{
return static_cast<size_t>(ret); return static_cast<size_t>(ret);
} }
# else // windows 32 bits #else // windows 32 bits
long ret = ::_filelength(fd); long ret = ::_filelength(fd);
if (ret >= 0) if (ret >= 0) {
{
return static_cast<size_t>(ret); return static_cast<size_t>(ret);
} }
# endif #endif
#else // unix #else // unix
// OpenBSD and AIX doesn't compile with :: before the fileno(..) // OpenBSD and AIX doesn't compile with :: before the fileno(..)
# if defined(__OpenBSD__) || defined(_AIX) #if defined(__OpenBSD__) || defined(_AIX)
int fd = fileno(f); int fd = fileno(f);
# else #else
int fd = ::fileno(f); int fd = ::fileno(f);
# endif #endif
// 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated) // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated)
# if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64)) #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \
(defined(__LP64__) || defined(_LP64))
struct stat64 st; struct stat64 st;
if (::fstat64(fd, &st) == 0) if (::fstat64(fd, &st) == 0) {
{
return static_cast<size_t>(st.st_size); return static_cast<size_t>(st.st_size);
} }
# else // other unix or linux 32 bits or cygwin #else // other unix or linux 32 bits or cygwin
struct stat st; struct stat st;
if (::fstat(fd, &st) == 0) if (::fstat(fd, &st) == 0) {
{
return static_cast<size_t>(st.st_size); return static_cast<size_t>(st.st_size);
} }
# endif #endif
#endif #endif
throw_spdlog_ex("Failed getting file size from fd", errno); throw_spdlog_ex("Failed getting file size from fd", errno);
return 0; // will not be reached. return 0; // will not be reached.
} }
#ifdef _MSC_VER #ifdef _MSC_VER
# pragma warning(pop) #pragma warning(pop)
#endif #endif
// Return utc offset in minutes or throw spdlog_ex on failure // Return utc offset in minutes or throw spdlog_ex on failure
SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
{
#ifdef _WIN32 #ifdef _WIN32
# if _WIN32_WINNT < _WIN32_WINNT_WS08 #if _WIN32_WINNT < _WIN32_WINNT_WS08
TIME_ZONE_INFORMATION tzinfo; TIME_ZONE_INFORMATION tzinfo;
auto rv = ::GetTimeZoneInformation(&tzinfo); auto rv = ::GetTimeZoneInformation(&tzinfo);
# else #else
DYNAMIC_TIME_ZONE_INFORMATION tzinfo; DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
# endif #endif
if (rv == TIME_ZONE_ID_INVALID) if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno);
throw_spdlog_ex("Failed getting timezone info. ", errno);
int offset = -tzinfo.Bias; int offset = -tzinfo.Bias;
if (tm.tm_isdst) if (tm.tm_isdst) {
{
offset -= tzinfo.DaylightBias; offset -= tzinfo.DaylightBias;
} } else {
else
{
offset -= tzinfo.StandardBias; offset -= tzinfo.StandardBias;
} }
return offset; return offset;
#else #else
# if defined(sun) || defined(__sun) || defined(_AIX) || (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || \ #if defined(sun) || defined(__sun) || defined(_AIX) || \
(defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || \
(!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE)) (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
// 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
struct helper struct helper {
{ static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(),
static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime()) const std::tm &gmtm = details::os::gmtime()) {
{
int local_year = localtm.tm_year + (1900 - 1); int local_year = localtm.tm_year + (1900 - 1);
int gmt_year = gmtm.tm_year + (1900 - 1); int gmt_year = gmtm.tm_year + (1900 - 1);
@ -323,9 +296,9 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
}; };
auto offset_seconds = helper::calculate_gmt_offset(tm); auto offset_seconds = helper::calculate_gmt_offset(tm);
# else #else
auto offset_seconds = tm.tm_gmtoff; auto offset_seconds = tm.tm_gmtoff;
# endif #endif
return static_cast<int>(offset_seconds / 60); return static_cast<int>(offset_seconds / 60);
#endif #endif
@ -334,14 +307,13 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
// Return current thread id as size_t // Return current thread id as size_t
// It exists because the std::this_thread::get_id() is much slower(especially // It exists because the std::this_thread::get_id() is much slower(especially
// under VS 2013) // under VS 2013)
SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
return static_cast<size_t>(::GetCurrentThreadId()); return static_cast<size_t>(::GetCurrentThreadId());
#elif defined(__linux__) #elif defined(__linux__)
# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
# define SYS_gettid __NR_gettid #define SYS_gettid __NR_gettid
# endif #endif
return static_cast<size_t>(::syscall(SYS_gettid)); return static_cast<size_t>(::syscall(SYS_gettid));
#elif defined(_AIX) #elif defined(_AIX)
struct __pthrdsinfo buf; struct __pthrdsinfo buf;
@ -360,34 +332,36 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
return static_cast<size_t>(::thr_self()); return static_cast<size_t>(::thr_self());
#elif __APPLE__ #elif __APPLE__
uint64_t tid; uint64_t tid;
// There is no pthread_threadid_np prior to 10.6, and it is not supported on any PPC, // There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC,
// including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64. // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.
# if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__) #ifdef MAC_OS_X_VERSION_MAX_ALLOWED
tid = pthread_mach_thread_np(pthread_self());
# elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
if (&pthread_threadid_np)
{
pthread_threadid_np(nullptr, &tid);
}
else
{ {
#if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
tid = pthread_mach_thread_np(pthread_self()); tid = pthread_mach_thread_np(pthread_self());
#elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
if (&pthread_threadid_np) {
pthread_threadid_np(nullptr, &tid);
} else {
tid = pthread_mach_thread_np(pthread_self());
}
#else
pthread_threadid_np(nullptr, &tid);
#endif
} }
# else #else
pthread_threadid_np(nullptr, &tid); pthread_threadid_np(nullptr, &tid);
# endif #endif
return static_cast<size_t>(tid); return static_cast<size_t>(tid);
#else // Default to standard C++11 (other Unix) #else // Default to standard C++11 (other Unix)
return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id())); return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
#endif #endif
} }
// Return current thread id as size_t (from thread local storage) // Return current thread id as size_t (from thread local storage)
SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT {
{
#if defined(SPDLOG_NO_TLS) #if defined(SPDLOG_NO_TLS)
return _thread_id(); return _thread_id();
#else // cache thread id in tls #else // cache thread id in tls
static thread_local const size_t tid = _thread_id(); static thread_local const size_t tid = _thread_id();
return tid; return tid;
#endif #endif
@ -395,8 +369,7 @@ SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
// This is avoid msvc issue in sleep_for that happens if the clock changes. // This is avoid msvc issue in sleep_for that happens if the clock changes.
// See https://github.com/gabime/spdlog/issues/609 // See https://github.com/gabime/spdlog/issues/609
SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT {
{
#if defined(_WIN32) #if defined(_WIN32)
::Sleep(milliseconds); ::Sleep(milliseconds);
#else #else
@ -406,22 +379,16 @@ SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT
// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) {
{
memory_buf_t buf; memory_buf_t buf;
wstr_to_utf8buf(filename, buf); wstr_to_utf8buf(filename, buf);
return SPDLOG_BUF_TO_STRING(buf); return SPDLOG_BUF_TO_STRING(buf);
} }
#else #else
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; }
{
return filename;
}
#endif #endif
SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
return conditional_static_cast<int>(::GetCurrentProcessId()); return conditional_static_cast<int>(::GetCurrentProcessId());
#else #else
@ -431,29 +398,29 @@ SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
// Determine if the terminal supports colors // Determine if the terminal supports colors
// Based on: https://github.com/agauniyal/rang/ // Based on: https://github.com/agauniyal/rang/
SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
return true; return true;
#else #else
static const bool result = []() { static const bool result = []() {
const char *env_colorterm_p = std::getenv("COLORTERM"); const char *env_colorterm_p = std::getenv("COLORTERM");
if (env_colorterm_p != nullptr) if (env_colorterm_p != nullptr) {
{
return true; return true;
} }
static constexpr std::array<const char *, 16> terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", static constexpr std::array<const char *, 16> terms = {
"msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}}; {"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys",
"putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
const char *env_term_p = std::getenv("TERM"); const char *env_term_p = std::getenv("TERM");
if (env_term_p == nullptr) if (env_term_p == nullptr) {
{
return false; return false;
} }
return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; }); return std::any_of(terms.begin(), terms.end(), [&](const char *term) {
return std::strstr(env_term_p, term) != nullptr;
});
}(); }();
return result; return result;
@ -462,9 +429,7 @@ SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
// Determine if the terminal attached // Determine if the terminal attached
// Source: https://github.com/agauniyal/rang/ // Source: https://github.com/agauniyal/rang/
SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
{
#ifdef _WIN32 #ifdef _WIN32
return ::_isatty(_fileno(file)) != 0; return ::_isatty(_fileno(file)) != 0;
#else #else
@ -473,82 +438,77 @@ SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
} }
#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) {
{ if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 4 - 1) {
if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1)
{
throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8"); throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
} }
int wstr_size = static_cast<int>(wstr.size()); int wstr_size = static_cast<int>(wstr.size());
if (wstr_size == 0) if (wstr_size == 0) {
{
target.resize(0); target.resize(0);
return; return;
} }
int result_size = static_cast<int>(target.capacity()); int result_size = static_cast<int>(target.capacity());
if ((wstr_size + 1) * 2 > result_size) if ((wstr_size + 1) * 4 > result_size) {
{ result_size =
result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL); ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
} }
if (result_size > 0) if (result_size > 0) {
{
target.resize(result_size); target.resize(result_size);
result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL); result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(),
result_size, NULL, NULL);
if (result_size > 0) if (result_size > 0) {
{
target.resize(result_size); target.resize(result_size);
return; return;
} }
} }
throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); throw_spdlog_ex(
fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
} }
SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {
{ if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1) {
if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1)
{
throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16"); throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16");
} }
int str_size = static_cast<int>(str.size()); int str_size = static_cast<int>(str.size());
if (str_size == 0) if (str_size == 0) {
{
target.resize(0); target.resize(0);
return; return;
} }
// find the size to allocate for the result buffer // find the size to allocate for the result buffer
int result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0); int result_size =
::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0);
if (result_size > 0) if (result_size > 0) {
{
target.resize(result_size); target.resize(result_size);
result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size); result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(),
if (result_size > 0) result_size);
{ if (result_size > 0) {
assert(result_size == target.size()); assert(result_size == target.size());
return; return;
} }
} }
throw_spdlog_ex(fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError())); throw_spdlog_ex(
fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
} }
#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) #endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) &&
// defined(_WIN32)
// return true on success // return true on success
static SPDLOG_INLINE bool mkdir_(const filename_t &path) static SPDLOG_INLINE bool mkdir_(const filename_t &path) {
{
#ifdef _WIN32 #ifdef _WIN32
# ifdef SPDLOG_WCHAR_FILENAMES #ifdef SPDLOG_WCHAR_FILENAMES
return ::_wmkdir(path.c_str()) == 0; return ::_wmkdir(path.c_str()) == 0;
# else #else
return ::_mkdir(path.c_str()) == 0; return ::_mkdir(path.c_str()) == 0;
# endif #endif
#else #else
return ::mkdir(path.c_str(), mode_t(0755)) == 0; return ::mkdir(path.c_str(), mode_t(0755)) == 0;
#endif #endif
@ -556,33 +516,36 @@ static SPDLOG_INLINE bool mkdir_(const filename_t &path)
// create the given directory - and all directories leading to it // create the given directory - and all directories leading to it
// return true on success or if the directory already exists // return true on success or if the directory already exists
SPDLOG_INLINE bool create_dir(const filename_t &path) SPDLOG_INLINE bool create_dir(const filename_t &path) {
{ if (path_exists(path)) {
if (path_exists(path))
{
return true; return true;
} }
if (path.empty()) if (path.empty()) {
{
return false; return false;
} }
size_t search_offset = 0; size_t search_offset = 0;
do do {
{
auto token_pos = path.find_first_of(folder_seps_filename, search_offset); auto token_pos = path.find_first_of(folder_seps_filename, search_offset);
// treat the entire path as a folder if no folder separator not found // treat the entire path as a folder if no folder separator not found
if (token_pos == filename_t::npos) if (token_pos == filename_t::npos) {
{
token_pos = path.size(); token_pos = path.size();
} }
auto subdir = path.substr(0, token_pos); auto subdir = path.substr(0, token_pos);
#ifdef _WIN32
// if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\",
// otherwise path_exists(subdir) returns false (issue #3079)
const bool is_drive = subdir.length() == 2 && subdir[1] == ':';
if (is_drive) {
subdir += '\\';
token_pos++;
}
#endif
if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) {
{ return false; // return error if failed creating dir
return false; // return error if failed creating dir
} }
search_offset = token_pos + 1; search_offset = token_pos + 1;
} while (search_offset < path.size()); } while (search_offset < path.size());
@ -595,25 +558,22 @@ SPDLOG_INLINE bool create_dir(const filename_t &path)
// "abc/" => "abc" // "abc/" => "abc"
// "abc" => "" // "abc" => ""
// "abc///" => "abc//" // "abc///" => "abc//"
SPDLOG_INLINE filename_t dir_name(const filename_t &path) SPDLOG_INLINE filename_t dir_name(const filename_t &path) {
{
auto pos = path.find_last_of(folder_seps_filename); auto pos = path.find_last_of(folder_seps_filename);
return pos != filename_t::npos ? path.substr(0, pos) : filename_t{}; return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
} }
std::string SPDLOG_INLINE getenv(const char *field) std::string SPDLOG_INLINE getenv(const char *field) {
{
#if defined(_MSC_VER) #if defined(_MSC_VER)
# if defined(__cplusplus_winrt) #if defined(__cplusplus_winrt)
return std::string{}; // not supported under uwp return std::string{}; // not supported under uwp
# else #else
size_t len = 0; size_t len = 0;
char buf[128]; char buf[128];
bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0; bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
return ok ? buf : std::string{}; return ok ? buf : std::string{};
# endif #endif
#else // revert to getenv #else // revert to getenv
char *buf = ::getenv(field); char *buf = ::getenv(field);
return buf ? buf : std::string{}; return buf ? buf : std::string{};
#endif #endif
@ -621,8 +581,7 @@ std::string SPDLOG_INLINE getenv(const char *field)
// Do fsync by FILE handlerpointer // Do fsync by FILE handlerpointer
// Return true on success // Return true on success
SPDLOG_INLINE bool fsync(FILE *fp) SPDLOG_INLINE bool fsync(FILE *fp) {
{
#ifdef _WIN32 #ifdef _WIN32
return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0; return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0;
#else #else
@ -630,6 +589,18 @@ SPDLOG_INLINE bool fsync(FILE *fp)
#endif #endif
} }
} // namespace os // Do non-locking fwrite if possible by the os or use the regular locking fwrite
} // namespace details // Return true on success.
} // namespace spdlog SPDLOG_INLINE bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) {
#if defined(_WIN32) && defined(SPDLOG_FWRITE_UNLOCKED)
return _fwrite_nolock(ptr, 1, n_bytes, fp) == n_bytes;
#elif defined(SPDLOG_FWRITE_UNLOCKED)
return ::fwrite_unlocked(ptr, 1, n_bytes, fp) == n_bytes;
#else
return std::fwrite(ptr, 1, n_bytes, fp) == n_bytes;
#endif
}
} // namespace os
} // namespace details
} // namespace spdlog

37
Tool/spdlog/include/spdlog/details/os.h
View File

@ -3,8 +3,8 @@
#pragma once #pragma once
#include <ctime> // std::time_t
#include <spdlog/common.h> #include <spdlog/common.h>
#include <ctime> // std::time_t
namespace spdlog { namespace spdlog {
namespace details { namespace details {
@ -22,26 +22,27 @@ SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;
// eol definition // eol definition
#if !defined(SPDLOG_EOL) #if !defined(SPDLOG_EOL)
# ifdef _WIN32 #ifdef _WIN32
# define SPDLOG_EOL "\r\n" #define SPDLOG_EOL "\r\n"
# else #else
# define SPDLOG_EOL "\n" #define SPDLOG_EOL "\n"
# endif #endif
#endif #endif
SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL; SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
// folder separator // folder separator
#if !defined(SPDLOG_FOLDER_SEPS) #if !defined(SPDLOG_FOLDER_SEPS)
# ifdef _WIN32 #ifdef _WIN32
# define SPDLOG_FOLDER_SEPS "\\/" #define SPDLOG_FOLDER_SEPS "\\/"
# else #else
# define SPDLOG_FOLDER_SEPS "/" #define SPDLOG_FOLDER_SEPS "/"
# endif #endif
#endif #endif
SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS; SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;
SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS); SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] =
SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
// fopen_s on non windows for writing // fopen_s on non windows for writing
SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode); SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
@ -113,10 +114,14 @@ SPDLOG_API std::string getenv(const char *field);
// Return true on success. // Return true on success.
SPDLOG_API bool fsync(FILE *fp); SPDLOG_API bool fsync(FILE *fp);
} // namespace os // Do non-locking fwrite if possible by the os or use the regular locking fwrite
} // namespace details // Return true on success.
} // namespace spdlog SPDLOG_API bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp);
} // namespace os
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "os-inl.h" #include "os-inl.h"
#endif #endif

12
Tool/spdlog/include/spdlog/details/periodic_worker-inl.h
View File

@ -4,17 +4,15 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/details/periodic_worker.h> #include <spdlog/details/periodic_worker.h>
#endif #endif
namespace spdlog { namespace spdlog {
namespace details { namespace details {
// stop the worker thread and join it // stop the worker thread and join it
SPDLOG_INLINE periodic_worker::~periodic_worker() SPDLOG_INLINE periodic_worker::~periodic_worker() {
{ if (worker_thread_.joinable()) {
if (worker_thread_.joinable())
{
{ {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
active_ = false; active_ = false;
@ -24,5 +22,5 @@ SPDLOG_INLINE periodic_worker::~periodic_worker()
} }
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

30
Tool/spdlog/include/spdlog/details/periodic_worker.h
View File

@ -7,7 +7,8 @@
// //
// RAII over the owned thread: // RAII over the owned thread:
// creates the thread on construction. // creates the thread on construction.
// stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first). // stops and joins the thread on destruction (if the thread is executing a callback, wait for it
// to finish first).
#include <chrono> #include <chrono>
#include <condition_variable> #include <condition_variable>
@ -17,30 +18,27 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
class SPDLOG_API periodic_worker class SPDLOG_API periodic_worker {
{
public: public:
template<typename Rep, typename Period> template <typename Rep, typename Period>
periodic_worker(const std::function<void()> &callback_fun, std::chrono::duration<Rep, Period> interval) periodic_worker(const std::function<void()> &callback_fun,
{ std::chrono::duration<Rep, Period> interval) {
active_ = (interval > std::chrono::duration<Rep, Period>::zero()); active_ = (interval > std::chrono::duration<Rep, Period>::zero());
if (!active_) if (!active_) {
{
return; return;
} }
worker_thread_ = std::thread([this, callback_fun, interval]() { worker_thread_ = std::thread([this, callback_fun, interval]() {
for (;;) for (;;) {
{
std::unique_lock<std::mutex> lock(this->mutex_); std::unique_lock<std::mutex> lock(this->mutex_);
if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) {
{ return; // active_ == false, so exit this thread
return; // active_ == false, so exit this thread
} }
callback_fun(); callback_fun();
} }
}); });
} }
std::thread &get_thread() { return worker_thread_; }
periodic_worker(const periodic_worker &) = delete; periodic_worker(const periodic_worker &) = delete;
periodic_worker &operator=(const periodic_worker &) = delete; periodic_worker &operator=(const periodic_worker &) = delete;
// stop the worker thread and join it // stop the worker thread and join it
@ -52,9 +50,9 @@ private:
std::mutex mutex_; std::mutex mutex_;
std::condition_variable cv_; std::condition_variable cv_;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "periodic_worker-inl.h" #include "periodic_worker-inl.h"
#endif #endif

172
Tool/spdlog/include/spdlog/details/registry-inl.h
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/details/registry.h> #include <spdlog/details/registry.h>
#endif #endif
#include <spdlog/common.h> #include <spdlog/common.h>
@ -13,13 +13,13 @@
#include <spdlog/pattern_formatter.h> #include <spdlog/pattern_formatter.h>
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
// support for the default stdout color logger // support for the default stdout color logger
# ifdef _WIN32 #ifdef _WIN32
# include <spdlog/sinks/wincolor_sink.h> #include <spdlog/sinks/wincolor_sink.h>
# else #else
# include <spdlog/sinks/ansicolor_sink.h> #include <spdlog/sinks/ansicolor_sink.h>
# endif #endif
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
#include <chrono> #include <chrono>
#include <functional> #include <functional>
@ -31,39 +31,34 @@ namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE registry::registry() SPDLOG_INLINE registry::registry()
: formatter_(new pattern_formatter()) : formatter_(new pattern_formatter()) {
{
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
# ifdef _WIN32 #ifdef _WIN32
auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>(); auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
# else #else
auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>(); auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
# endif #endif
const char *default_logger_name = ""; const char *default_logger_name = "";
default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink)); default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
loggers_[default_logger_name] = default_logger_; loggers_[default_logger_name] = default_logger_;
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
} }
SPDLOG_INLINE registry::~registry() = default; SPDLOG_INLINE registry::~registry() = default;
SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger) SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
register_logger_(std::move(new_logger)); register_logger_(std::move(new_logger));
} }
SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
new_logger->set_formatter(formatter_->clone()); new_logger->set_formatter(formatter_->clone());
if (err_handler_) if (err_handler_) {
{
new_logger->set_error_handler(err_handler_); new_logger->set_error_handler(err_handler_);
} }
@ -74,26 +69,22 @@ SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logge
new_logger->flush_on(flush_level_); new_logger->flush_on(flush_level_);
if (backtrace_n_messages_ > 0) if (backtrace_n_messages_ > 0) {
{
new_logger->enable_backtrace(backtrace_n_messages_); new_logger->enable_backtrace(backtrace_n_messages_);
} }
if (automatic_registration_) if (automatic_registration_) {
{
register_logger_(std::move(new_logger)); register_logger_(std::move(new_logger));
} }
} }
SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name) SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto found = loggers_.find(logger_name); auto found = loggers_.find(logger_name);
return found == loggers_.end() ? nullptr : found->second; return found == loggers_.end() ? nullptr : found->second;
} }
SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger() SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger() {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
return default_logger_; return default_logger_;
} }
@ -102,141 +93,110 @@ SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
// To be used directly by the spdlog default api (e.g. spdlog::info) // To be used directly by the spdlog default api (e.g. spdlog::info)
// This make the default API faster, but cannot be used concurrently with set_default_logger(). // This make the default API faster, but cannot be used concurrently with set_default_logger().
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
SPDLOG_INLINE logger *registry::get_default_raw() SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); }
{
return default_logger_.get();
}
// set default logger. // set default logger.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
// remove previous default logger from the map if (new_default_logger != nullptr) {
if (default_logger_ != nullptr)
{
loggers_.erase(default_logger_->name());
}
if (new_default_logger != nullptr)
{
loggers_[new_default_logger->name()] = new_default_logger; loggers_[new_default_logger->name()] = new_default_logger;
} }
default_logger_ = std::move(new_default_logger); default_logger_ = std::move(new_default_logger);
} }
SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp) SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp) {
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_); std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_ = std::move(tp); tp_ = std::move(tp);
} }
SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp() SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp() {
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_); std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
return tp_; return tp_;
} }
// Set global formatter. Each sink in each logger will get a clone of this object // Set global formatter. Each sink in each logger will get a clone of this object
SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter) SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
formatter_ = std::move(formatter); formatter_ = std::move(formatter);
for (auto &l : loggers_) for (auto &l : loggers_) {
{
l.second->set_formatter(formatter_->clone()); l.second->set_formatter(formatter_->clone());
} }
} }
SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
backtrace_n_messages_ = n_messages; backtrace_n_messages_ = n_messages;
for (auto &l : loggers_) for (auto &l : loggers_) {
{
l.second->enable_backtrace(n_messages); l.second->enable_backtrace(n_messages);
} }
} }
SPDLOG_INLINE void registry::disable_backtrace() SPDLOG_INLINE void registry::disable_backtrace() {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
backtrace_n_messages_ = 0; backtrace_n_messages_ = 0;
for (auto &l : loggers_) for (auto &l : loggers_) {
{
l.second->disable_backtrace(); l.second->disable_backtrace();
} }
} }
SPDLOG_INLINE void registry::set_level(level::level_enum log_level) SPDLOG_INLINE void registry::set_level(level::level_enum log_level) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_) {
{
l.second->set_level(log_level); l.second->set_level(log_level);
} }
global_log_level_ = log_level; global_log_level_ = log_level;
} }
SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_) {
{
l.second->flush_on(log_level); l.second->flush_on(log_level);
} }
flush_level_ = log_level; flush_level_ = log_level;
} }
SPDLOG_INLINE void registry::set_error_handler(err_handler handler) SPDLOG_INLINE void registry::set_error_handler(err_handler handler) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_) {
{
l.second->set_error_handler(handler); l.second->set_error_handler(handler);
} }
err_handler_ = std::move(handler); err_handler_ = std::move(handler);
} }
SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun) SPDLOG_INLINE void registry::apply_all(
{ const std::function<void(const std::shared_ptr<logger>)> &fun) {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_) {
{
fun(l.second); fun(l.second);
} }
} }
SPDLOG_INLINE void registry::flush_all() SPDLOG_INLINE void registry::flush_all() {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_) {
{
l.second->flush(); l.second->flush();
} }
} }
SPDLOG_INLINE void registry::drop(const std::string &logger_name) SPDLOG_INLINE void registry::drop(const std::string &logger_name) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto is_default_logger = default_logger_ && default_logger_->name() == logger_name; auto is_default_logger = default_logger_ && default_logger_->name() == logger_name;
loggers_.erase(logger_name); loggers_.erase(logger_name);
if (is_default_logger) if (is_default_logger) {
{
default_logger_.reset(); default_logger_.reset();
} }
} }
SPDLOG_INLINE void registry::drop_all() SPDLOG_INLINE void registry::drop_all() {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.clear(); loggers_.clear();
default_logger_.reset(); default_logger_.reset();
} }
// clean all resources and threads started by the registry // clean all resources and threads started by the registry
SPDLOG_INLINE void registry::shutdown() SPDLOG_INLINE void registry::shutdown() {
{
{ {
std::lock_guard<std::mutex> lock(flusher_mutex_); std::lock_guard<std::mutex> lock(flusher_mutex_);
periodic_flusher_.reset(); periodic_flusher_.reset();
@ -250,66 +210,52 @@ SPDLOG_INLINE void registry::shutdown()
} }
} }
SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex() SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex() { return tp_mutex_; }
{
return tp_mutex_;
}
SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
automatic_registration_ = automatic_registration; automatic_registration_ = automatic_registration;
} }
SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
log_levels_ = std::move(levels); log_levels_ = std::move(levels);
auto global_level_requested = global_level != nullptr; auto global_level_requested = global_level != nullptr;
global_log_level_ = global_level_requested ? *global_level : global_log_level_; global_log_level_ = global_level_requested ? *global_level : global_log_level_;
for (auto &logger : loggers_) for (auto &logger : loggers_) {
{
auto logger_entry = log_levels_.find(logger.first); auto logger_entry = log_levels_.find(logger.first);
if (logger_entry != log_levels_.end()) if (logger_entry != log_levels_.end()) {
{
logger.second->set_level(logger_entry->second); logger.second->set_level(logger_entry->second);
} } else if (global_level_requested) {
else if (global_level_requested)
{
logger.second->set_level(*global_level); logger.second->set_level(*global_level);
} }
} }
} }
SPDLOG_INLINE registry &registry::instance() SPDLOG_INLINE registry &registry::instance() {
{
static registry s_instance; static registry s_instance;
return s_instance; return s_instance;
} }
SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger) SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger) {
{
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto it = log_levels_.find(new_logger->name()); auto it = log_levels_.find(new_logger->name());
auto new_level = it != log_levels_.end() ? it->second : global_log_level_; auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
new_logger->set_level(new_level); new_logger->set_level(new_level);
} }
SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) {
{ if (loggers_.find(logger_name) != loggers_.end()) {
if (loggers_.find(logger_name) != loggers_.end())
{
throw_spdlog_ex("logger with name '" + logger_name + "' already exists"); throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
} }
} }
SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) {
{
auto logger_name = new_logger->name(); auto logger_name = new_logger->name();
throw_if_exists_(logger_name); throw_if_exists_(logger_name);
loggers_[logger_name] = std::move(new_logger); loggers_[logger_name] = std::move(new_logger);
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

28
Tool/spdlog/include/spdlog/details/registry.h
View File

@ -14,9 +14,9 @@
#include <chrono> #include <chrono>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <mutex>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <mutex>
namespace spdlog { namespace spdlog {
class logger; class logger;
@ -24,8 +24,7 @@ class logger;
namespace details { namespace details {
class thread_pool; class thread_pool;
class SPDLOG_API registry class SPDLOG_API registry {
{
public: public:
using log_levels = std::unordered_map<std::string, level::level_enum>; using log_levels = std::unordered_map<std::string, level::level_enum>;
registry(const registry &) = delete; registry(const registry &) = delete;
@ -39,11 +38,14 @@ public:
// Return raw ptr to the default logger. // Return raw ptr to the default logger.
// To be used directly by the spdlog default api (e.g. spdlog::info) // To be used directly by the spdlog default api (e.g. spdlog::info)
// This make the default API faster, but cannot be used concurrently with set_default_logger(). // This make the default API faster, but cannot be used concurrently with set_default_logger().
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. // e.g do not call set_default_logger() from one thread while calling spdlog::info() from
// another.
logger *get_default_raw(); logger *get_default_raw();
// set default logger. // set default logger and add it to the registry if not registered already.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
// Note: Make sure to unregister it when no longer needed or before calling again with a new
// logger.
void set_default_logger(std::shared_ptr<logger> new_default_logger); void set_default_logger(std::shared_ptr<logger> new_default_logger);
void set_tp(std::shared_ptr<thread_pool> tp); void set_tp(std::shared_ptr<thread_pool> tp);
@ -61,14 +63,18 @@ public:
void flush_on(level::level_enum log_level); void flush_on(level::level_enum log_level);
template<typename Rep, typename Period> template <typename Rep, typename Period>
void flush_every(std::chrono::duration<Rep, Period> interval) void flush_every(std::chrono::duration<Rep, Period> interval) {
{
std::lock_guard<std::mutex> lock(flusher_mutex_); std::lock_guard<std::mutex> lock(flusher_mutex_);
auto clbk = [this]() { this->flush_all(); }; auto clbk = [this]() { this->flush_all(); };
periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval); periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
} }
std::unique_ptr<periodic_worker> &get_flusher() {
std::lock_guard<std::mutex> lock(flusher_mutex_);
return periodic_flusher_;
}
void set_error_handler(err_handler handler); void set_error_handler(err_handler handler);
void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun); void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
@ -115,9 +121,9 @@ private:
size_t backtrace_n_messages_ = 0; size_t backtrace_n_messages_ = 0;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "registry-inl.h" #include "registry-inl.h"
#endif #endif

10
Tool/spdlog/include/spdlog/details/synchronous_factory.h
View File

@ -10,15 +10,13 @@ namespace spdlog {
// Default logger factory- creates synchronous loggers // Default logger factory- creates synchronous loggers
class logger; class logger;
struct synchronous_factory struct synchronous_factory {
{ template <typename Sink, typename... SinkArgs>
template<typename Sink, typename... SinkArgs> static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) {
static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args)
{
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink)); auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
details::registry::instance().initialize_logger(new_logger); details::registry::instance().initialize_logger(new_logger);
return new_logger; return new_logger;
} }
}; };
} // namespace spdlog } // namespace spdlog

101
Tool/spdlog/include/spdlog/details/tcp_client-windows.h
View File

@ -8,12 +8,12 @@
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <winsock2.h>
#include <windows.h>
#include <ws2tcpip.h>
#include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string> #include <string>
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "Ws2_32.lib") #pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "Mswsock.lib") #pragma comment(lib, "Mswsock.lib")
@ -21,79 +21,61 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
class tcp_client class tcp_client {
{
SOCKET socket_ = INVALID_SOCKET; SOCKET socket_ = INVALID_SOCKET;
static void init_winsock_() static void init_winsock_() {
{
WSADATA wsaData; WSADATA wsaData;
auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData); auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (rv != 0) if (rv != 0) {
{
throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
} }
} }
static void throw_winsock_error_(const std::string &msg, int last_error) static void throw_winsock_error_(const std::string &msg, int last_error) {
{
char buf[512]; char buf[512];
::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error, ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,
(sizeof(buf) / sizeof(char)), NULL);
throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf)); throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf));
} }
public: public:
tcp_client() tcp_client() { init_winsock_(); }
{
init_winsock_();
}
~tcp_client() ~tcp_client() {
{
close(); close();
::WSACleanup(); ::WSACleanup();
} }
bool is_connected() const bool is_connected() const { return socket_ != INVALID_SOCKET; }
{
return socket_ != INVALID_SOCKET;
}
void close() void close() {
{
::closesocket(socket_); ::closesocket(socket_);
socket_ = INVALID_SOCKET; socket_ = INVALID_SOCKET;
} }
SOCKET fd() const SOCKET fd() const { return socket_; }
{
return socket_;
}
// try to connect or throw on failure // try to connect or throw on failure
void connect(const std::string &host, int port) void connect(const std::string &host, int port) {
{ if (is_connected()) {
if (is_connected())
{
close(); close();
} }
struct addrinfo hints struct addrinfo hints {};
{};
ZeroMemory(&hints, sizeof(hints)); ZeroMemory(&hints, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on
hints.ai_socktype = SOCK_STREAM; // TCP hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
hints.ai_protocol = 0; hints.ai_protocol = 0;
auto port_str = std::to_string(port); auto port_str = std::to_string(port);
struct addrinfo *addrinfo_result; struct addrinfo *addrinfo_result;
auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
int last_error = 0; int last_error = 0;
if (rv != 0) if (rv != 0) {
{
last_error = ::WSAGetLastError(); last_error = ::WSAGetLastError();
WSACleanup(); WSACleanup();
throw_winsock_error_("getaddrinfo failed", last_error); throw_winsock_error_("getaddrinfo failed", last_error);
@ -101,54 +83,47 @@ public:
// Try each address until we successfully connect(2). // Try each address until we successfully connect(2).
for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {
{
socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (socket_ == INVALID_SOCKET) if (socket_ == INVALID_SOCKET) {
{
last_error = ::WSAGetLastError(); last_error = ::WSAGetLastError();
WSACleanup(); WSACleanup();
continue; continue;
} }
if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) {
{
break; break;
} } else {
else
{
last_error = ::WSAGetLastError(); last_error = ::WSAGetLastError();
close(); close();
} }
} }
::freeaddrinfo(addrinfo_result); ::freeaddrinfo(addrinfo_result);
if (socket_ == INVALID_SOCKET) if (socket_ == INVALID_SOCKET) {
{
WSACleanup(); WSACleanup();
throw_winsock_error_("connect failed", last_error); throw_winsock_error_("connect failed", last_error);
} }
// set TCP_NODELAY // set TCP_NODELAY
int enable_flag = 1; int enable_flag = 1;
::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag)); ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag),
sizeof(enable_flag));
} }
// Send exactly n_bytes of the given data. // Send exactly n_bytes of the given data.
// On error close the connection and throw. // On error close the connection and throw.
void send(const char *data, size_t n_bytes) void send(const char *data, size_t n_bytes) {
{
size_t bytes_sent = 0; size_t bytes_sent = 0;
while (bytes_sent < n_bytes) while (bytes_sent < n_bytes) {
{
const int send_flags = 0; const int send_flags = 0;
auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags); auto write_result =
if (write_result == SOCKET_ERROR) ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
{ if (write_result == SOCKET_ERROR) {
int last_error = ::WSAGetLastError(); int last_error = ::WSAGetLastError();
close(); close();
throw_winsock_error_("send failed", last_error); throw_winsock_error_("send failed", last_error);
} }
if (write_result == 0) // (probably should not happen but in any case..) if (write_result == 0) // (probably should not happen but in any case..)
{ {
break; break;
} }
@ -156,5 +131,5 @@ public:
} }
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

85
Tool/spdlog/include/spdlog/details/tcp_client.h
View File

@ -4,91 +4,73 @@
#pragma once #pragma once
#ifdef _WIN32 #ifdef _WIN32
# error include tcp_client-windows.h instead #error include tcp_client-windows.h instead
#endif #endif
// tcp client helper // tcp client helper
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <sys/socket.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h> #include <netdb.h>
#include <netinet/tcp.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string> #include <string>
namespace spdlog { namespace spdlog {
namespace details { namespace details {
class tcp_client class tcp_client {
{
int socket_ = -1; int socket_ = -1;
public: public:
bool is_connected() const bool is_connected() const { return socket_ != -1; }
{
return socket_ != -1;
}
void close() void close() {
{ if (is_connected()) {
if (is_connected())
{
::close(socket_); ::close(socket_);
socket_ = -1; socket_ = -1;
} }
} }
int fd() const int fd() const { return socket_; }
{
return socket_;
}
~tcp_client() ~tcp_client() { close(); }
{
close();
}
// try to connect or throw on failure // try to connect or throw on failure
void connect(const std::string &host, int port) void connect(const std::string &host, int port) {
{
close(); close();
struct addrinfo hints struct addrinfo hints {};
{};
memset(&hints, 0, sizeof(struct addrinfo)); memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on
hints.ai_socktype = SOCK_STREAM; // TCP hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
hints.ai_protocol = 0; hints.ai_protocol = 0;
auto port_str = std::to_string(port); auto port_str = std::to_string(port);
struct addrinfo *addrinfo_result; struct addrinfo *addrinfo_result;
auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
if (rv != 0) if (rv != 0) {
{
throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv))); throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv)));
} }
// Try each address until we successfully connect(2). // Try each address until we successfully connect(2).
int last_errno = 0; int last_errno = 0;
for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {
{
#if defined(SOCK_CLOEXEC) #if defined(SOCK_CLOEXEC)
const int flags = SOCK_CLOEXEC; const int flags = SOCK_CLOEXEC;
#else #else
const int flags = 0; const int flags = 0;
#endif #endif
socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol); socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);
if (socket_ == -1) if (socket_ == -1) {
{
last_errno = errno; last_errno = errno;
continue; continue;
} }
rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen); rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);
if (rv == 0) if (rv == 0) {
{
break; break;
} }
last_errno = errno; last_errno = errno;
@ -96,45 +78,44 @@ public:
socket_ = -1; socket_ = -1;
} }
::freeaddrinfo(addrinfo_result); ::freeaddrinfo(addrinfo_result);
if (socket_ == -1) if (socket_ == -1) {
{
throw_spdlog_ex("::connect failed", last_errno); throw_spdlog_ex("::connect failed", last_errno);
} }
// set TCP_NODELAY // set TCP_NODELAY
int enable_flag = 1; int enable_flag = 1;
::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag)); ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag),
sizeof(enable_flag));
// prevent sigpipe on systems where MSG_NOSIGNAL is not available // prevent sigpipe on systems where MSG_NOSIGNAL is not available
#if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) #if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag)); ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag),
sizeof(enable_flag));
#endif #endif
#if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
# error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available" #error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
#endif #endif
} }
// Send exactly n_bytes of the given data. // Send exactly n_bytes of the given data.
// On error close the connection and throw. // On error close the connection and throw.
void send(const char *data, size_t n_bytes) void send(const char *data, size_t n_bytes) {
{
size_t bytes_sent = 0; size_t bytes_sent = 0;
while (bytes_sent < n_bytes) while (bytes_sent < n_bytes) {
{
#if defined(MSG_NOSIGNAL) #if defined(MSG_NOSIGNAL)
const int send_flags = MSG_NOSIGNAL; const int send_flags = MSG_NOSIGNAL;
#else #else
const int send_flags = 0; const int send_flags = 0;
#endif #endif
auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags); auto write_result =
if (write_result < 0) ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
{ if (write_result < 0) {
close(); close();
throw_spdlog_ex("write(2) failed", errno); throw_spdlog_ex("write(2) failed", errno);
} }
if (write_result == 0) // (probably should not happen but in any case..) if (write_result == 0) // (probably should not happen but in any case..)
{ {
break; break;
} }
@ -142,5 +123,5 @@ public:
} }
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

132
Tool/spdlog/include/spdlog/details/thread_pool-inl.h
View File

@ -4,26 +4,26 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/details/thread_pool.h> #include <spdlog/details/thread_pool.h>
#endif #endif
#include <spdlog/common.h>
#include <cassert> #include <cassert>
#include <spdlog/common.h>
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE thread_pool::thread_pool( SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop) size_t threads_n,
: q_(q_max_items) std::function<void()> on_thread_start,
{ std::function<void()> on_thread_stop)
if (threads_n == 0 || threads_n > 1000) : q_(q_max_items) {
{ if (threads_n == 0 || threads_n > 1000) {
throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid " throw_spdlog_ex(
"range is 1-1000)"); "spdlog::thread_pool(): invalid threads_n param (valid "
"range is 1-1000)");
} }
for (size_t i = 0; i < threads_n; i++) for (size_t i = 0; i < threads_n; i++) {
{
threads_.emplace_back([this, on_thread_start, on_thread_stop] { threads_.emplace_back([this, on_thread_start, on_thread_stop] {
on_thread_start(); on_thread_start();
this->thread_pool::worker_loop_(); this->thread_pool::worker_loop_();
@ -32,106 +32,96 @@ SPDLOG_INLINE thread_pool::thread_pool(
} }
} }
SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start) SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
: thread_pool(q_max_items, threads_n, on_thread_start, [] {}) size_t threads_n,
{} std::function<void()> on_thread_start)
: thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {}
SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n) SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
: thread_pool( : thread_pool(
q_max_items, threads_n, [] {}, [] {}) q_max_items, threads_n, [] {}, [] {}) {}
{}
// message all threads to terminate gracefully join them // message all threads to terminate gracefully join them
SPDLOG_INLINE thread_pool::~thread_pool() SPDLOG_INLINE thread_pool::~thread_pool() {
{ SPDLOG_TRY {
SPDLOG_TRY for (size_t i = 0; i < threads_.size(); i++) {
{
for (size_t i = 0; i < threads_.size(); i++)
{
post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block); post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
} }
for (auto &t : threads_) for (auto &t : threads_) {
{
t.join(); t.join();
} }
} }
SPDLOG_CATCH_STD SPDLOG_CATCH_STD
} }
void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy) void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr,
{ const details::log_msg &msg,
async_overflow_policy overflow_policy) {
async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg); async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
post_async_msg_(std::move(async_m), overflow_policy); post_async_msg_(std::move(async_m), overflow_policy);
} }
void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy) void SPDLOG_INLINE thread_pool::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); post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
} }
size_t SPDLOG_INLINE thread_pool::overrun_counter() size_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); }
{
return q_.overrun_counter();
}
void SPDLOG_INLINE thread_pool::reset_overrun_counter() void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); }
{
q_.reset_overrun_counter();
}
size_t SPDLOG_INLINE thread_pool::queue_size() size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); }
{
return q_.size();
}
void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); }
{
if (overflow_policy == async_overflow_policy::block) size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); }
{
void SPDLOG_INLINE thread_pool::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)); q_.enqueue(std::move(new_msg));
} } else if (overflow_policy == async_overflow_policy::overrun_oldest) {
else
{
q_.enqueue_nowait(std::move(new_msg)); q_.enqueue_nowait(std::move(new_msg));
} else {
assert(overflow_policy == async_overflow_policy::discard_new);
q_.enqueue_if_have_room(std::move(new_msg));
} }
} }
void SPDLOG_INLINE thread_pool::worker_loop_() void SPDLOG_INLINE thread_pool::worker_loop_() {
{ while (process_next_msg_()) {
while (process_next_msg_()) {} }
} }
// process next message in the queue // process next message in the queue
// return true if this thread should still be active (while no terminate msg // return true if this thread should still be active (while no terminate msg
// was received) // was received)
bool SPDLOG_INLINE thread_pool::process_next_msg_() bool SPDLOG_INLINE thread_pool::process_next_msg_() {
{
async_msg incoming_async_msg; async_msg incoming_async_msg;
q_.dequeue(incoming_async_msg); q_.dequeue(incoming_async_msg);
switch (incoming_async_msg.msg_type) switch (incoming_async_msg.msg_type) {
{ case async_msg_type::log: {
case async_msg_type::log: { incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); return true;
return true; }
} case async_msg_type::flush: {
case async_msg_type::flush: { incoming_async_msg.worker_ptr->backend_flush_();
incoming_async_msg.worker_ptr->backend_flush_(); return true;
return true; }
}
case async_msg_type::terminate: { case async_msg_type::terminate: {
return false; return false;
} }
default: { default: {
assert(false); assert(false);
} }
} }
return true; return true;
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

61
Tool/spdlog/include/spdlog/details/thread_pool.h
View File

@ -8,10 +8,10 @@
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <chrono> #include <chrono>
#include <functional>
#include <memory> #include <memory>
#include <thread> #include <thread>
#include <vector> #include <vector>
#include <functional>
namespace spdlog { namespace spdlog {
class async_logger; class async_logger;
@ -20,17 +20,11 @@ namespace details {
using async_logger_ptr = std::shared_ptr<spdlog::async_logger>; using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
enum class async_msg_type enum class async_msg_type { log, flush, terminate };
{
log,
flush,
terminate
};
// Async msg to move to/from the queue // Async msg to move to/from the queue
// Movable only. should never be copied // Movable only. should never be copied
struct async_msg : log_msg_buffer struct async_msg : log_msg_buffer {
{
async_msg_type msg_type{async_msg_type::log}; async_msg_type msg_type{async_msg_type::log};
async_logger_ptr worker_ptr; async_logger_ptr worker_ptr;
@ -43,48 +37,45 @@ struct async_msg : log_msg_buffer
// support for vs2013 move // support for vs2013 move
#if defined(_MSC_VER) && _MSC_VER <= 1800 #if defined(_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&other) async_msg(async_msg &&other)
: log_msg_buffer(std::move(other)) : log_msg_buffer(std::move(other)),
, msg_type(other.msg_type) msg_type(other.msg_type),
, worker_ptr(std::move(other.worker_ptr)) worker_ptr(std::move(other.worker_ptr)) {}
{}
async_msg &operator=(async_msg &&other) async_msg &operator=(async_msg &&other) {
{
*static_cast<log_msg_buffer *>(this) = std::move(other); *static_cast<log_msg_buffer *>(this) = std::move(other);
msg_type = other.msg_type; msg_type = other.msg_type;
worker_ptr = std::move(other.worker_ptr); worker_ptr = std::move(other.worker_ptr);
return *this; return *this;
} }
#else // (_MSC_VER) && _MSC_VER <= 1800 #else // (_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&) = default; async_msg(async_msg &&) = default;
async_msg &operator=(async_msg &&) = default; async_msg &operator=(async_msg &&) = default;
#endif #endif
// construct from log_msg with given type // construct from log_msg with given type
async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m) async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
: log_msg_buffer{m} : log_msg_buffer{m},
, msg_type{the_type} msg_type{the_type},
, worker_ptr{std::move(worker)} worker_ptr{std::move(worker)} {}
{}
async_msg(async_logger_ptr &&worker, async_msg_type the_type) async_msg(async_logger_ptr &&worker, async_msg_type the_type)
: log_msg_buffer{} : log_msg_buffer{},
, msg_type{the_type} msg_type{the_type},
, worker_ptr{std::move(worker)} worker_ptr{std::move(worker)} {}
{}
explicit async_msg(async_msg_type the_type) explicit async_msg(async_msg_type the_type)
: async_msg{nullptr, the_type} : async_msg{nullptr, the_type} {}
{}
}; };
class SPDLOG_API thread_pool class SPDLOG_API thread_pool {
{
public: public:
using item_type = async_msg; using item_type = async_msg;
using q_type = details::mpmc_blocking_queue<item_type>; using q_type = details::mpmc_blocking_queue<item_type>;
thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop); thread_pool(size_t q_max_items,
size_t threads_n,
std::function<void()> on_thread_start,
std::function<void()> on_thread_stop);
thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start); thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);
thread_pool(size_t q_max_items, size_t threads_n); thread_pool(size_t q_max_items, size_t threads_n);
@ -94,10 +85,14 @@ public:
thread_pool(const thread_pool &) = delete; thread_pool(const thread_pool &) = delete;
thread_pool &operator=(thread_pool &&) = delete; thread_pool &operator=(thread_pool &&) = delete;
void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy); void post_log(async_logger_ptr &&worker_ptr,
const details::log_msg &msg,
async_overflow_policy overflow_policy);
void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy); void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
size_t overrun_counter(); size_t overrun_counter();
void reset_overrun_counter(); void reset_overrun_counter();
size_t discard_counter();
void reset_discard_counter();
size_t queue_size(); size_t queue_size();
private: private:
@ -114,9 +109,9 @@ private:
bool process_next_msg_(); bool process_next_msg_();
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "thread_pool-inl.h" #include "thread_pool-inl.h"
#endif #endif

69
Tool/spdlog/include/spdlog/details/udp_client-windows.h
View File

@ -9,49 +9,44 @@
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <spdlog/details/windows_include.h> #include <spdlog/details/windows_include.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#include <stdlib.h>
#include <stdio.h>
#include <string>
#if defined(_MSC_VER) #if defined(_MSC_VER)
# pragma comment(lib, "Ws2_32.lib") #pragma comment(lib, "Ws2_32.lib")
# pragma comment(lib, "Mswsock.lib") #pragma comment(lib, "Mswsock.lib")
# pragma comment(lib, "AdvApi32.lib") #pragma comment(lib, "AdvApi32.lib")
#endif #endif
namespace spdlog { namespace spdlog {
namespace details { namespace details {
class udp_client class udp_client {
{
static constexpr int TX_BUFFER_SIZE = 1024 * 10; static constexpr int TX_BUFFER_SIZE = 1024 * 10;
SOCKET socket_ = INVALID_SOCKET; SOCKET socket_ = INVALID_SOCKET;
sockaddr_in addr_ = {}; sockaddr_in addr_ = {};
static void init_winsock_() static void init_winsock_() {
{
WSADATA wsaData; WSADATA wsaData;
auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData); auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData);
if (rv != 0) if (rv != 0) {
{
throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
} }
} }
static void throw_winsock_error_(const std::string &msg, int last_error) static void throw_winsock_error_(const std::string &msg, int last_error) {
{
char buf[512]; char buf[512];
::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error, ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,
(sizeof(buf) / sizeof(char)), NULL);
throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf)); throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf));
} }
void cleanup_() void cleanup_() {
{ if (socket_ != INVALID_SOCKET) {
if (socket_ != INVALID_SOCKET)
{
::closesocket(socket_); ::closesocket(socket_);
} }
socket_ = INVALID_SOCKET; socket_ = INVALID_SOCKET;
@ -59,55 +54,45 @@ class udp_client
} }
public: public:
udp_client(const std::string &host, uint16_t port) udp_client(const std::string &host, uint16_t port) {
{
init_winsock_(); init_winsock_();
addr_.sin_family = PF_INET; addr_.sin_family = PF_INET;
addr_.sin_port = htons(port); addr_.sin_port = htons(port);
addr_.sin_addr.s_addr = INADDR_ANY; addr_.sin_addr.s_addr = INADDR_ANY;
if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) {
{
int last_error = ::WSAGetLastError(); int last_error = ::WSAGetLastError();
::WSACleanup(); ::WSACleanup();
throw_winsock_error_("error: Invalid address!", last_error); throw_winsock_error_("error: Invalid address!", last_error);
} }
socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
if (socket_ == INVALID_SOCKET) if (socket_ == INVALID_SOCKET) {
{
int last_error = ::WSAGetLastError(); int last_error = ::WSAGetLastError();
::WSACleanup(); ::WSACleanup();
throw_winsock_error_("error: Create Socket failed", last_error); throw_winsock_error_("error: Create Socket failed", last_error);
} }
int option_value = TX_BUFFER_SIZE; int option_value = TX_BUFFER_SIZE;
if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
{ reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) {
int last_error = ::WSAGetLastError(); int last_error = ::WSAGetLastError();
cleanup_(); cleanup_();
throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error); throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error);
} }
} }
~udp_client() ~udp_client() { cleanup_(); }
{
cleanup_();
}
SOCKET fd() const SOCKET fd() const { return socket_; }
{
return socket_;
}
void send(const char *data, size_t n_bytes) void send(const char *data, size_t n_bytes) {
{
socklen_t tolen = sizeof(struct sockaddr); socklen_t tolen = sizeof(struct sockaddr);
if (::sendto(socket_, data, static_cast<int>(n_bytes), 0, (struct sockaddr *)&addr_, tolen) == -1) if (::sendto(socket_, data, static_cast<int>(n_bytes), 0, (struct sockaddr *)&addr_,
{ tolen) == -1) {
throw_spdlog_ex("sendto(2) failed", errno); throw_spdlog_ex("sendto(2) failed", errno);
} }
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

55
Tool/spdlog/include/spdlog/details/udp_client.h
View File

@ -7,51 +7,46 @@
// Will throw on construction if the socket creation failed. // Will throw on construction if the socket creation failed.
#ifdef _WIN32 #ifdef _WIN32
# error "include udp_client-windows.h instead" #error "include udp_client-windows.h instead"
#endif #endif
#include <arpa/inet.h>
#include <cstring>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/udp.h>
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <cstring>
#include <sys/socket.h> #include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h> #include <unistd.h>
#include <netdb.h>
#include <netinet/udp.h>
#include <string> #include <string>
namespace spdlog { namespace spdlog {
namespace details { namespace details {
class udp_client class udp_client {
{
static constexpr int TX_BUFFER_SIZE = 1024 * 10; static constexpr int TX_BUFFER_SIZE = 1024 * 10;
int socket_ = -1; int socket_ = -1;
struct sockaddr_in sockAddr_; struct sockaddr_in sockAddr_;
void cleanup_() void cleanup_() {
{ if (socket_ != -1) {
if (socket_ != -1)
{
::close(socket_); ::close(socket_);
socket_ = -1; socket_ = -1;
} }
} }
public: public:
udp_client(const std::string &host, uint16_t port) udp_client(const std::string &host, uint16_t port) {
{
socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
if (socket_ < 0) if (socket_ < 0) {
{
throw_spdlog_ex("error: Create Socket Failed!"); throw_spdlog_ex("error: Create Socket Failed!");
} }
int option_value = TX_BUFFER_SIZE; int option_value = TX_BUFFER_SIZE;
if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
{ reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) {
cleanup_(); cleanup_();
throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!"); throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!");
} }
@ -59,8 +54,7 @@ public:
sockAddr_.sin_family = AF_INET; sockAddr_.sin_family = AF_INET;
sockAddr_.sin_port = htons(port); sockAddr_.sin_port = htons(port);
if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) {
{
cleanup_(); cleanup_();
throw_spdlog_ex("error: Invalid address!"); throw_spdlog_ex("error: Invalid address!");
} }
@ -68,27 +62,20 @@ public:
::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero)); ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero));
} }
~udp_client() ~udp_client() { cleanup_(); }
{
cleanup_();
}
int fd() const int fd() const { return socket_; }
{
return socket_;
}
// Send exactly n_bytes of the given data. // Send exactly n_bytes of the given data.
// On error close the connection and throw. // On error close the connection and throw.
void send(const char *data, size_t n_bytes) void send(const char *data, size_t n_bytes) {
{
ssize_t toslen = 0; ssize_t toslen = 0;
socklen_t tolen = sizeof(struct sockaddr); socklen_t tolen = sizeof(struct sockaddr);
if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == -1) if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) ==
{ -1) {
throw_spdlog_ex("sendto(2) failed", errno); throw_spdlog_ex("sendto(2) failed", errno);
} }
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

4
Tool/spdlog/include/spdlog/details/windows_include.h
View File

@ -1,11 +1,11 @@
#pragma once #pragma once
#ifndef NOMINMAX #ifndef NOMINMAX
# define NOMINMAX // prevent windows redefining min/max #define NOMINMAX // prevent windows redefining min/max
#endif #endif
#ifndef WIN32_LEAN_AND_MEAN #ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN
#endif #endif
#include <windows.h> #include <windows.h>

164
Tool/spdlog/include/spdlog/fmt/bin_to_hex.h
View File

@ -9,13 +9,13 @@
#include <spdlog/common.h> #include <spdlog/common.h>
#if defined(__has_include) #if defined(__has_include)
# if __has_include(<version>) #if __has_include(<version>)
# include <version> #include <version>
# endif #endif
#endif #endif
#if __cpp_lib_span >= 202002L #if __cpp_lib_span >= 202002L
# include <span> #include <span>
#endif #endif
// //
@ -39,53 +39,43 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
template<typename It> template <typename It>
class dump_info class dump_info {
{
public: public:
dump_info(It range_begin, It range_end, size_t size_per_line) dump_info(It range_begin, It range_end, size_t size_per_line)
: begin_(range_begin) : begin_(range_begin),
, end_(range_end) end_(range_end),
, size_per_line_(size_per_line) size_per_line_(size_per_line) {}
{}
// do not use begin() and end() to avoid collision with fmt/ranges // do not use begin() and end() to avoid collision with fmt/ranges
It get_begin() const It get_begin() const { return begin_; }
{ It get_end() const { return end_; }
return begin_; size_t size_per_line() const { return size_per_line_; }
}
It get_end() const
{
return end_;
}
size_t size_per_line() const
{
return size_per_line_;
}
private: private:
It begin_, end_; It begin_, end_;
size_t size_per_line_; size_t size_per_line_;
}; };
} // namespace details } // namespace details
// create a dump_info that wraps the given container // create a dump_info that wraps the given container
template<typename Container> template <typename Container>
inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container, size_t size_per_line = 32) inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container,
{ size_t size_per_line = 32) {
static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); static_assert(sizeof(typename Container::value_type) == 1,
"sizeof(Container::value_type) != 1");
using Iter = typename Container::const_iterator; using Iter = typename Container::const_iterator;
return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line); return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
} }
#if __cpp_lib_span >= 202002L #if __cpp_lib_span >= 202002L
template<typename Value, size_t Extent> template <typename Value, size_t Extent>
inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex( inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
const std::span<Value, Extent> &container, size_t size_per_line = 32) const std::span<Value, Extent> &container, size_t size_per_line = 32) {
{
using Container = std::span<Value, Extent>; using Container = std::span<Value, Extent>;
static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); static_assert(sizeof(typename Container::value_type) == 1,
"sizeof(Container::value_type) != 1");
using Iter = typename Container::iterator; using Iter = typename Container::iterator;
return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line); return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
} }
@ -93,13 +83,14 @@ inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
#endif #endif
// create dump_info from ranges // create dump_info from ranges
template<typename It> template <typename It>
inline details::dump_info<It> to_hex(const It range_begin, const It range_end, size_t size_per_line = 32) inline details::dump_info<It> to_hex(const It range_begin,
{ const It range_end,
size_t size_per_line = 32) {
return details::dump_info<It>(range_begin, range_end, size_per_line); return details::dump_info<It>(range_begin, range_end, size_per_line);
} }
} // namespace spdlog } // namespace spdlog
namespace namespace
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
@ -109,44 +100,39 @@ namespace
#endif #endif
{ {
template<typename T> template <typename T>
struct formatter<spdlog::details::dump_info<T>, char> struct formatter<spdlog::details::dump_info<T>, char> {
{
const char delimiter = ' '; const char delimiter = ' ';
bool put_newlines = true; bool put_newlines = true;
bool put_delimiters = true; bool put_delimiters = true;
bool use_uppercase = false; bool use_uppercase = false;
bool put_positions = true; // position on start of each line bool put_positions = true; // position on start of each line
bool show_ascii = false; bool show_ascii = false;
// parse the format string flags // parse the format string flags
template<typename ParseContext> template <typename ParseContext>
SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
{
auto it = ctx.begin(); auto it = ctx.begin();
while (it != ctx.end() && *it != '}') while (it != ctx.end() && *it != '}') {
{ switch (*it) {
switch (*it) case 'X':
{ use_uppercase = true;
case 'X': break;
use_uppercase = true; case 's':
break; put_delimiters = false;
case 's': break;
put_delimiters = false; case 'p':
break; put_positions = false;
case 'p': break;
put_positions = false; case 'n':
break; put_newlines = false;
case 'n': show_ascii = false;
put_newlines = false; break;
show_ascii = false; case 'a':
break; if (put_newlines) {
case 'a': show_ascii = true;
if (put_newlines) }
{ break;
show_ascii = true;
}
break;
} }
++it; ++it;
@ -155,9 +141,9 @@ struct formatter<spdlog::details::dump_info<T>, char>
} }
// format the given bytes range as hex // format the given bytes range as hex
template<typename FormatContext, typename Container> template <typename FormatContext, typename Container>
auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) const -> decltype(ctx.out()) auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) const
{ -> decltype(ctx.out()) {
SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF"; SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef"; SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
const char *hex_chars = use_uppercase ? hex_upper : hex_lower; const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
@ -170,18 +156,15 @@ struct formatter<spdlog::details::dump_info<T>, char>
int size_per_line = static_cast<int>(the_range.size_per_line()); int size_per_line = static_cast<int>(the_range.size_per_line());
auto start_of_line = the_range.get_begin(); auto start_of_line = the_range.get_begin();
for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) {
{
auto ch = static_cast<unsigned char>(*i); auto ch = static_cast<unsigned char>(*i);
if (put_newlines && (i == the_range.get_begin() || i - start_of_line >= size_per_line)) if (put_newlines &&
{ (i == the_range.get_begin() || i - start_of_line >= size_per_line)) {
if (show_ascii && i != the_range.get_begin()) if (show_ascii && i != the_range.get_begin()) {
{
*inserter++ = delimiter; *inserter++ = delimiter;
*inserter++ = delimiter; *inserter++ = delimiter;
for (auto j = start_of_line; j < i; j++) for (auto j = start_of_line; j < i; j++) {
{
auto pc = static_cast<unsigned char>(*j); auto pc = static_cast<unsigned char>(*j);
*inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.'; *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
} }
@ -196,33 +179,28 @@ struct formatter<spdlog::details::dump_info<T>, char>
continue; continue;
} }
if (put_delimiters && i != the_range.get_begin()) if (put_delimiters && i != the_range.get_begin()) {
{
*inserter++ = delimiter; *inserter++ = delimiter;
} }
*inserter++ = hex_chars[(ch >> 4) & 0x0f]; *inserter++ = hex_chars[(ch >> 4) & 0x0f];
*inserter++ = hex_chars[ch & 0x0f]; *inserter++ = hex_chars[ch & 0x0f];
} }
if (show_ascii) // add ascii to last line if (show_ascii) // add ascii to last line
{ {
if (the_range.get_end() - the_range.get_begin() > size_per_line) if (the_range.get_end() - the_range.get_begin() > size_per_line) {
{
auto blank_num = size_per_line - (the_range.get_end() - start_of_line); auto blank_num = size_per_line - (the_range.get_end() - start_of_line);
while (blank_num-- > 0) while (blank_num-- > 0) {
{
*inserter++ = delimiter; *inserter++ = delimiter;
*inserter++ = delimiter; *inserter++ = delimiter;
if (put_delimiters) if (put_delimiters) {
{
*inserter++ = delimiter; *inserter++ = delimiter;
} }
} }
} }
*inserter++ = delimiter; *inserter++ = delimiter;
*inserter++ = delimiter; *inserter++ = delimiter;
for (auto j = start_of_line; j != the_range.get_end(); j++) for (auto j = start_of_line; j != the_range.get_end(); j++) {
{
auto pc = static_cast<unsigned char>(*j); auto pc = static_cast<unsigned char>(*j);
*inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.'; *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
} }
@ -231,18 +209,16 @@ struct formatter<spdlog::details::dump_info<T>, char>
} }
// put newline(and position header) // put newline(and position header)
template<typename It> template <typename It>
void put_newline(It inserter, std::size_t pos) const void put_newline(It inserter, std::size_t pos) const {
{
#ifdef _WIN32 #ifdef _WIN32
*inserter++ = '\r'; *inserter++ = '\r';
#endif #endif
*inserter++ = '\n'; *inserter++ = '\n';
if (put_positions) if (put_positions) {
{
spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos); spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos);
} }
} }
}; };
} // namespace std } // namespace std

128
Tool/spdlog/include/spdlog/fmt/bundled/args.h
View File

@ -1,4 +1,4 @@
// Formatting library for C++ - dynamic format arguments // Formatting library for C++ - dynamic argument lists
// //
// Copyright (c) 2012 - present, Victor Zverovich // Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved. // All rights reserved.
@ -8,11 +8,13 @@
#ifndef FMT_ARGS_H_ #ifndef FMT_ARGS_H_
#define FMT_ARGS_H_ #define FMT_ARGS_H_
#include <functional> // std::reference_wrapper #ifndef FMT_MODULE
#include <memory> // std::unique_ptr # include <functional> // std::reference_wrapper
#include <vector> # include <memory> // std::unique_ptr
# include <vector>
#endif
#include "core.h" #include "format.h" // std_string_view
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
@ -22,20 +24,24 @@ template <typename T> struct is_reference_wrapper : std::false_type {};
template <typename T> template <typename T>
struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {}; struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
template <typename T> const T& unwrap(const T& v) { return v; } template <typename T> auto unwrap(const T& v) -> const T& { return v; }
template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) { template <typename T>
auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
return static_cast<const T&>(v); return static_cast<const T&>(v);
} }
class dynamic_arg_list { // node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for // 2022 (v17.10.0).
// templates it doesn't complain about inability to deduce single translation //
// unit for placing vtable. So storage_node_base is made a fake template. // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
template <typename = void> struct node { // templates it doesn't complain about inability to deduce single translation
virtual ~node() = default; // unit for placing vtable. So node is made a fake template.
std::unique_ptr<node<>> next; template <typename = void> struct node {
}; virtual ~node() = default;
std::unique_ptr<node<>> next;
};
class dynamic_arg_list {
template <typename T> struct typed_node : node<> { template <typename T> struct typed_node : node<> {
T value; T value;
@ -50,7 +56,7 @@ class dynamic_arg_list {
std::unique_ptr<node<>> head_; std::unique_ptr<node<>> head_;
public: public:
template <typename T, typename Arg> const T& push(const Arg& arg) { template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg)); auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
auto& value = new_node->value; auto& value = new_node->value;
new_node->next = std::move(head_); new_node->next = std::move(head_);
@ -61,14 +67,10 @@ class dynamic_arg_list {
} // namespace detail } // namespace detail
/** /**
\rst * A dynamic list of formatting arguments with storage.
A dynamic version of `fmt::format_arg_store`. *
It's equipped with a storage to potentially temporary objects which lifetimes * It can be implicitly converted into `fmt::basic_format_args` for passing
could be shorter than the format arguments object. * into type-erased formatting functions such as `fmt::vformat`.
It can be implicitly converted into `~fmt::basic_format_args` for passing
into type-erased formatting functions such as `~fmt::vformat`.
\endrst
*/ */
template <typename Context> template <typename Context>
class dynamic_format_arg_store class dynamic_format_arg_store
@ -110,14 +112,14 @@ class dynamic_format_arg_store
friend class basic_format_args<Context>; friend class basic_format_args<Context>;
unsigned long long get_types() const { auto get_types() const -> unsigned long long {
return detail::is_unpacked_bit | data_.size() | return detail::is_unpacked_bit | data_.size() |
(named_info_.empty() (named_info_.empty()
? 0ULL ? 0ULL
: static_cast<unsigned long long>(detail::has_named_args_bit)); : static_cast<unsigned long long>(detail::has_named_args_bit));
} }
const basic_format_arg<Context>* data() const { auto data() const -> const basic_format_arg<Context>* {
return named_info_.empty() ? data_.data() : data_.data() + 1; return named_info_.empty() ? data_.data() : data_.data() + 1;
} }
@ -146,22 +148,20 @@ class dynamic_format_arg_store
constexpr dynamic_format_arg_store() = default; constexpr dynamic_format_arg_store() = default;
/** /**
\rst * Adds an argument into the dynamic store for later passing to a formatting
Adds an argument into the dynamic store for later passing to a formatting * function.
function. *
* Note that custom types and string types (but not string views) are copied
Note that custom types and string types (but not string views) are copied * into the store dynamically allocating memory if necessary.
into the store dynamically allocating memory if necessary. *
* **Example**:
**Example**:: *
* fmt::dynamic_format_arg_store<fmt::format_context> store;
fmt::dynamic_format_arg_store<fmt::format_context> store; * store.push_back(42);
store.push_back(42); * store.push_back("abc");
store.push_back("abc"); * store.push_back(1.5f);
store.push_back(1.5f); * std::string result = fmt::vformat("{} and {} and {}", store);
std::string result = fmt::vformat("{} and {} and {}", store); */
\endrst
*/
template <typename T> void push_back(const T& arg) { template <typename T> void push_back(const T& arg) {
if (detail::const_check(need_copy<T>::value)) if (detail::const_check(need_copy<T>::value))
emplace_arg(dynamic_args_.push<stored_type<T>>(arg)); emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
@ -170,20 +170,18 @@ class dynamic_format_arg_store
} }
/** /**
\rst * Adds a reference to the argument into the dynamic store for later passing
Adds a reference to the argument into the dynamic store for later passing to * to a formatting function.
a formatting function. *
* **Example**:
**Example**:: *
* fmt::dynamic_format_arg_store<fmt::format_context> store;
fmt::dynamic_format_arg_store<fmt::format_context> store; * char band[] = "Rolling Stones";
char band[] = "Rolling Stones"; * store.push_back(std::cref(band));
store.push_back(std::cref(band)); * band[9] = 'c'; // Changing str affects the output.
band[9] = 'c'; // Changing str affects the output. * std::string result = fmt::vformat("{}", store);
std::string result = fmt::vformat("{}", store); * // result == "Rolling Scones"
// result == "Rolling Scones" */
\endrst
*/
template <typename T> void push_back(std::reference_wrapper<T> arg) { template <typename T> void push_back(std::reference_wrapper<T> arg) {
static_assert( static_assert(
need_copy<T>::value, need_copy<T>::value,
@ -192,10 +190,10 @@ class dynamic_format_arg_store
} }
/** /**
Adds named argument into the dynamic store for later passing to a formatting * Adds named argument into the dynamic store for later passing to a
function. ``std::reference_wrapper`` is supported to avoid copying of the * formatting function. `std::reference_wrapper` is supported to avoid
argument. The name is always copied into the store. * copying of the argument. The name is always copied into the store.
*/ */
template <typename T> template <typename T>
void push_back(const detail::named_arg<char_type, T>& arg) { void push_back(const detail::named_arg<char_type, T>& arg) {
const char_type* arg_name = const char_type* arg_name =
@ -208,19 +206,15 @@ class dynamic_format_arg_store
} }
} }
/** Erase all elements from the store */ /// Erase all elements from the store.
void clear() { void clear() {
data_.clear(); data_.clear();
named_info_.clear(); named_info_.clear();
dynamic_args_ = detail::dynamic_arg_list(); dynamic_args_ = detail::dynamic_arg_list();
} }
/** /// Reserves space to store at least `new_cap` arguments including
\rst /// `new_cap_named` named arguments.
Reserves space to store at least *new_cap* arguments including
*new_cap_named* named arguments.
\endrst
*/
void reserve(size_t new_cap, size_t new_cap_named) { void reserve(size_t new_cap, size_t new_cap_named) {
FMT_ASSERT(new_cap >= new_cap_named, FMT_ASSERT(new_cap >= new_cap_named,
"Set of arguments includes set of named arguments"); "Set of arguments includes set of named arguments");

3077
Tool/spdlog/include/spdlog/fmt/bundled/base.h Normal file
View File

File diff suppressed because it is too large Load Diff

1381
Tool/spdlog/include/spdlog/fmt/bundled/chrono.h
View File

File diff suppressed because it is too large Load Diff

283
Tool/spdlog/include/spdlog/fmt/bundled/color.h
View File

@ -11,7 +11,7 @@
#include "format.h" #include "format.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN FMT_BEGIN_EXPORT
enum class color : uint32_t { enum class color : uint32_t {
alice_blue = 0xF0F8FF, // rgb(240,248,255) alice_blue = 0xF0F8FF, // rgb(240,248,255)
@ -203,7 +203,7 @@ struct rgb {
uint8_t b; uint8_t b;
}; };
FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
// color is a struct of either a rgb color or a terminal color. // color is a struct of either a rgb color or a terminal color.
struct color_type { struct color_type {
@ -225,22 +225,21 @@ struct color_type {
uint32_t rgb_color; uint32_t rgb_color;
} value; } value;
}; };
} // namespace detail
FMT_END_DETAIL_NAMESPACE /// A text style consisting of foreground and background colors and emphasis.
/** A text style consisting of foreground and background colors and emphasis. */
class text_style { class text_style {
public: public:
FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
: set_foreground_color(), set_background_color(), ems(em) {} : set_foreground_color(), set_background_color(), ems(em) {}
FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) { FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
if (!set_foreground_color) { if (!set_foreground_color) {
set_foreground_color = rhs.set_foreground_color; set_foreground_color = rhs.set_foreground_color;
foreground_color = rhs.foreground_color; foreground_color = rhs.foreground_color;
} else if (rhs.set_foreground_color) { } else if (rhs.set_foreground_color) {
if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
FMT_THROW(format_error("can't OR a terminal color")); report_error("can't OR a terminal color");
foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
} }
@ -249,7 +248,7 @@ class text_style {
background_color = rhs.background_color; background_color = rhs.background_color;
} else if (rhs.set_background_color) { } else if (rhs.set_background_color) {
if (!background_color.is_rgb || !rhs.background_color.is_rgb) if (!background_color.is_rgb || !rhs.background_color.is_rgb)
FMT_THROW(format_error("can't OR a terminal color")); report_error("can't OR a terminal color");
background_color.value.rgb_color |= rhs.background_color.value.rgb_color; background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
} }
@ -258,29 +257,29 @@ class text_style {
return *this; return *this;
} }
friend FMT_CONSTEXPR text_style operator|(text_style lhs, friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
const text_style& rhs) { -> text_style {
return lhs |= rhs; return lhs |= rhs;
} }
FMT_CONSTEXPR bool has_foreground() const noexcept { FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
return set_foreground_color; return set_foreground_color;
} }
FMT_CONSTEXPR bool has_background() const noexcept { FMT_CONSTEXPR auto has_background() const noexcept -> bool {
return set_background_color; return set_background_color;
} }
FMT_CONSTEXPR bool has_emphasis() const noexcept { FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
return static_cast<uint8_t>(ems) != 0; return static_cast<uint8_t>(ems) != 0;
} }
FMT_CONSTEXPR detail::color_type get_foreground() const noexcept { FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
FMT_ASSERT(has_foreground(), "no foreground specified for this style"); FMT_ASSERT(has_foreground(), "no foreground specified for this style");
return foreground_color; return foreground_color;
} }
FMT_CONSTEXPR detail::color_type get_background() const noexcept { FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
FMT_ASSERT(has_background(), "no background specified for this style"); FMT_ASSERT(has_background(), "no background specified for this style");
return background_color; return background_color;
} }
FMT_CONSTEXPR emphasis get_emphasis() const noexcept { FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
return ems; return ems;
} }
@ -298,9 +297,11 @@ class text_style {
} }
} }
friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept; friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
-> text_style;
friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept; friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
-> text_style;
detail::color_type foreground_color; detail::color_type foreground_color;
detail::color_type background_color; detail::color_type background_color;
@ -309,21 +310,24 @@ class text_style {
emphasis ems; emphasis ems;
}; };
/** Creates a text style from the foreground (text) color. */ /// Creates a text style from the foreground (text) color.
FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept { FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
-> text_style {
return text_style(true, foreground); return text_style(true, foreground);
} }
/** Creates a text style from the background color. */ /// Creates a text style from the background color.
FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept { FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
-> text_style {
return text_style(false, background); return text_style(false, background);
} }
FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept { FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
-> text_style {
return text_style(lhs) | rhs; return text_style(lhs) | rhs;
} }
FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
template <typename Char> struct ansi_color_escape { template <typename Char> struct ansi_color_escape {
FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
@ -385,9 +389,9 @@ template <typename Char> struct ansi_color_escape {
} }
FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; } FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept { FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
return buffer + std::char_traits<Char>::length(buffer); return buffer + basic_string_view<Char>(buffer).size();
} }
private: private:
@ -401,62 +405,45 @@ template <typename Char> struct ansi_color_escape {
out[2] = static_cast<Char>('0' + c % 10); out[2] = static_cast<Char>('0' + c % 10);
out[3] = static_cast<Char>(delimiter); out[3] = static_cast<Char>(delimiter);
} }
static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept { static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
-> bool {
return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask); return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
} }
}; };
template <typename Char> template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color( FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
detail::color_type foreground) noexcept { -> ansi_color_escape<Char> {
return ansi_color_escape<Char>(foreground, "\x1b[38;2;"); return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
} }
template <typename Char> template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_background_color( FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
detail::color_type background) noexcept { -> ansi_color_escape<Char> {
return ansi_color_escape<Char>(background, "\x1b[48;2;"); return ansi_color_escape<Char>(background, "\x1b[48;2;");
} }
template <typename Char> template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept { FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
-> ansi_color_escape<Char> {
return ansi_color_escape<Char>(em); return ansi_color_escape<Char>(em);
} }
template <typename Char> inline void fputs(const Char* chars, FILE* stream) {
int result = std::fputs(chars, stream);
if (result < 0)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}
template <> inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) {
int result = std::fputws(chars, stream);
if (result < 0)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}
template <typename Char> inline void reset_color(FILE* stream) {
fputs("\x1b[0m", stream);
}
template <> inline void reset_color<wchar_t>(FILE* stream) {
fputs(L"\x1b[0m", stream);
}
template <typename Char> inline void reset_color(buffer<Char>& buffer) { template <typename Char> inline void reset_color(buffer<Char>& buffer) {
auto reset_color = string_view("\x1b[0m"); auto reset_color = string_view("\x1b[0m");
buffer.append(reset_color.begin(), reset_color.end()); buffer.append(reset_color.begin(), reset_color.end());
} }
template <typename T> struct styled_arg { template <typename T> struct styled_arg : detail::view {
const T& value; const T& value;
text_style style; text_style style;
styled_arg(const T& v, text_style s) : value(v), style(s) {}
}; };
template <typename Char> template <typename Char>
void vformat_to(buffer<Char>& buf, const text_style& ts, void vformat_to(
basic_string_view<Char> format_str, buffer<Char>& buf, const text_style& ts, basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) { basic_format_args<buffered_context<type_identity_t<Char>>> args) {
bool has_style = false; bool has_style = false;
if (ts.has_emphasis()) { if (ts.has_emphasis()) {
has_style = true; has_style = true;
@ -477,118 +464,94 @@ void vformat_to(buffer<Char>& buf, const text_style& ts,
if (has_style) detail::reset_color<Char>(buf); if (has_style) detail::reset_color<Char>(buf);
} }
FMT_END_DETAIL_NAMESPACE } // namespace detail
template <typename S, typename Char = char_t<S>> inline void vprint(FILE* f, const text_style& ts, string_view fmt,
void vprint(std::FILE* f, const text_style& ts, const S& format, format_args args) {
basic_format_args<buffer_context<type_identity_t<Char>>> args) { auto buf = memory_buffer();
basic_memory_buffer<Char> buf; detail::vformat_to(buf, ts, fmt, args);
detail::vformat_to(buf, ts, detail::to_string_view(format), args); print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
if (detail::is_utf8()) {
detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
} else {
buf.push_back(Char(0));
detail::fputs(buf.data(), f);
}
} }
/** /**
\rst * Formats a string and prints it to the specified file stream using ANSI
Formats a string and prints it to the specified file stream using ANSI * escape sequences to specify text formatting.
escape sequences to specify text formatting. *
* **Example**:
**Example**:: *
* fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
fmt::print(fmt::emphasis::bold | fg(fmt::color::red), * "Elapsed time: {0:.2f} seconds", 1.23);
"Elapsed time: {0:.2f} seconds", 1.23);
\endrst
*/ */
template <typename S, typename... Args, template <typename... T>
FMT_ENABLE_IF(detail::is_string<S>::value)> void print(FILE* f, const text_style& ts, format_string<T...> fmt,
void print(std::FILE* f, const text_style& ts, const S& format_str, T&&... args) {
const Args&... args) { vprint(f, ts, fmt, fmt::make_format_args(args...));
vprint(f, ts, format_str,
fmt::make_format_args<buffer_context<char_t<S>>>(args...));
} }
/** /**
\rst * Formats a string and prints it to stdout using ANSI escape sequences to
Formats a string and prints it to stdout using ANSI escape sequences to * specify text formatting.
specify text formatting. *
* **Example**:
**Example**:: *
* fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
fmt::print(fmt::emphasis::bold | fg(fmt::color::red), * "Elapsed time: {0:.2f} seconds", 1.23);
"Elapsed time: {0:.2f} seconds", 1.23);
\endrst
*/ */
template <typename S, typename... Args, template <typename... T>
FMT_ENABLE_IF(detail::is_string<S>::value)> void print(const text_style& ts, format_string<T...> fmt, T&&... args) {
void print(const text_style& ts, const S& format_str, const Args&... args) { return print(stdout, ts, fmt, std::forward<T>(args)...);
return print(stdout, ts, format_str, args...);
} }
template <typename S, typename Char = char_t<S>> inline auto vformat(const text_style& ts, string_view fmt, format_args args)
inline std::basic_string<Char> vformat( -> std::string {
const text_style& ts, const S& format_str, auto buf = memory_buffer();
basic_format_args<buffer_context<type_identity_t<Char>>> args) { detail::vformat_to(buf, ts, fmt, args);
basic_memory_buffer<Char> buf;
detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
return fmt::to_string(buf); return fmt::to_string(buf);
} }
/** /**
\rst * Formats arguments and returns the result as a string using ANSI escape
Formats arguments and returns the result as a string using ANSI * sequences to specify text formatting.
escape sequences to specify text formatting. *
* **Example**:
**Example**:: *
* ```
#include <fmt/color.h> * #include <fmt/color.h>
std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
"The answer is {}", 42); * "The answer is {}", 42);
\endrst * ```
*/
template <typename S, typename... Args, typename Char = char_t<S>>
inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
const Args&... args) {
return fmt::vformat(ts, detail::to_string_view(format_str),
fmt::make_format_args<buffer_context<Char>>(args...));
}
/**
Formats a string with the given text_style and writes the output to ``out``.
*/ */
template <typename OutputIt, typename Char, template <typename... T>
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)> inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
OutputIt vformat_to( -> std::string {
OutputIt out, const text_style& ts, basic_string_view<Char> format_str, return fmt::vformat(ts, fmt, fmt::make_format_args(args...));
basic_format_args<buffer_context<type_identity_t<Char>>> args) { }
auto&& buf = detail::get_buffer<Char>(out);
detail::vformat_to(buf, ts, format_str, args); /// Formats a string with the given text_style and writes the output to `out`.
return detail::get_iterator(buf); template <typename OutputIt,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
auto vformat_to(OutputIt out, const text_style& ts, string_view fmt,
format_args args) -> OutputIt {
auto&& buf = detail::get_buffer<char>(out);
detail::vformat_to(buf, ts, fmt, args);
return detail::get_iterator(buf, out);
} }
/** /**
\rst * Formats arguments with the given text style, writes the result to the output
Formats arguments with the given text_style, writes the result to the output * iterator `out` and returns the iterator past the end of the output range.
iterator ``out`` and returns the iterator past the end of the output range. *
* **Example**:
**Example**:: *
* std::vector<char> out;
std::vector<char> out; * fmt::format_to(std::back_inserter(out),
fmt::format_to(std::back_inserter(out), * fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); */
\endrst template <typename OutputIt, typename... T,
*/ FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
template <typename OutputIt, typename S, typename... Args, inline auto format_to(OutputIt out, const text_style& ts,
bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&& format_string<T...> fmt, T&&... args) -> OutputIt {
detail::is_string<S>::value> return vformat_to(out, ts, fmt, fmt::make_format_args(args...));
inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
return vformat_to(out, ts, detail::to_string_view(format_str),
fmt::make_format_args<buffer_context<char_t<S>>>(args...));
} }
template <typename T, typename Char> template <typename T, typename Char>
@ -628,16 +591,14 @@ struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
}; };
/** /**
\rst * Returns an argument that will be formatted using ANSI escape sequences,
Returns an argument that will be formatted using ANSI escape sequences, * to be used in a formatting function.
to be used in a formatting function. *
* **Example**:
**Example**:: *
* fmt::print("Elapsed time: {0:.2f} seconds",
fmt::print("Elapsed time: {0:.2f} seconds", * fmt::styled(1.23, fmt::fg(fmt::color::green) |
fmt::styled(1.23, fmt::fg(fmt::color::green) | * fmt::bg(fmt::color::blue)));
fmt::bg(fmt::color::blue)));
\endrst
*/ */
template <typename T> template <typename T>
FMT_CONSTEXPR auto styled(const T& value, text_style ts) FMT_CONSTEXPR auto styled(const T& value, text_style ts)
@ -645,7 +606,7 @@ FMT_CONSTEXPR auto styled(const T& value, text_style ts)
return detail::styled_arg<remove_cvref_t<T>>{value, ts}; return detail::styled_arg<remove_cvref_t<T>>{value, ts};
} }
FMT_MODULE_EXPORT_END FMT_END_EXPORT
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // FMT_COLOR_H_ #endif // FMT_COLOR_H_

242
Tool/spdlog/include/spdlog/fmt/bundled/compile.h
View File

@ -8,117 +8,41 @@
#ifndef FMT_COMPILE_H_ #ifndef FMT_COMPILE_H_
#define FMT_COMPILE_H_ #define FMT_COMPILE_H_
#ifndef FMT_MODULE
# include <iterator> // std::back_inserter
#endif
#include "format.h" #include "format.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
namespace detail {
template <typename Char, typename InputIt>
FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
counting_iterator it) {
return it + (end - begin);
}
template <typename OutputIt> class truncating_iterator_base {
protected:
OutputIt out_;
size_t limit_;
size_t count_ = 0;
truncating_iterator_base() : out_(), limit_(0) {}
truncating_iterator_base(OutputIt out, size_t limit)
: out_(out), limit_(limit) {}
public:
using iterator_category = std::output_iterator_tag;
using value_type = typename std::iterator_traits<OutputIt>::value_type;
using difference_type = std::ptrdiff_t;
using pointer = void;
using reference = void;
FMT_UNCHECKED_ITERATOR(truncating_iterator_base);
OutputIt base() const { return out_; }
size_t count() const { return count_; }
};
// An output iterator that truncates the output and counts the number of objects
// written to it.
template <typename OutputIt,
typename Enable = typename std::is_void<
typename std::iterator_traits<OutputIt>::value_type>::type>
class truncating_iterator;
template <typename OutputIt>
class truncating_iterator<OutputIt, std::false_type>
: public truncating_iterator_base<OutputIt> {
mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
public:
using value_type = typename truncating_iterator_base<OutputIt>::value_type;
truncating_iterator() = default;
truncating_iterator(OutputIt out, size_t limit)
: truncating_iterator_base<OutputIt>(out, limit) {}
truncating_iterator& operator++() {
if (this->count_++ < this->limit_) ++this->out_;
return *this;
}
truncating_iterator operator++(int) {
auto it = *this;
++*this;
return it;
}
value_type& operator*() const {
return this->count_ < this->limit_ ? *this->out_ : blackhole_;
}
};
template <typename OutputIt>
class truncating_iterator<OutputIt, std::true_type>
: public truncating_iterator_base<OutputIt> {
public:
truncating_iterator() = default;
truncating_iterator(OutputIt out, size_t limit)
: truncating_iterator_base<OutputIt>(out, limit) {}
template <typename T> truncating_iterator& operator=(T val) {
if (this->count_++ < this->limit_) *this->out_++ = val;
return *this;
}
truncating_iterator& operator++() { return *this; }
truncating_iterator& operator++(int) { return *this; }
truncating_iterator& operator*() { return *this; }
};
// A compile-time string which is compiled into fast formatting code. // A compile-time string which is compiled into fast formatting code.
class compiled_string {}; FMT_EXPORT class compiled_string {};
namespace detail {
template <typename T, typename InputIt>
FMT_CONSTEXPR inline auto copy(InputIt begin, InputIt end, counting_iterator it)
-> counting_iterator {
return it + (end - begin);
}
template <typename S> template <typename S>
struct is_compiled_string : std::is_base_of<compiled_string, S> {}; struct is_compiled_string : std::is_base_of<compiled_string, S> {};
/** /**
\rst * Converts a string literal `s` into a format string that will be parsed at
Converts a string literal *s* into a format string that will be parsed at * compile time and converted into efficient formatting code. Requires C++17
compile time and converted into efficient formatting code. Requires C++17 * `constexpr if` compiler support.
``constexpr if`` compiler support. *
* **Example**:
**Example**:: *
* // Converts 42 into std::string using the most efficient method and no
// Converts 42 into std::string using the most efficient method and no * // runtime format string processing.
// runtime format string processing. * std::string s = fmt::format(FMT_COMPILE("{}"), 42);
std::string s = fmt::format(FMT_COMPILE("{}"), 42);
\endrst
*/ */
#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
# define FMT_COMPILE(s) \ # define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string, explicit)
FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
#else #else
# define FMT_COMPILE(s) FMT_STRING(s) # define FMT_COMPILE(s) FMT_STRING(s)
#endif #endif
@ -135,7 +59,7 @@ struct udl_compiled_string : compiled_string {
#endif #endif
template <typename T, typename... Tail> template <typename T, typename... Tail>
const T& first(const T& value, const Tail&...) { auto first(const T& value, const Tail&...) -> const T& {
return value; return value;
} }
@ -196,7 +120,8 @@ template <typename Char> struct code_unit {
template <typename OutputIt, typename... Args> template <typename OutputIt, typename... Args>
constexpr OutputIt format(OutputIt out, const Args&...) const { constexpr OutputIt format(OutputIt out, const Args&...) const {
return write<Char>(out, value); *out++ = value;
return out;
} }
}; };
@ -220,7 +145,12 @@ template <typename Char, typename T, int N> struct field {
template <typename OutputIt, typename... Args> template <typename OutputIt, typename... Args>
constexpr OutputIt format(OutputIt out, const Args&... args) const { constexpr OutputIt format(OutputIt out, const Args&... args) const {
return write<Char>(out, get_arg_checked<T, N>(args...)); const T& arg = get_arg_checked<T, N>(args...);
if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
auto s = basic_string_view<Char>(arg);
return copy<Char>(s.begin(), s.end(), out);
}
return write<Char>(out, arg);
} }
}; };
@ -308,13 +238,12 @@ constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
} }
template <typename Args, size_t POS, int ID, typename S> template <typename Args, size_t POS, int ID, typename S>
constexpr auto compile_format_string(S format_str); constexpr auto compile_format_string(S fmt);
template <typename Args, size_t POS, int ID, typename T, typename S> template <typename Args, size_t POS, int ID, typename T, typename S>
constexpr auto parse_tail(T head, S format_str) { constexpr auto parse_tail(T head, S fmt) {
if constexpr (POS != if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
basic_string_view<typename S::char_type>(format_str).size()) { constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
if constexpr (std::is_same<remove_cvref_t<decltype(tail)>, if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
unknown_format>()) unknown_format>())
return tail; return tail;
@ -331,14 +260,14 @@ template <typename T, typename Char> struct parse_specs_result {
int next_arg_id; int next_arg_id;
}; };
constexpr int manual_indexing_id = -1; enum { manual_indexing_id = -1 };
template <typename T, typename Char> template <typename T, typename Char>
constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str, constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
size_t pos, int next_arg_id) { size_t pos, int next_arg_id) {
str.remove_prefix(pos); str.remove_prefix(pos);
auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, {}, auto ctx =
next_arg_id); compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
auto f = formatter<T, Char>(); auto f = formatter<T, Char>();
auto end = f.parse(ctx); auto end = f.parse(ctx);
return {f, pos + fmt::detail::to_unsigned(end - str.data()), return {f, pos + fmt::detail::to_unsigned(end - str.data()),
@ -348,22 +277,18 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
template <typename Char> struct arg_id_handler { template <typename Char> struct arg_id_handler {
arg_ref<Char> arg_id; arg_ref<Char> arg_id;
constexpr int operator()() { constexpr int on_auto() {
FMT_ASSERT(false, "handler cannot be used with automatic indexing"); FMT_ASSERT(false, "handler cannot be used with automatic indexing");
return 0; return 0;
} }
constexpr int operator()(int id) { constexpr int on_index(int id) {
arg_id = arg_ref<Char>(id); arg_id = arg_ref<Char>(id);
return 0; return 0;
} }
constexpr int operator()(basic_string_view<Char> id) { constexpr int on_name(basic_string_view<Char> id) {
arg_id = arg_ref<Char>(id); arg_id = arg_ref<Char>(id);
return 0; return 0;
} }
constexpr void on_error(const char* message) {
FMT_THROW(format_error(message));
}
}; };
template <typename Char> struct parse_arg_id_result { template <typename Char> struct parse_arg_id_result {
@ -389,14 +314,13 @@ struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID, template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
typename S> typename S>
constexpr auto parse_replacement_field_then_tail(S format_str) { constexpr auto parse_replacement_field_then_tail(S fmt) {
using char_type = typename S::char_type; using char_type = typename S::char_type;
constexpr auto str = basic_string_view<char_type>(format_str); constexpr auto str = basic_string_view<char_type>(fmt);
constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
if constexpr (c == '}') { if constexpr (c == '}') {
return parse_tail<Args, END_POS + 1, NEXT_ID>( return parse_tail<Args, END_POS + 1, NEXT_ID>(
field<char_type, typename field_type<T>::type, ARG_INDEX>(), field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt);
format_str);
} else if constexpr (c != ':') { } else if constexpr (c != ':') {
FMT_THROW(format_error("expected ':'")); FMT_THROW(format_error("expected ':'"));
} else { } else {
@ -409,7 +333,7 @@ constexpr auto parse_replacement_field_then_tail(S format_str) {
return parse_tail<Args, result.end + 1, result.next_arg_id>( return parse_tail<Args, result.end + 1, result.next_arg_id>(
spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{ spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
result.fmt}, result.fmt},
format_str); fmt);
} }
} }
} }
@ -417,22 +341,21 @@ constexpr auto parse_replacement_field_then_tail(S format_str) {
// Compiles a non-empty format string and returns the compiled representation // Compiles a non-empty format string and returns the compiled representation
// or unknown_format() on unrecognized input. // or unknown_format() on unrecognized input.
template <typename Args, size_t POS, int ID, typename S> template <typename Args, size_t POS, int ID, typename S>
constexpr auto compile_format_string(S format_str) { constexpr auto compile_format_string(S fmt) {
using char_type = typename S::char_type; using char_type = typename S::char_type;
constexpr auto str = basic_string_view<char_type>(format_str); constexpr auto str = basic_string_view<char_type>(fmt);
if constexpr (str[POS] == '{') { if constexpr (str[POS] == '{') {
if constexpr (POS + 1 == str.size()) if constexpr (POS + 1 == str.size())
FMT_THROW(format_error("unmatched '{' in format string")); FMT_THROW(format_error("unmatched '{' in format string"));
if constexpr (str[POS + 1] == '{') { if constexpr (str[POS + 1] == '{') {
return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str); return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
} else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') { } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
static_assert(ID != manual_indexing_id, static_assert(ID != manual_indexing_id,
"cannot switch from manual to automatic argument indexing"); "cannot switch from manual to automatic argument indexing");
constexpr auto next_id = constexpr auto next_id =
ID != manual_indexing_id ? ID + 1 : manual_indexing_id; ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
return parse_replacement_field_then_tail<get_type<ID, Args>, Args, return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
POS + 1, ID, next_id>( POS + 1, ID, next_id>(fmt);
format_str);
} else { } else {
constexpr auto arg_id_result = constexpr auto arg_id_result =
parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size()); parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
@ -448,60 +371,55 @@ constexpr auto compile_format_string(S format_str) {
return parse_replacement_field_then_tail<get_type<arg_index, Args>, return parse_replacement_field_then_tail<get_type<arg_index, Args>,
Args, arg_id_end_pos, Args, arg_id_end_pos,
arg_index, manual_indexing_id>( arg_index, manual_indexing_id>(
format_str); fmt);
} else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) { } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
constexpr auto arg_index = constexpr auto arg_index =
get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{}); get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
if constexpr (arg_index != invalid_arg_index) { if constexpr (arg_index >= 0) {
constexpr auto next_id = constexpr auto next_id =
ID != manual_indexing_id ? ID + 1 : manual_indexing_id; ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
return parse_replacement_field_then_tail< return parse_replacement_field_then_tail<
decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos, decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
arg_index, next_id>(format_str); arg_index, next_id>(fmt);
} else { } else if constexpr (c == '}') {
if constexpr (c == '}') { return parse_tail<Args, arg_id_end_pos + 1, ID>(
return parse_tail<Args, arg_id_end_pos + 1, ID>( runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
runtime_named_field<char_type>{arg_id_result.arg_id.val.name}, fmt);
format_str); } else if constexpr (c == ':') {
} else if constexpr (c == ':') { return unknown_format(); // no type info for specs parsing
return unknown_format(); // no type info for specs parsing
}
} }
} }
} }
} else if constexpr (str[POS] == '}') { } else if constexpr (str[POS] == '}') {
if constexpr (POS + 1 == str.size()) if constexpr (POS + 1 == str.size())
FMT_THROW(format_error("unmatched '}' in format string")); FMT_THROW(format_error("unmatched '}' in format string"));
return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str); return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
} else { } else {
constexpr auto end = parse_text(str, POS + 1); constexpr auto end = parse_text(str, POS + 1);
if constexpr (end - POS > 1) { if constexpr (end - POS > 1) {
return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt);
format_str);
} else { } else {
return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt);
format_str);
} }
} }
} }
template <typename... Args, typename S, template <typename... Args, typename S,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
constexpr auto compile(S format_str) { constexpr auto compile(S fmt) {
constexpr auto str = basic_string_view<typename S::char_type>(format_str); constexpr auto str = basic_string_view<typename S::char_type>(fmt);
if constexpr (str.size() == 0) { if constexpr (str.size() == 0) {
return detail::make_text(str, 0, 0); return detail::make_text(str, 0, 0);
} else { } else {
constexpr auto result = constexpr auto result =
detail::compile_format_string<detail::type_list<Args...>, 0, 0>( detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt);
format_str);
return result; return result;
} }
} }
#endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) #endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
} // namespace detail } // namespace detail
FMT_MODULE_EXPORT_BEGIN FMT_BEGIN_EXPORT
#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
@ -566,33 +484,33 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
template <typename OutputIt, typename S, typename... Args, template <typename OutputIt, typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n, auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
const S& format_str, Args&&... args) { -> format_to_n_result<OutputIt> {
auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n), using traits = detail::fixed_buffer_traits;
format_str, std::forward<Args>(args)...); auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
return {it.base(), it.count()}; fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
return {buf.out(), buf.count()};
} }
template <typename S, typename... Args, template <typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
FMT_CONSTEXPR20 size_t formatted_size(const S& format_str, FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
const Args&... args) { -> size_t {
return fmt::format_to(detail::counting_iterator(), format_str, args...) return fmt::format_to(detail::counting_iterator(), fmt, args...).count();
.count();
} }
template <typename S, typename... Args, template <typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
void print(std::FILE* f, const S& format_str, const Args&... args) { void print(std::FILE* f, const S& fmt, const Args&... args) {
memory_buffer buffer; memory_buffer buffer;
fmt::format_to(std::back_inserter(buffer), format_str, args...); fmt::format_to(std::back_inserter(buffer), fmt, args...);
detail::print(f, {buffer.data(), buffer.size()}); detail::print(f, {buffer.data(), buffer.size()});
} }
template <typename S, typename... Args, template <typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
void print(const S& format_str, const Args&... args) { void print(const S& fmt, const Args&... args) {
print(stdout, format_str, args...); print(stdout, fmt, args...);
} }
#if FMT_USE_NONTYPE_TEMPLATE_ARGS #if FMT_USE_NONTYPE_TEMPLATE_ARGS
@ -605,7 +523,7 @@ template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
} // namespace literals } // namespace literals
#endif #endif
FMT_MODULE_EXPORT_END FMT_END_EXPORT
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // FMT_COMPILE_H_ #endif // FMT_COMPILE_H_

3326
Tool/spdlog/include/spdlog/fmt/bundled/core.h
View File

File diff suppressed because it is too large Load Diff

641
Tool/spdlog/include/spdlog/fmt/bundled/format-inl.h
View File

@ -8,21 +8,19 @@
#ifndef FMT_FORMAT_INL_H_ #ifndef FMT_FORMAT_INL_H_
#define FMT_FORMAT_INL_H_ #define FMT_FORMAT_INL_H_
#include <algorithm> #ifndef FMT_MODULE
#include <cctype> # include <algorithm>
#include <cerrno> // errno # include <cerrno> // errno
#include <climits> # include <climits>
#include <cmath> # include <cmath>
#include <cstdarg> # include <exception>
#include <cstring> // std::memmove
#include <cwchar>
#include <exception>
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR # if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
# include <locale> # include <locale>
# endif
#endif #endif
#ifdef _WIN32 #if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)
# include <io.h> // _isatty # include <io.h> // _isatty
#endif #endif
@ -40,10 +38,6 @@ FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
std::terminate(); std::terminate();
} }
FMT_FUNC void throw_format_error(const char* message) {
FMT_THROW(format_error(message));
}
FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code, FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
string_view message) noexcept { string_view message) noexcept {
// Report error code making sure that the output fits into // Report error code making sure that the output fits into
@ -60,10 +54,10 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
++error_code_size; ++error_code_size;
} }
error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
auto it = buffer_appender<char>(out); auto it = appender(out);
if (message.size() <= inline_buffer_size - error_code_size) if (message.size() <= inline_buffer_size - error_code_size)
format_to(it, FMT_STRING("{}{}"), message, SEP); fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
FMT_ASSERT(out.size() <= inline_buffer_size, ""); FMT_ASSERT(out.size() <= inline_buffer_size, "");
} }
@ -77,9 +71,8 @@ FMT_FUNC void report_error(format_func func, int error_code,
} }
// A wrapper around fwrite that throws on error. // A wrapper around fwrite that throws on error.
inline void fwrite_fully(const void* ptr, size_t size, size_t count, inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
FILE* stream) { size_t written = std::fwrite(ptr, 1, count, stream);
size_t written = std::fwrite(ptr, size, count, stream);
if (written < count) if (written < count)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
} }
@ -90,7 +83,7 @@ locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
static_assert(std::is_same<Locale, std::locale>::value, ""); static_assert(std::is_same<Locale, std::locale>::value, "");
} }
template <typename Locale> Locale locale_ref::get() const { template <typename Locale> auto locale_ref::get() const -> Locale {
static_assert(std::is_same<Locale, std::locale>::value, ""); static_assert(std::is_same<Locale, std::locale>::value, "");
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale(); return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
} }
@ -102,7 +95,8 @@ FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
return {std::move(grouping), thousands_sep}; return {std::move(grouping), thousands_sep};
} }
template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) { template <typename Char>
FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()) return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
.decimal_point(); .decimal_point();
} }
@ -115,96 +109,81 @@ template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
return '.'; return '.';
} }
#endif #endif
FMT_FUNC auto write_loc(appender out, loc_value value,
const format_specs& specs, locale_ref loc) -> bool {
#ifdef FMT_STATIC_THOUSANDS_SEPARATOR
value.visit(loc_writer<>{
out, specs, std::string(1, FMT_STATIC_THOUSANDS_SEPARATOR), "\3", "."});
return true;
#else
auto locale = loc.get<std::locale>();
// We cannot use the num_put<char> facet because it may produce output in
// a wrong encoding.
using facet = format_facet<std::locale>;
if (std::has_facet<facet>(locale))
return std::use_facet<facet>(locale).put(out, value, specs);
return facet(locale).put(out, value, specs);
#endif
}
} // namespace detail } // namespace detail
#if !FMT_MSC_VERSION FMT_FUNC void report_error(const char* message) {
FMT_API FMT_FUNC format_error::~format_error() noexcept = default; FMT_THROW(format_error(message));
}
template <typename Locale> typename Locale::id format_facet<Locale>::id;
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
grouping_ = numpunct.grouping();
if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
}
template <>
FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
appender out, loc_value val, const format_specs& specs) const -> bool {
return val.visit(
detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
}
#endif #endif
FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str, FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)
format_args args) { -> std::system_error {
auto ec = std::error_code(error_code, std::generic_category()); auto ec = std::error_code(error_code, std::generic_category());
return std::system_error(ec, vformat(format_str, args)); return std::system_error(ec, vformat(fmt, args));
} }
namespace detail { namespace detail {
template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) { template <typename F>
inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool {
return x.f == y.f && x.e == y.e; return x.f == y.f && x.e == y.e;
} }
// Compilers should be able to optimize this into the ror instruction. // Compilers should be able to optimize this into the ror instruction.
FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept { FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
r &= 31; r &= 31;
return (n >> r) | (n << (32 - r)); return (n >> r) | (n << (32 - r));
} }
FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept { FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
r &= 63; r &= 63;
return (n >> r) | (n << (64 - r)); return (n >> r) | (n << (64 - r));
} }
// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
#if FMT_USE_INT128
auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
#elif defined(_MSC_VER) && defined(_M_X64)
auto result = uint128_fallback();
result.lo_ = _umul128(x, y, &result.hi_);
return result;
#else
const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
uint64_t a = x >> 32;
uint64_t b = x & mask;
uint64_t c = y >> 32;
uint64_t d = y & mask;
uint64_t ac = a * c;
uint64_t bc = b * c;
uint64_t ad = a * d;
uint64_t bd = b * d;
uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
(intermediate << 32) + (bd & mask)};
#endif
}
// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox. // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
namespace dragonbox { namespace dragonbox {
// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
#if FMT_USE_INT128
auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
return static_cast<uint64_t>(p >> 64);
#elif defined(_MSC_VER) && defined(_M_X64)
return __umulh(x, y);
#else
return umul128(x, y).high();
#endif
}
// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer.
inline uint128_fallback umul192_upper128(uint64_t x,
uint128_fallback y) noexcept {
uint128_fallback r = umul128(x, y.high());
r += umul128_upper64(x, y.low());
return r;
}
// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
// 64-bit unsigned integer. // 64-bit unsigned integer.
inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept { inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {
return umul128_upper64(static_cast<uint64_t>(x) << 32, y); return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
} }
// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer. // 128-bit unsigned integer.
inline uint128_fallback umul192_lower128(uint64_t x, inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept
uint128_fallback y) noexcept { -> uint128_fallback {
uint64_t high = x * y.high(); uint64_t high = x * y.high();
uint128_fallback high_low = umul128(x, y.low()); uint128_fallback high_low = umul128(x, y.low());
return {high + high_low.high(), high_low.low()}; return {high + high_low.high(), high_low.low()};
@ -212,29 +191,17 @@ inline uint128_fallback umul192_lower128(uint64_t x,
// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
// 64-bit unsigned integer. // 64-bit unsigned integer.
inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept { inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {
return x * y; return x * y;
} }
// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
inline int floor_log10_pow2(int e) noexcept {
FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
return (e * 315653) >> 20;
}
// Various fast log computations. // Various fast log computations.
inline int floor_log2_pow10(int e) noexcept { inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
return (e * 1741647) >> 19;
}
inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent"); FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
return (e * 631305 - 261663) >> 21; return (e * 631305 - 261663) >> 21;
} }
static constexpr struct { FMT_INLINE_VARIABLE constexpr struct {
uint32_t divisor; uint32_t divisor;
int shift_amount; int shift_amount;
} div_small_pow10_infos[] = {{10, 16}, {100, 16}}; } div_small_pow10_infos[] = {{10, 16}, {100, 16}};
@ -243,7 +210,7 @@ static constexpr struct {
// divisible by pow(10, N). // divisible by pow(10, N).
// Precondition: n <= pow(10, N + 1). // Precondition: n <= pow(10, N + 1).
template <int N> template <int N>
bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept { auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
// The numbers below are chosen such that: // The numbers below are chosen such that:
// 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
// 2. nm mod 2^k < m if and only if n is divisible by d, // 2. nm mod 2^k < m if and only if n is divisible by d,
@ -268,7 +235,7 @@ bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
// Computes floor(n / pow(10, N)) for small n and N. // Computes floor(n / pow(10, N)) for small n and N.
// Precondition: n <= pow(10, N + 1). // Precondition: n <= pow(10, N + 1).
template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept { template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {
constexpr auto info = div_small_pow10_infos[N - 1]; constexpr auto info = div_small_pow10_infos[N - 1];
FMT_ASSERT(n <= info.divisor * 10, "n is too large"); FMT_ASSERT(n <= info.divisor * 10, "n is too large");
constexpr uint32_t magic_number = constexpr uint32_t magic_number =
@ -277,24 +244,24 @@ template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
} }
// Computes floor(n / 10^(kappa + 1)) (float) // Computes floor(n / 10^(kappa + 1)) (float)
inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept { inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {
// 1374389535 = ceil(2^37/100) // 1374389535 = ceil(2^37/100)
return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37); return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
} }
// Computes floor(n / 10^(kappa + 1)) (double) // Computes floor(n / 10^(kappa + 1)) (double)
inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept { inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
// 2361183241434822607 = ceil(2^(64+7)/1000) // 2361183241434822607 = ceil(2^(64+7)/1000)
return umul128_upper64(n, 2361183241434822607ull) >> 7; return umul128_upper64(n, 2361183241434822607ull) >> 7;
} }
// Various subroutines using pow10 cache // Various subroutines using pow10 cache
template <class T> struct cache_accessor; template <typename T> struct cache_accessor;
template <> struct cache_accessor<float> { template <> struct cache_accessor<float> {
using carrier_uint = float_info<float>::carrier_uint; using carrier_uint = float_info<float>::carrier_uint;
using cache_entry_type = uint64_t; using cache_entry_type = uint64_t;
static uint64_t get_cached_power(int k) noexcept { static auto get_cached_power(int k) noexcept -> uint64_t {
FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k, FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
"k is out of range"); "k is out of range");
static constexpr const uint64_t pow10_significands[] = { static constexpr const uint64_t pow10_significands[] = {
@ -336,20 +303,23 @@ template <> struct cache_accessor<float> {
bool is_integer; bool is_integer;
}; };
static compute_mul_result compute_mul( static auto compute_mul(carrier_uint u,
carrier_uint u, const cache_entry_type& cache) noexcept { const cache_entry_type& cache) noexcept
-> compute_mul_result {
auto r = umul96_upper64(u, cache); auto r = umul96_upper64(u, cache);
return {static_cast<carrier_uint>(r >> 32), return {static_cast<carrier_uint>(r >> 32),
static_cast<carrier_uint>(r) == 0}; static_cast<carrier_uint>(r) == 0};
} }
static uint32_t compute_delta(const cache_entry_type& cache, static auto compute_delta(const cache_entry_type& cache, int beta) noexcept
int beta) noexcept { -> uint32_t {
return static_cast<uint32_t>(cache >> (64 - 1 - beta)); return static_cast<uint32_t>(cache >> (64 - 1 - beta));
} }
static compute_mul_parity_result compute_mul_parity( static auto compute_mul_parity(carrier_uint two_f,
carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept { const cache_entry_type& cache,
int beta) noexcept
-> compute_mul_parity_result {
FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta >= 1, "");
FMT_ASSERT(beta < 64, ""); FMT_ASSERT(beta < 64, "");
@ -358,22 +328,22 @@ template <> struct cache_accessor<float> {
static_cast<uint32_t>(r >> (32 - beta)) == 0}; static_cast<uint32_t>(r >> (32 - beta)) == 0};
} }
static carrier_uint compute_left_endpoint_for_shorter_interval_case( static auto compute_left_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept { const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return static_cast<carrier_uint>( return static_cast<carrier_uint>(
(cache - (cache >> (num_significand_bits<float>() + 2))) >> (cache - (cache >> (num_significand_bits<float>() + 2))) >>
(64 - num_significand_bits<float>() - 1 - beta)); (64 - num_significand_bits<float>() - 1 - beta));
} }
static carrier_uint compute_right_endpoint_for_shorter_interval_case( static auto compute_right_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept { const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return static_cast<carrier_uint>( return static_cast<carrier_uint>(
(cache + (cache >> (num_significand_bits<float>() + 1))) >> (cache + (cache >> (num_significand_bits<float>() + 1))) >>
(64 - num_significand_bits<float>() - 1 - beta)); (64 - num_significand_bits<float>() - 1 - beta));
} }
static carrier_uint compute_round_up_for_shorter_interval_case( static auto compute_round_up_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept { const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (static_cast<carrier_uint>( return (static_cast<carrier_uint>(
cache >> (64 - num_significand_bits<float>() - 2 - beta)) + cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
1) / 1) /
@ -385,7 +355,7 @@ template <> struct cache_accessor<double> {
using carrier_uint = float_info<double>::carrier_uint; using carrier_uint = float_info<double>::carrier_uint;
using cache_entry_type = uint128_fallback; using cache_entry_type = uint128_fallback;
static uint128_fallback get_cached_power(int k) noexcept { static auto get_cached_power(int k) noexcept -> uint128_fallback {
FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k, FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
"k is out of range"); "k is out of range");
@ -1009,8 +979,22 @@ template <> struct cache_accessor<double> {
{0xfcf62c1dee382c42, 0x46729e03dd9ed7b6}, {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
{0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2}, {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
{0xc5a05277621be293, 0xc7098b7305241886}, {0xc5a05277621be293, 0xc7098b7305241886},
{ 0xf70867153aa2db38, {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
0xb8cbee4fc66d1ea8 } {0x9a65406d44a5c903, 0x737f74f1dc043329},
{0xc0fe908895cf3b44, 0x505f522e53053ff3},
{0xf13e34aabb430a15, 0x647726b9e7c68ff0},
{0x96c6e0eab509e64d, 0x5eca783430dc19f6},
{0xbc789925624c5fe0, 0xb67d16413d132073},
{0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
{0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
{0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
{0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
{0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
{0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
{0xe0accfa875af45a7, 0x93eb1b80a33b8606},
{0x8c6c01c9498d8b88, 0xbc72f130660533c4},
{0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
{0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
#else #else
{0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
{0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
@ -1034,8 +1018,8 @@ template <> struct cache_accessor<double> {
{0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
{0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
{0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
{ 0x95527a5202df0ccb, {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
0x0f37801e0c43ebc9 } {0xf13e34aabb430a15, 0x647726b9e7c68ff0}
#endif #endif
}; };
@ -1095,19 +1079,22 @@ template <> struct cache_accessor<double> {
bool is_integer; bool is_integer;
}; };
static compute_mul_result compute_mul( static auto compute_mul(carrier_uint u,
carrier_uint u, const cache_entry_type& cache) noexcept { const cache_entry_type& cache) noexcept
-> compute_mul_result {
auto r = umul192_upper128(u, cache); auto r = umul192_upper128(u, cache);
return {r.high(), r.low() == 0}; return {r.high(), r.low() == 0};
} }
static uint32_t compute_delta(cache_entry_type const& cache, static auto compute_delta(cache_entry_type const& cache, int beta) noexcept
int beta) noexcept { -> uint32_t {
return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta)); return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
} }
static compute_mul_parity_result compute_mul_parity( static auto compute_mul_parity(carrier_uint two_f,
carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept { const cache_entry_type& cache,
int beta) noexcept
-> compute_mul_parity_result {
FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta >= 1, "");
FMT_ASSERT(beta < 64, ""); FMT_ASSERT(beta < 64, "");
@ -1116,31 +1103,35 @@ template <> struct cache_accessor<double> {
((r.high() << beta) | (r.low() >> (64 - beta))) == 0}; ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
} }
static carrier_uint compute_left_endpoint_for_shorter_interval_case( static auto compute_left_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept { const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (cache.high() - return (cache.high() -
(cache.high() >> (num_significand_bits<double>() + 2))) >> (cache.high() >> (num_significand_bits<double>() + 2))) >>
(64 - num_significand_bits<double>() - 1 - beta); (64 - num_significand_bits<double>() - 1 - beta);
} }
static carrier_uint compute_right_endpoint_for_shorter_interval_case( static auto compute_right_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept { const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (cache.high() + return (cache.high() +
(cache.high() >> (num_significand_bits<double>() + 1))) >> (cache.high() >> (num_significand_bits<double>() + 1))) >>
(64 - num_significand_bits<double>() - 1 - beta); (64 - num_significand_bits<double>() - 1 - beta);
} }
static carrier_uint compute_round_up_for_shorter_interval_case( static auto compute_round_up_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept { const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) + return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
1) / 1) /
2; 2;
} }
}; };
FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
return cache_accessor<double>::get_cached_power(k);
}
// Various integer checks // Various integer checks
template <class T> template <typename T>
bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept { auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
const int case_shorter_interval_left_endpoint_lower_threshold = 2; const int case_shorter_interval_left_endpoint_lower_threshold = 2;
const int case_shorter_interval_left_endpoint_upper_threshold = 3; const int case_shorter_interval_left_endpoint_upper_threshold = 3;
return exponent >= case_shorter_interval_left_endpoint_lower_threshold && return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
@ -1148,12 +1139,12 @@ bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
} }
// Remove trailing zeros from n and return the number of zeros removed (float) // Remove trailing zeros from n and return the number of zeros removed (float)
FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept { FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
FMT_ASSERT(n != 0, ""); FMT_ASSERT(n != 0, "");
const uint32_t mod_inv_5 = 0xcccccccd; // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5; constexpr uint32_t mod_inv_5 = 0xcccccccd;
constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5
int s = 0;
while (true) { while (true) {
auto q = rotr(n * mod_inv_25, 2); auto q = rotr(n * mod_inv_25, 2);
if (q > max_value<uint32_t>() / 100) break; if (q > max_value<uint32_t>() / 100) break;
@ -1165,7 +1156,6 @@ FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
n = q; n = q;
s |= 1; s |= 1;
} }
return s; return s;
} }
@ -1179,32 +1169,17 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
// Is n is divisible by 10^8? // Is n is divisible by 10^8?
if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) { if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
// If yes, work with the quotient. // If yes, work with the quotient...
auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64)); auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
// ... and use the 32 bit variant of the function
const uint32_t mod_inv_5 = 0xcccccccd; int s = remove_trailing_zeros(n32, 8);
const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
int s = 8;
while (true) {
auto q = rotr(n32 * mod_inv_25, 2);
if (q > max_value<uint32_t>() / 100) break;
n32 = q;
s += 2;
}
auto q = rotr(n32 * mod_inv_5, 1);
if (q <= max_value<uint32_t>() / 10) {
n32 = q;
s |= 1;
}
n = n32; n = n32;
return s; return s;
} }
// If n is not divisible by 10^8, work with n itself. // If n is not divisible by 10^8, work with n itself.
const uint64_t mod_inv_5 = 0xcccccccccccccccd; constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
const uint64_t mod_inv_25 = mod_inv_5 * mod_inv_5; constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5
int s = 0; int s = 0;
while (true) { while (true) {
@ -1223,7 +1198,7 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
} }
// The main algorithm for shorter interval case // The main algorithm for shorter interval case
template <class T> template <typename T>
FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept { FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
decimal_fp<T> ret_value; decimal_fp<T> ret_value;
// Compute k and beta // Compute k and beta
@ -1270,7 +1245,7 @@ FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
return ret_value; return ret_value;
} }
template <typename T> decimal_fp<T> to_decimal(T x) noexcept { template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
// Step 1: integer promotion & Schubfach multiplier calculation. // Step 1: integer promotion & Schubfach multiplier calculation.
using carrier_uint = typename float_info<T>::carrier_uint; using carrier_uint = typename float_info<T>::carrier_uint;
@ -1394,17 +1369,6 @@ small_divisor_case_label:
return ret_value; return ret_value;
} }
} // namespace dragonbox } // namespace dragonbox
#ifdef _MSC_VER
FMT_FUNC auto fmt_snprintf(char* buf, size_t size, const char* fmt, ...)
-> int {
auto args = va_list();
va_start(args, fmt);
int result = vsnprintf_s(buf, size, _TRUNCATE, fmt, args);
va_end(args);
return result;
}
#endif
} // namespace detail } // namespace detail
template <> struct formatter<detail::bigint> { template <> struct formatter<detail::bigint> {
@ -1413,23 +1377,22 @@ template <> struct formatter<detail::bigint> {
return ctx.begin(); return ctx.begin();
} }
template <typename FormatContext> auto format(const detail::bigint& n, format_context& ctx) const
auto format(const detail::bigint& n, FormatContext& ctx) const -> -> format_context::iterator {
typename FormatContext::iterator {
auto out = ctx.out(); auto out = ctx.out();
bool first = true; bool first = true;
for (auto i = n.bigits_.size(); i > 0; --i) { for (auto i = n.bigits_.size(); i > 0; --i) {
auto value = n.bigits_[i - 1u]; auto value = n.bigits_[i - 1u];
if (first) { if (first) {
out = format_to(out, FMT_STRING("{:x}"), value); out = fmt::format_to(out, FMT_STRING("{:x}"), value);
first = false; first = false;
continue; continue;
} }
out = format_to(out, FMT_STRING("{:08x}"), value); out = fmt::format_to(out, FMT_STRING("{:08x}"), value);
} }
if (n.exp_ > 0) if (n.exp_ > 0)
out = format_to(out, FMT_STRING("p{}"), out = fmt::format_to(out, FMT_STRING("p{}"),
n.exp_ * detail::bigint::bigit_bits); n.exp_ * detail::bigint::bigit_bits);
return out; return out;
} }
}; };
@ -1453,7 +1416,7 @@ FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
const char* message) noexcept { const char* message) noexcept {
FMT_TRY { FMT_TRY {
auto ec = std::error_code(error_code, std::generic_category()); auto ec = std::error_code(error_code, std::generic_category());
write(std::back_inserter(out), std::system_error(ec, message).what()); detail::write(appender(out), std::system_error(ec, message).what());
return; return;
} }
FMT_CATCH(...) {} FMT_CATCH(...) {}
@ -1465,7 +1428,7 @@ FMT_FUNC void report_system_error(int error_code,
report_error(format_system_error, error_code, message); report_error(format_system_error, error_code, message);
} }
FMT_FUNC std::string vformat(string_view fmt, format_args args) { FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
// Don't optimize the "{}" case to keep the binary size small and because it // Don't optimize the "{}" case to keep the binary size small and because it
// can be better optimized in fmt::format anyway. // can be better optimized in fmt::format anyway.
auto buffer = memory_buffer(); auto buffer = memory_buffer();
@ -1474,57 +1437,299 @@ FMT_FUNC std::string vformat(string_view fmt, format_args args) {
} }
namespace detail { namespace detail {
#ifdef _WIN32
template <typename T> struct span {
T* data;
size_t size;
};
template <typename F> auto flockfile(F* f) -> decltype(_lock_file(f)) {
_lock_file(f);
}
template <typename F> auto funlockfile(F* f) -> decltype(_unlock_file(f)) {
_unlock_file(f);
}
#ifndef getc_unlocked
template <typename F> auto getc_unlocked(F* f) -> decltype(_fgetc_nolock(f)) {
return _fgetc_nolock(f);
}
#endif
template <typename F = FILE, typename Enable = void>
struct has_flockfile : std::false_type {};
template <typename F>
struct has_flockfile<F, void_t<decltype(flockfile(&std::declval<F&>()))>>
: std::true_type {};
// A FILE wrapper. F is FILE defined as a template parameter to make system API
// detection work.
template <typename F> class file_base {
public:
F* file_;
public:
file_base(F* file) : file_(file) {}
operator F*() const { return file_; }
// Reads a code unit from the stream.
auto get() -> int {
int result = getc_unlocked(file_);
if (result == EOF && ferror(file_) != 0)
FMT_THROW(system_error(errno, FMT_STRING("getc failed")));
return result;
}
// Puts the code unit back into the stream buffer.
void unget(char c) {
if (ungetc(c, file_) == EOF)
FMT_THROW(system_error(errno, FMT_STRING("ungetc failed")));
}
void flush() { fflush(this->file_); }
};
// A FILE wrapper for glibc.
template <typename F> class glibc_file : public file_base<F> {
private:
enum {
line_buffered = 0x200, // _IO_LINE_BUF
unbuffered = 2 // _IO_UNBUFFERED
};
public:
using file_base<F>::file_base;
auto is_buffered() const -> bool {
return (this->file_->_flags & unbuffered) == 0;
}
void init_buffer() {
if (this->file_->_IO_write_ptr) return;
// Force buffer initialization by placing and removing a char in a buffer.
putc_unlocked(0, this->file_);
--this->file_->_IO_write_ptr;
}
// Returns the file's read buffer.
auto get_read_buffer() const -> span<const char> {
auto ptr = this->file_->_IO_read_ptr;
return {ptr, to_unsigned(this->file_->_IO_read_end - ptr)};
}
// Returns the file's write buffer.
auto get_write_buffer() const -> span<char> {
auto ptr = this->file_->_IO_write_ptr;
return {ptr, to_unsigned(this->file_->_IO_buf_end - ptr)};
}
void advance_write_buffer(size_t size) { this->file_->_IO_write_ptr += size; }
bool needs_flush() const {
if ((this->file_->_flags & line_buffered) == 0) return false;
char* end = this->file_->_IO_write_end;
return memchr(end, '\n', to_unsigned(this->file_->_IO_write_ptr - end));
}
void flush() { fflush_unlocked(this->file_); }
};
// A FILE wrapper for Apple's libc.
template <typename F> class apple_file : public file_base<F> {
private:
enum {
line_buffered = 1, // __SNBF
unbuffered = 2 // __SLBF
};
public:
using file_base<F>::file_base;
auto is_buffered() const -> bool {
return (this->file_->_flags & unbuffered) == 0;
}
void init_buffer() {
if (this->file_->_p) return;
// Force buffer initialization by placing and removing a char in a buffer.
putc_unlocked(0, this->file_);
--this->file_->_p;
++this->file_->_w;
}
auto get_read_buffer() const -> span<const char> {
return {reinterpret_cast<char*>(this->file_->_p),
to_unsigned(this->file_->_r)};
}
auto get_write_buffer() const -> span<char> {
return {reinterpret_cast<char*>(this->file_->_p),
to_unsigned(this->file_->_bf._base + this->file_->_bf._size -
this->file_->_p)};
}
void advance_write_buffer(size_t size) {
this->file_->_p += size;
this->file_->_w -= size;
}
bool needs_flush() const {
if ((this->file_->_flags & line_buffered) == 0) return false;
return memchr(this->file_->_p + this->file_->_w, '\n',
to_unsigned(-this->file_->_w));
}
};
// A fallback FILE wrapper.
template <typename F> class fallback_file : public file_base<F> {
private:
char next_; // The next unconsumed character in the buffer.
bool has_next_ = false;
public:
using file_base<F>::file_base;
auto is_buffered() const -> bool { return false; }
auto needs_flush() const -> bool { return false; }
void init_buffer() {}
auto get_read_buffer() const -> span<const char> {
return {&next_, has_next_ ? 1u : 0u};
}
auto get_write_buffer() const -> span<char> { return {nullptr, 0}; }
void advance_write_buffer(size_t) {}
auto get() -> int {
has_next_ = false;
return file_base<F>::get();
}
void unget(char c) {
file_base<F>::unget(c);
next_ = c;
has_next_ = true;
}
};
#ifndef FMT_USE_FALLBACK_FILE
# define FMT_USE_FALLBACK_FILE 1
#endif
template <typename F,
FMT_ENABLE_IF(sizeof(F::_p) != 0 && !FMT_USE_FALLBACK_FILE)>
auto get_file(F* f, int) -> apple_file<F> {
return f;
}
template <typename F,
FMT_ENABLE_IF(sizeof(F::_IO_read_ptr) != 0 && !FMT_USE_FALLBACK_FILE)>
inline auto get_file(F* f, int) -> glibc_file<F> {
return f;
}
inline auto get_file(FILE* f, ...) -> fallback_file<FILE> { return f; }
using file_ref = decltype(get_file(static_cast<FILE*>(nullptr), 0));
template <typename F = FILE, typename Enable = void>
class file_print_buffer : public buffer<char> {
public:
explicit file_print_buffer(F*) : buffer(nullptr, size_t()) {}
};
template <typename F>
class file_print_buffer<F, enable_if_t<has_flockfile<F>::value>>
: public buffer<char> {
private:
file_ref file_;
static void grow(buffer<char>& base, size_t) {
auto& self = static_cast<file_print_buffer&>(base);
self.file_.advance_write_buffer(self.size());
if (self.file_.get_write_buffer().size == 0) self.file_.flush();
auto buf = self.file_.get_write_buffer();
FMT_ASSERT(buf.size > 0, "");
self.set(buf.data, buf.size);
self.clear();
}
public:
explicit file_print_buffer(F* f) : buffer(grow, size_t()), file_(f) {
flockfile(f);
file_.init_buffer();
auto buf = file_.get_write_buffer();
set(buf.data, buf.size);
}
~file_print_buffer() {
file_.advance_write_buffer(size());
bool flush = file_.needs_flush();
F* f = file_; // Make funlockfile depend on the template parameter F
funlockfile(f); // for the system API detection to work.
if (flush) fflush(file_);
}
};
#if !defined(_WIN32) || defined(FMT_USE_WRITE_CONSOLE)
FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
#else
using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>; using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( //
void*, const void*, dword, dword*, void*); void*, const void*, dword, dword*, void*);
FMT_FUNC bool write_console(std::FILE* f, string_view text) { FMT_FUNC bool write_console(int fd, string_view text) {
auto fd = _fileno(f); auto u16 = utf8_to_utf16(text);
if (_isatty(fd)) { return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
detail::utf8_to_utf16 u16(string_view(text.data(), text.size())); static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
auto written = detail::dword(); }
if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), #endif
u16.c_str(), static_cast<uint32_t>(u16.size()),
&written, nullptr)) { #ifdef _WIN32
return true; // Print assuming legacy (non-Unicode) encoding.
} FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args,
} bool newline) {
// We return false if the file descriptor was not TTY, or it was but auto buffer = memory_buffer();
// SetConsoleW failed which can happen if the output has been redirected to detail::vformat_to(buffer, fmt, args);
// NUL. In both cases when we return false, we should attempt to do regular if (newline) buffer.push_back('\n');
// write via fwrite or std::ostream::write. fwrite_fully(buffer.data(), buffer.size(), f);
return false;
} }
#endif #endif
FMT_FUNC void print(std::FILE* f, string_view text) { FMT_FUNC void print(std::FILE* f, string_view text) {
#ifdef _WIN32 #if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)
if (write_console(f, text)) return; int fd = _fileno(f);
if (_isatty(fd)) {
std::fflush(f);
if (write_console(fd, text)) return;
}
#endif #endif
detail::fwrite_fully(text.data(), 1, text.size(), f); fwrite_fully(text.data(), text.size(), f);
} }
} // namespace detail } // namespace detail
FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) { FMT_FUNC void vprint_buffered(std::FILE* f, string_view fmt, format_args args) {
memory_buffer buffer; auto buffer = memory_buffer();
detail::vformat_to(buffer, format_str, args); detail::vformat_to(buffer, fmt, args);
detail::print(f, {buffer.data(), buffer.size()}); detail::print(f, {buffer.data(), buffer.size()});
} }
#ifdef _WIN32 FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
// Print assuming legacy (non-Unicode) encoding. if (!detail::file_ref(f).is_buffered() || !detail::has_flockfile<>())
FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str, return vprint_buffered(f, fmt, args);
format_args args) { auto&& buffer = detail::file_print_buffer<>(f);
memory_buffer buffer; return detail::vformat_to(buffer, fmt, args);
detail::vformat_to(buffer, format_str,
basic_format_args<buffer_context<char>>(args));
fwrite_fully(buffer.data(), 1, buffer.size(), f);
} }
#endif
FMT_FUNC void vprint(string_view format_str, format_args args) { FMT_FUNC void vprintln(std::FILE* f, string_view fmt, format_args args) {
vprint(stdout, format_str, args); auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt, args);
buffer.push_back('\n');
detail::print(f, {buffer.data(), buffer.size()});
}
FMT_FUNC void vprint(string_view fmt, format_args args) {
vprint(stdout, fmt, args);
} }
namespace detail { namespace detail {

3006
Tool/spdlog/include/spdlog/fmt/bundled/format.h
View File

File diff suppressed because it is too large Load Diff

325
Tool/spdlog/include/spdlog/fmt/bundled/os.h
View File

@ -8,17 +8,19 @@
#ifndef FMT_OS_H_ #ifndef FMT_OS_H_
#define FMT_OS_H_ #define FMT_OS_H_
#include <cerrno>
#include <cstddef>
#include <cstdio>
#include <system_error> // std::system_error
#if defined __APPLE__ || defined(__FreeBSD__)
# include <xlocale.h> // for LC_NUMERIC_MASK on OS X
#endif
#include "format.h" #include "format.h"
#ifndef FMT_MODULE
# include <cerrno>
# include <cstddef>
# include <cstdio>
# include <system_error> // std::system_error
# if FMT_HAS_INCLUDE(<xlocale.h>)
# include <xlocale.h> // LC_NUMERIC_MASK on macOS
# endif
#endif // FMT_MODULE
#ifndef FMT_USE_FCNTL #ifndef FMT_USE_FCNTL
// UWP doesn't provide _pipe. // UWP doesn't provide _pipe.
# if FMT_HAS_INCLUDE("winapifamily.h") # if FMT_HAS_INCLUDE("winapifamily.h")
@ -46,6 +48,7 @@
// Calls to system functions are wrapped in FMT_SYSTEM for testability. // Calls to system functions are wrapped in FMT_SYSTEM for testability.
#ifdef FMT_SYSTEM #ifdef FMT_SYSTEM
# define FMT_HAS_SYSTEM
# define FMT_POSIX_CALL(call) FMT_SYSTEM(call) # define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
#else #else
# define FMT_SYSTEM(call) ::call # define FMT_SYSTEM(call) ::call
@ -71,132 +74,78 @@
#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN FMT_BEGIN_EXPORT
/** /**
\rst * A reference to a null-terminated string. It can be constructed from a C
A reference to a null-terminated string. It can be constructed from a C * string or `std::string`.
string or ``std::string``. *
* You can use one of the following type aliases for common character types:
You can use one of the following type aliases for common character types: *
* +---------------+-----------------------------+
+---------------+-----------------------------+ * | Type | Definition |
| Type | Definition | * +===============+=============================+
+===============+=============================+ * | cstring_view | basic_cstring_view<char> |
| cstring_view | basic_cstring_view<char> | * +---------------+-----------------------------+
+---------------+-----------------------------+ * | wcstring_view | basic_cstring_view<wchar_t> |
| wcstring_view | basic_cstring_view<wchar_t> | * +---------------+-----------------------------+
+---------------+-----------------------------+ *
* This class is most useful as a parameter type for functions that wrap C APIs.
This class is most useful as a parameter type to allow passing
different types of strings to a function, for example::
template <typename... Args>
std::string format(cstring_view format_str, const Args & ... args);
format("{}", 42);
format(std::string("{}"), 42);
\endrst
*/ */
template <typename Char> class basic_cstring_view { template <typename Char> class basic_cstring_view {
private: private:
const Char* data_; const Char* data_;
public: public:
/** Constructs a string reference object from a C string. */ /// Constructs a string reference object from a C string.
basic_cstring_view(const Char* s) : data_(s) {} basic_cstring_view(const Char* s) : data_(s) {}
/** /// Constructs a string reference from an `std::string` object.
\rst
Constructs a string reference from an ``std::string`` object.
\endrst
*/
basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {} basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
/** Returns the pointer to a C string. */ /// Returns the pointer to a C string.
const Char* c_str() const { return data_; } auto c_str() const -> const Char* { return data_; }
}; };
using cstring_view = basic_cstring_view<char>; using cstring_view = basic_cstring_view<char>;
using wcstring_view = basic_cstring_view<wchar_t>; using wcstring_view = basic_cstring_view<wchar_t>;
template <typename Char> struct formatter<std::error_code, Char> {
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext>
FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
out = detail::write_bytes(out, ec.category().name(),
basic_format_specs<Char>());
out = detail::write<Char>(out, Char(':'));
out = detail::write<Char>(out, ec.value());
return out;
}
};
#ifdef _WIN32 #ifdef _WIN32
FMT_API const std::error_category& system_category() noexcept; FMT_API const std::error_category& system_category() noexcept;
FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
// 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(basic_string_view<wchar_t> 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(basic_string_view<wchar_t> s);
};
FMT_API void format_windows_error(buffer<char>& out, int error_code, FMT_API void format_windows_error(buffer<char>& out, int error_code,
const char* message) noexcept; const char* message) noexcept;
FMT_END_DETAIL_NAMESPACE }
FMT_API std::system_error vwindows_error(int error_code, string_view format_str, FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
format_args args); format_args args);
/** /**
\rst * Constructs a `std::system_error` object with the description of the form
Constructs a :class:`std::system_error` object with the description *
of the form * <message>: <system-message>
*
.. parsed-literal:: * where `<message>` is the formatted message and `<system-message>` is the
*<message>*: *<system-message>* * system message corresponding to the error code.
* `error_code` is a Windows error code as given by `GetLastError`.
where *<message>* is the formatted message and *<system-message>* is the * If `error_code` is not a valid error code such as -1, the system message
system message corresponding to the error code. * will look like "error -1".
*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 * **Example**:
will look like "error -1". *
* // This throws a system_error with the description
**Example**:: * // cannot open file 'madeup': The system cannot find the file
* specified.
// This throws a system_error with the description * // or similar (system message may vary).
// cannot open file 'madeup': The system cannot find the file specified. * const char *filename = "madeup";
// or similar (system message may vary). * LPOFSTRUCT of = LPOFSTRUCT();
const char *filename = "madeup"; * HFILE file = OpenFile(filename, &of, OF_READ);
LPOFSTRUCT of = LPOFSTRUCT(); * if (file == HFILE_ERROR) {
HFILE file = OpenFile(filename, &of, OF_READ); * throw fmt::windows_error(GetLastError(),
if (file == HFILE_ERROR) { * "cannot open file '{}'", filename);
throw fmt::windows_error(GetLastError(), * }
"cannot open file '{}'", filename); */
}
\endrst
*/
template <typename... Args> template <typename... Args>
std::system_error windows_error(int error_code, string_view message, std::system_error windows_error(int error_code, string_view message,
const Args&... args) { const Args&... args) {
@ -207,7 +156,7 @@ std::system_error windows_error(int error_code, string_view message,
// Can be used to report errors from destructors. // Can be used to report errors from destructors.
FMT_API void report_windows_error(int error_code, const char* message) noexcept; FMT_API void report_windows_error(int error_code, const char* message) noexcept;
#else #else
inline const std::error_category& system_category() noexcept { inline auto system_category() noexcept -> const std::error_category& {
return std::system_category(); return std::system_category();
} }
#endif // _WIN32 #endif // _WIN32
@ -244,7 +193,7 @@ class buffered_file {
other.file_ = nullptr; other.file_ = nullptr;
} }
buffered_file& operator=(buffered_file&& other) { auto operator=(buffered_file&& other) -> buffered_file& {
close(); close();
file_ = other.file_; file_ = other.file_;
other.file_ = nullptr; other.file_ = nullptr;
@ -258,21 +207,20 @@ class buffered_file {
FMT_API void close(); FMT_API void close();
// Returns the pointer to a FILE object representing this file. // Returns the pointer to a FILE object representing this file.
FILE* get() const noexcept { return file_; } auto get() const noexcept -> FILE* { return file_; }
FMT_API int descriptor() const; FMT_API auto descriptor() const -> int;
void vprint(string_view format_str, format_args args) { template <typename... T>
fmt::vprint(file_, format_str, args); inline void print(string_view fmt, const T&... args) {
} const auto& vargs = fmt::make_format_args(args...);
detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
template <typename... Args> : fmt::vprint(file_, fmt, vargs);
inline void print(string_view format_str, const Args&... args) {
vprint(format_str, fmt::make_format_args(args...));
} }
}; };
#if FMT_USE_FCNTL #if FMT_USE_FCNTL
// A file. Closed file is represented by a file object with descriptor -1. // A file. Closed file is represented by a file object with descriptor -1.
// Methods that are not declared with noexcept may throw // Methods that are not declared with noexcept may throw
// fmt::system_error in case of failure. Note that some errors such as // fmt::system_error in case of failure. Note that some errors such as
@ -286,6 +234,8 @@ class FMT_API file {
// Constructs a file object with a given descriptor. // Constructs a file object with a given descriptor.
explicit file(int fd) : fd_(fd) {} explicit file(int fd) : fd_(fd) {}
friend struct pipe;
public: public:
// Possible values for the oflag argument to the constructor. // Possible values for the oflag argument to the constructor.
enum { enum {
@ -310,7 +260,7 @@ class FMT_API file {
file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
// Move assignment is not noexcept because close may throw. // Move assignment is not noexcept because close may throw.
file& operator=(file&& other) { auto operator=(file&& other) -> file& {
close(); close();
fd_ = other.fd_; fd_ = other.fd_;
other.fd_ = -1; other.fd_ = -1;
@ -321,24 +271,24 @@ class FMT_API file {
~file() noexcept; ~file() noexcept;
// Returns the file descriptor. // Returns the file descriptor.
int descriptor() const noexcept { return fd_; } auto descriptor() const noexcept -> int { return fd_; }
// Closes the file. // Closes the file.
void close(); void close();
// Returns the file size. The size has signed type for consistency with // Returns the file size. The size has signed type for consistency with
// stat::st_size. // stat::st_size.
long long size() const; auto size() const -> long long;
// Attempts to read count bytes from the file into the specified buffer. // Attempts to read count bytes from the file into the specified buffer.
size_t read(void* buffer, size_t count); auto read(void* buffer, size_t count) -> size_t;
// Attempts to write count bytes from the specified buffer to the file. // Attempts to write count bytes from the specified buffer to the file.
size_t write(const void* buffer, size_t count); auto write(const void* buffer, size_t count) -> size_t;
// Duplicates a file descriptor with the dup function and returns // Duplicates a file descriptor with the dup function and returns
// the duplicate as a file object. // the duplicate as a file object.
static file dup(int fd); static auto dup(int fd) -> file;
// Makes fd be the copy of this file descriptor, closing fd first if // Makes fd be the copy of this file descriptor, closing fd first if
// necessary. // necessary.
@ -348,24 +298,35 @@ class FMT_API file {
// necessary. // necessary.
void dup2(int fd, std::error_code& ec) noexcept; void dup2(int fd, std::error_code& ec) noexcept;
// Creates a pipe setting up read_end and write_end file objects for reading
// and writing respectively.
static void pipe(file& read_end, file& write_end);
// Creates a buffered_file object associated with this file and detaches // Creates a buffered_file object associated with this file and detaches
// this file object from the file. // this file object from the file.
buffered_file fdopen(const char* mode); auto fdopen(const char* mode) -> buffered_file;
# if defined(_WIN32) && !defined(__MINGW32__)
// Opens a file and constructs a file object representing this file by
// wcstring_view filename. Windows only.
static file open_windows_file(wcstring_view path, int oflag);
# endif
};
struct FMT_API pipe {
file read_end;
file write_end;
// Creates a pipe setting up read_end and write_end file objects for reading
// and writing respectively.
pipe();
}; };
// Returns the memory page size. // Returns the memory page size.
long getpagesize(); auto getpagesize() -> long;
FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
struct buffer_size { struct buffer_size {
buffer_size() = default; buffer_size() = default;
size_t value = 0; size_t value = 0;
buffer_size operator=(size_t val) const { auto operator=(size_t val) const -> buffer_size {
auto bs = buffer_size(); auto bs = buffer_size();
bs.value = val; bs.value = val;
return bs; return bs;
@ -397,82 +358,82 @@ struct ostream_params {
# endif # endif
}; };
FMT_END_DETAIL_NAMESPACE class file_buffer final : public buffer<char> {
// Added {} below to work around default constructor error known to
// occur in Xcode versions 7.2.1 and 8.2.1.
constexpr detail::buffer_size buffer_size{};
/** A fast output stream which is not thread-safe. */
class FMT_API ostream final : private detail::buffer<char> {
private: private:
file file_; file file_;
void grow(size_t) override; FMT_API static void grow(buffer<char>& buf, size_t);
ostream(cstring_view path, const detail::ostream_params& params)
: file_(path, params.oflag) {
set(new char[params.buffer_size], params.buffer_size);
}
public: public:
ostream(ostream&& other) FMT_API file_buffer(cstring_view path, const ostream_params& params);
: detail::buffer<char>(other.data(), other.size(), other.capacity()), FMT_API file_buffer(file_buffer&& other) noexcept;
file_(std::move(other.file_)) { FMT_API ~file_buffer();
other.clear();
other.set(nullptr, 0);
}
~ostream() {
flush();
delete[] data();
}
void flush() { void flush() {
if (size() == 0) return; if (size() == 0) return;
file_.write(data(), size()); file_.write(data(), size() * sizeof(data()[0]));
clear(); clear();
} }
template <typename... T>
friend ostream output_file(cstring_view path, T... params);
void close() { void close() {
flush(); flush();
file_.close(); file_.close();
} }
};
/** } // namespace detail
Formats ``args`` according to specifications in ``fmt`` and writes the
output to the file. constexpr auto buffer_size = detail::buffer_size();
*/
/// A fast output stream for writing from a single thread. Writing from
/// multiple threads without external synchronization may result in a data race.
class FMT_API ostream {
private:
FMT_MSC_WARNING(suppress : 4251)
detail::file_buffer buffer_;
ostream(cstring_view path, const detail::ostream_params& params)
: buffer_(path, params) {}
public:
ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
~ostream();
void flush() { buffer_.flush(); }
template <typename... T>
friend auto output_file(cstring_view path, T... params) -> ostream;
void close() { buffer_.close(); }
/// Formats `args` according to specifications in `fmt` and writes the
/// output to the file.
template <typename... T> void print(format_string<T...> fmt, T&&... args) { template <typename... T> void print(format_string<T...> fmt, T&&... args) {
vformat_to(detail::buffer_appender<char>(*this), fmt, vformat_to(appender(buffer_), fmt, fmt::make_format_args(args...));
fmt::make_format_args(args...));
} }
}; };
/** /**
\rst * Opens a file for writing. Supported parameters passed in `params`:
Opens a file for writing. Supported parameters passed in *params*: *
* - `<integer>`: Flags passed to [open](
* ``<integer>``: Flags passed to `open * https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)
<https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_ * (`file::WRONLY | file::CREATE | file::TRUNC` by default)
(``file::WRONLY | file::CREATE | file::TRUNC`` by default) * - `buffer_size=<integer>`: Output buffer size
* ``buffer_size=<integer>``: Output buffer size *
* **Example**:
**Example**:: *
* auto out = fmt::output_file("guide.txt");
auto out = fmt::output_file("guide.txt"); * out.print("Don't {}", "Panic");
out.print("Don't {}", "Panic");
\endrst
*/ */
template <typename... T> template <typename... T>
inline ostream output_file(cstring_view path, T... params) { inline auto output_file(cstring_view path, T... params) -> ostream {
return {path, detail::ostream_params(params...)}; return {path, detail::ostream_params(params...)};
} }
#endif // FMT_USE_FCNTL #endif // FMT_USE_FCNTL
FMT_MODULE_EXPORT_END FMT_END_EXPORT
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // FMT_OS_H_ #endif // FMT_OS_H_

184
Tool/spdlog/include/spdlog/fmt/bundled/ostream.h
View File

@ -8,61 +8,29 @@
#ifndef FMT_OSTREAM_H_ #ifndef FMT_OSTREAM_H_
#define FMT_OSTREAM_H_ #define FMT_OSTREAM_H_
#include <fstream> #ifndef FMT_MODULE
#include <ostream> # include <fstream> // std::filebuf
#if defined(_WIN32) && defined(__GLIBCXX__)
# include <ext/stdio_filebuf.h>
# include <ext/stdio_sync_filebuf.h>
#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
# include <__std_stream>
#endif #endif
#include "format.h" #ifdef _WIN32
# ifdef __GLIBCXX__
# include <ext/stdio_filebuf.h>
# include <ext/stdio_sync_filebuf.h>
# endif
# include <io.h>
#endif
#include "chrono.h" // formatbuf
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
template <typename OutputIt, typename Char> class basic_printf_context;
namespace detail { namespace detail {
// Checks if T has a user-defined operator<<.
template <typename T, typename Char, typename Enable = void>
class is_streamable {
private:
template <typename U>
static auto test(int)
-> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
<< std::declval<U>()) != 0>;
template <typename> static auto test(...) -> std::false_type;
using result = decltype(test<T>(0));
public:
is_streamable() = default;
static const bool value = result::value;
};
// Formatting of built-in types and arrays is intentionally disabled because
// it's handled by standard (non-ostream) formatters.
template <typename T, typename Char>
struct is_streamable<
T, Char,
enable_if_t<
std::is_arithmetic<T>::value || std::is_array<T>::value ||
std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
std::is_same<T, std_string_view<Char>>::value ||
(std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
: std::false_type {};
// Generate a unique explicit instantion in every translation unit using a tag // Generate a unique explicit instantion in every translation unit using a tag
// type in an anonymous namespace. // type in an anonymous namespace.
namespace { namespace {
struct file_access_tag {}; struct file_access_tag {};
} // namespace } // namespace
template <class Tag, class BufType, FILE* BufType::*FileMemberPtr> template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
class file_access { class file_access {
friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; } friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
}; };
@ -71,36 +39,40 @@ class file_access {
template class file_access<file_access_tag, std::filebuf, template class file_access<file_access_tag, std::filebuf,
&std::filebuf::_Myfile>; &std::filebuf::_Myfile>;
auto get_file(std::filebuf&) -> FILE*; auto get_file(std::filebuf&) -> FILE*;
#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
template class file_access<file_access_tag, std::__stdoutbuf<char>,
&std::__stdoutbuf<char>::__file_>;
auto get_file(std::__stdoutbuf<char>&) -> FILE*;
#endif #endif
inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) { inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
#if FMT_MSC_VERSION -> bool {
FILE* f = nullptr;
#if FMT_MSC_VERSION && FMT_USE_RTTI
if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf())) if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
if (FILE* f = get_file(*buf)) return write_console(f, data); f = get_file(*buf);
#elif defined(_WIN32) && defined(__GLIBCXX__) else
auto* rdbuf = os.rdbuf(); return false;
FILE* c_file; #elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf)) auto* rdbuf = os.rdbuf();
c_file = fbuf->file(); if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf)) f = sfbuf->file();
c_file = fbuf->file(); else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
f = fbuf->file();
else else
return false; return false;
if (c_file) return write_console(c_file, data);
#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
if (FILE* f = get_file(*buf)) return write_console(f, data);
#else #else
ignore_unused(os, data); ignore_unused(os, data, f);
#endif
#ifdef _WIN32
if (f) {
int fd = _fileno(f);
if (_isatty(fd)) {
os.flush();
return write_console(fd, data);
}
}
#endif #endif
return false; return false;
} }
inline bool write_ostream_unicode(std::wostream&, inline auto write_ostream_unicode(std::wostream&,
fmt::basic_string_view<wchar_t>) { fmt::basic_string_view<wchar_t>) -> bool {
return false; return false;
} }
@ -121,18 +93,19 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
} }
template <typename Char, typename T> template <typename Char, typename T>
void format_value(buffer<Char>& buf, const T& value, void format_value(buffer<Char>& buf, const T& value) {
locale_ref loc = locale_ref()) {
auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf); auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
auto&& output = std::basic_ostream<Char>(&format_buf); auto&& output = std::basic_ostream<Char>(&format_buf);
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
if (loc) output.imbue(loc.get<std::locale>()); output.imbue(std::locale::classic()); // The default is always unlocalized.
#endif #endif
output << value; output << value;
output.exceptions(std::ios_base::failbit | std::ios_base::badbit); output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
} }
template <typename T> struct streamed_view { const T& value; }; template <typename T> struct streamed_view {
const T& value;
};
} // namespace detail } // namespace detail
@ -141,11 +114,10 @@ template <typename Char>
struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> { struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
void set_debug_format() = delete; void set_debug_format() = delete;
template <typename T, typename OutputIt> template <typename T, typename Context>
auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
-> OutputIt {
auto buffer = basic_memory_buffer<Char>(); auto buffer = basic_memory_buffer<Char>();
format_value(buffer, value, ctx.locale()); detail::format_value(buffer, value);
return formatter<basic_string_view<Char>, Char>::format( return formatter<basic_string_view<Char>, Char>::format(
{buffer.data(), buffer.size()}, ctx); {buffer.data(), buffer.size()}, ctx);
} }
@ -156,37 +128,28 @@ using ostream_formatter = basic_ostream_formatter<char>;
template <typename T, typename Char> template <typename T, typename Char>
struct formatter<detail::streamed_view<T>, Char> struct formatter<detail::streamed_view<T>, Char>
: basic_ostream_formatter<Char> { : basic_ostream_formatter<Char> {
template <typename OutputIt> template <typename Context>
auto format(detail::streamed_view<T> view, auto format(detail::streamed_view<T> view, Context& ctx) const
basic_format_context<OutputIt, Char>& ctx) const -> OutputIt { -> decltype(ctx.out()) {
return basic_ostream_formatter<Char>::format(view.value, ctx); return basic_ostream_formatter<Char>::format(view.value, ctx);
} }
}; };
/** /**
\rst * Returns a view that formats `value` via an ostream `operator<<`.
Returns a view that formats `value` via an ostream ``operator<<``. *
* **Example**:
**Example**:: *
* fmt::print("Current thread id: {}\n",
fmt::print("Current thread id: {}\n", * fmt::streamed(std::this_thread::get_id()));
fmt::streamed(std::this_thread::get_id()));
\endrst
*/ */
template <typename T> template <typename T>
auto streamed(const T& value) -> detail::streamed_view<T> { constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
return {value}; return {value};
} }
namespace detail { namespace detail {
// Formats an object of type T that has an overloaded ostream operator<<.
template <typename T, typename Char>
struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
: basic_ostream_formatter<Char> {
using basic_ostream_formatter<Char>::format;
};
inline void vprint_directly(std::ostream& os, string_view format_str, inline void vprint_directly(std::ostream& os, string_view format_str,
format_args args) { format_args args) {
auto buffer = memory_buffer(); auto buffer = memory_buffer();
@ -196,10 +159,10 @@ inline void vprint_directly(std::ostream& os, string_view format_str,
} // namespace detail } // namespace detail
FMT_MODULE_EXPORT template <typename Char> FMT_EXPORT template <typename Char>
void vprint(std::basic_ostream<Char>& os, void vprint(std::basic_ostream<Char>& os,
basic_string_view<type_identity_t<Char>> format_str, basic_string_view<type_identity_t<Char>> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) { typename detail::vformat_args<Char>::type args) {
auto buffer = basic_memory_buffer<Char>(); auto buffer = basic_memory_buffer<Char>();
detail::vformat_to(buffer, format_str, args); detail::vformat_to(buffer, format_str, args);
if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return; if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
@ -207,29 +170,40 @@ void vprint(std::basic_ostream<Char>& os,
} }
/** /**
\rst * Prints formatted data to the stream `os`.
Prints formatted data to the stream *os*. *
* **Example**:
**Example**:: *
* fmt::print(cerr, "Don't {}!", "panic");
fmt::print(cerr, "Don't {}!", "panic");
\endrst
*/ */
FMT_MODULE_EXPORT template <typename... T> FMT_EXPORT template <typename... T>
void print(std::ostream& os, format_string<T...> fmt, T&&... args) { void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
const auto& vargs = fmt::make_format_args(args...); const auto& vargs = fmt::make_format_args(args...);
if (detail::is_utf8()) if (detail::use_utf8())
vprint(os, fmt, vargs); vprint(os, fmt, vargs);
else else
detail::vprint_directly(os, fmt, vargs); detail::vprint_directly(os, fmt, vargs);
} }
FMT_MODULE_EXPORT FMT_EXPORT
template <typename... Args> template <typename... Args>
void print(std::wostream& os, void print(std::wostream& os,
basic_format_string<wchar_t, type_identity_t<Args>...> fmt, basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
Args&&... args) { Args&&... args) {
vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...)); vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
}
FMT_EXPORT template <typename... T>
void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
}
FMT_EXPORT
template <typename... Args>
void println(std::wostream& os,
basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
Args&&... args) {
print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
} }
FMT_END_NAMESPACE FMT_END_NAMESPACE

504
Tool/spdlog/include/spdlog/fmt/bundled/printf.h
View File

@ -8,107 +8,103 @@
#ifndef FMT_PRINTF_H_ #ifndef FMT_PRINTF_H_
#define FMT_PRINTF_H_ #define FMT_PRINTF_H_
#include <algorithm> // std::max #ifndef FMT_MODULE
#include <limits> // std::numeric_limits # include <algorithm> // std::max
# include <limits> // std::numeric_limits
#endif
#include "format.h" #include "format.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN FMT_BEGIN_EXPORT
template <typename T> struct printf_formatter { printf_formatter() = delete; }; template <typename T> struct printf_formatter {
printf_formatter() = delete;
template <typename Char>
class basic_printf_parse_context : public basic_format_parse_context<Char> {
using basic_format_parse_context<Char>::basic_format_parse_context;
}; };
template <typename OutputIt, typename Char> class basic_printf_context { template <typename Char> class basic_printf_context {
private: private:
OutputIt out_; basic_appender<Char> out_;
basic_format_args<basic_printf_context> args_; basic_format_args<basic_printf_context> args_;
static_assert(std::is_same<Char, char>::value ||
std::is_same<Char, wchar_t>::value,
"Unsupported code unit type.");
public: public:
using char_type = Char; using char_type = Char;
using format_arg = basic_format_arg<basic_printf_context>; using parse_context_type = basic_format_parse_context<Char>;
using parse_context_type = basic_printf_parse_context<Char>;
template <typename T> using formatter_type = printf_formatter<T>; template <typename T> using formatter_type = printf_formatter<T>;
/** /// Constructs a `printf_context` object. References to the arguments are
\rst /// stored in the context object so make sure they have appropriate lifetimes.
Constructs a ``printf_context`` object. References to the arguments are basic_printf_context(basic_appender<Char> out,
stored in the context object so make sure they have appropriate lifetimes.
\endrst
*/
basic_printf_context(OutputIt out,
basic_format_args<basic_printf_context> args) basic_format_args<basic_printf_context> args)
: out_(out), args_(args) {} : out_(out), args_(args) {}
OutputIt out() { return out_; } auto out() -> basic_appender<Char> { return out_; }
void advance_to(OutputIt it) { out_ = it; } void advance_to(basic_appender<Char>) {}
detail::locale_ref locale() { return {}; } auto locale() -> detail::locale_ref { return {}; }
format_arg arg(int id) const { return args_.get(id); } auto arg(int id) const -> basic_format_arg<basic_printf_context> {
return args_.get(id);
FMT_CONSTEXPR void on_error(const char* message) {
detail::error_handler().on_error(message);
} }
}; };
FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
// Checks if a value fits in int - used to avoid warnings about comparing // Checks if a value fits in int - used to avoid warnings about comparing
// signed and unsigned integers. // signed and unsigned integers.
template <bool IsSigned> struct int_checker { template <bool IsSigned> struct int_checker {
template <typename T> static bool fits_in_int(T value) { template <typename T> static auto fits_in_int(T value) -> bool {
unsigned max = max_value<int>(); unsigned max = to_unsigned(max_value<int>());
return value <= max; return value <= max;
} }
static bool fits_in_int(bool) { return true; } static auto fits_in_int(bool) -> bool { return true; }
}; };
template <> struct int_checker<true> { template <> struct int_checker<true> {
template <typename T> static bool fits_in_int(T value) { template <typename T> static auto fits_in_int(T value) -> bool {
return value >= (std::numeric_limits<int>::min)() && return value >= (std::numeric_limits<int>::min)() &&
value <= max_value<int>(); value <= max_value<int>();
} }
static bool fits_in_int(int) { return true; } static auto fits_in_int(int) -> bool { return true; }
}; };
class printf_precision_handler { struct printf_precision_handler {
public:
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
int operator()(T value) { auto operator()(T value) -> int {
if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value)) if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
FMT_THROW(format_error("number is too big")); report_error("number is too big");
return (std::max)(static_cast<int>(value), 0); return (std::max)(static_cast<int>(value), 0);
} }
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
int operator()(T) { auto operator()(T) -> int {
FMT_THROW(format_error("precision is not integer")); report_error("precision is not integer");
return 0; return 0;
} }
}; };
// An argument visitor that returns true iff arg is a zero integer. // An argument visitor that returns true iff arg is a zero integer.
class is_zero_int { struct is_zero_int {
public:
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
bool operator()(T value) { auto operator()(T value) -> bool {
return value == 0; return value == 0;
} }
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
bool operator()(T) { auto operator()(T) -> bool {
return false; return false;
} }
}; };
template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {}; template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
template <> struct make_unsigned_or_bool<bool> { using type = bool; }; template <> struct make_unsigned_or_bool<bool> {
using type = bool;
};
template <typename T, typename Context> class arg_converter { template <typename T, typename Context> class arg_converter {
private: private:
@ -132,22 +128,23 @@ template <typename T, typename Context> class arg_converter {
if (const_check(sizeof(target_type) <= sizeof(int))) { if (const_check(sizeof(target_type) <= sizeof(int))) {
// Extra casts are used to silence warnings. // Extra casts are used to silence warnings.
if (is_signed) { if (is_signed) {
arg_ = detail::make_arg<Context>( auto n = static_cast<int>(static_cast<target_type>(value));
static_cast<int>(static_cast<target_type>(value))); arg_ = detail::make_arg<Context>(n);
} else { } else {
using unsigned_type = typename make_unsigned_or_bool<target_type>::type; using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
arg_ = detail::make_arg<Context>( auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
static_cast<unsigned>(static_cast<unsigned_type>(value))); arg_ = detail::make_arg<Context>(n);
} }
} else { } else {
if (is_signed) { if (is_signed) {
// glibc's printf doesn't sign extend arguments of smaller types: // glibc's printf doesn't sign extend arguments of smaller types:
// std::printf("%lld", -42); // prints "4294967254" // std::printf("%lld", -42); // prints "4294967254"
// but we don't have to do the same because it's a UB. // but we don't have to do the same because it's a UB.
arg_ = detail::make_arg<Context>(static_cast<long long>(value)); auto n = static_cast<long long>(value);
arg_ = detail::make_arg<Context>(n);
} else { } else {
arg_ = detail::make_arg<Context>( auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
static_cast<typename make_unsigned_or_bool<U>::type>(value)); arg_ = detail::make_arg<Context>(n);
} }
} }
} }
@ -162,7 +159,7 @@ template <typename T, typename Context> class arg_converter {
// unsigned). // unsigned).
template <typename T, typename Context, typename Char> template <typename T, typename Context, typename Char>
void convert_arg(basic_format_arg<Context>& arg, Char type) { void convert_arg(basic_format_arg<Context>& arg, Char type) {
visit_format_arg(arg_converter<T, Context>(arg, type), arg); arg.visit(arg_converter<T, Context>(arg, type));
} }
// Converts an integer argument to char for printf. // Converts an integer argument to char for printf.
@ -175,8 +172,8 @@ template <typename Context> class char_converter {
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
void operator()(T value) { void operator()(T value) {
arg_ = detail::make_arg<Context>( auto c = static_cast<typename Context::char_type>(value);
static_cast<typename Context::char_type>(value)); arg_ = detail::make_arg<Context>(c);
} }
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@ -186,122 +183,126 @@ template <typename Context> class char_converter {
// An argument visitor that return a pointer to a C string if argument is a // An argument visitor that return a pointer to a C string if argument is a
// string or null otherwise. // string or null otherwise.
template <typename Char> struct get_cstring { template <typename Char> struct get_cstring {
template <typename T> const Char* operator()(T) { return nullptr; } template <typename T> auto operator()(T) -> const Char* { return nullptr; }
const Char* operator()(const Char* s) { return s; } auto operator()(const Char* s) -> const Char* { return s; }
}; };
// Checks if an argument is a valid printf width specifier and sets // Checks if an argument is a valid printf width specifier and sets
// left alignment if it is negative. // left alignment if it is negative.
template <typename Char> class printf_width_handler { class printf_width_handler {
private: private:
using format_specs = basic_format_specs<Char>;
format_specs& specs_; format_specs& specs_;
public: public:
explicit printf_width_handler(format_specs& specs) : specs_(specs) {} explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
unsigned operator()(T value) { auto operator()(T value) -> unsigned {
auto width = static_cast<uint32_or_64_or_128_t<T>>(value); auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
if (detail::is_negative(value)) { if (detail::is_negative(value)) {
specs_.align = align::left; specs_.align = align::left;
width = 0 - width; width = 0 - width;
} }
unsigned int_max = max_value<int>(); unsigned int_max = to_unsigned(max_value<int>());
if (width > int_max) FMT_THROW(format_error("number is too big")); if (width > int_max) report_error("number is too big");
return static_cast<unsigned>(width); return static_cast<unsigned>(width);
} }
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
unsigned operator()(T) { auto operator()(T) -> unsigned {
FMT_THROW(format_error("width is not integer")); report_error("width is not integer");
return 0; return 0;
} }
}; };
// The ``printf`` argument formatter. // Workaround for a bug with the XL compiler when initializing
template <typename OutputIt, typename Char> // printf_arg_formatter's base class.
template <typename Char>
auto make_arg_formatter(basic_appender<Char> iter, format_specs& s)
-> arg_formatter<Char> {
return {iter, s, locale_ref()};
}
// The `printf` argument formatter.
template <typename Char>
class printf_arg_formatter : public arg_formatter<Char> { class printf_arg_formatter : public arg_formatter<Char> {
private: private:
using base = arg_formatter<Char>; using base = arg_formatter<Char>;
using context_type = basic_printf_context<OutputIt, Char>; using context_type = basic_printf_context<Char>;
using format_specs = basic_format_specs<Char>;
context_type& context_; context_type& context_;
OutputIt write_null_pointer(bool is_string = false) { void write_null_pointer(bool is_string = false) {
auto s = this->specs; auto s = this->specs;
s.type = presentation_type::none; s.type = presentation_type::none;
return write_bytes(this->out, is_string ? "(null)" : "(nil)", s); write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
} }
public: public:
printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx) printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
: base{iter, s, locale_ref()}, context_(ctx) {} context_type& ctx)
: base(make_arg_formatter(iter, s)), context_(ctx) {}
OutputIt operator()(monostate value) { return base::operator()(value); } void operator()(monostate value) { base::operator()(value); }
template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)> template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
OutputIt operator()(T value) { void operator()(T value) {
// MSVC2013 fails to compile separate overloads for bool and Char so use // MSVC2013 fails to compile separate overloads for bool and Char so use
// std::is_same instead. // std::is_same instead.
if (std::is_same<T, Char>::value) { if (!std::is_same<T, Char>::value) {
format_specs fmt_specs = this->specs; base::operator()(value);
if (fmt_specs.type != presentation_type::none && return;
fmt_specs.type != presentation_type::chr) {
return (*this)(static_cast<int>(value));
}
fmt_specs.sign = sign::none;
fmt_specs.alt = false;
fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types.
// align::numeric needs to be overwritten here since the '0' flag is
// ignored for non-numeric types
if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
fmt_specs.align = align::right;
return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
} }
return base::operator()(value); format_specs s = this->specs;
if (s.type != presentation_type::none && s.type != presentation_type::chr) {
return (*this)(static_cast<int>(value));
}
s.sign = sign::none;
s.alt = false;
s.fill = ' '; // Ignore '0' flag for char types.
// align::numeric needs to be overwritten here since the '0' flag is
// ignored for non-numeric types
if (s.align == align::none || s.align == align::numeric)
s.align = align::right;
write<Char>(this->out, static_cast<Char>(value), s);
} }
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
OutputIt operator()(T value) { void operator()(T value) {
return base::operator()(value); base::operator()(value);
} }
/** Formats a null-terminated C string. */ void operator()(const char* value) {
OutputIt operator()(const char* value) { if (value)
if (value) return base::operator()(value); base::operator()(value);
return write_null_pointer(this->specs.type != presentation_type::pointer); else
write_null_pointer(this->specs.type != presentation_type::pointer);
} }
/** Formats a null-terminated wide C string. */ void operator()(const wchar_t* value) {
OutputIt operator()(const wchar_t* value) { if (value)
if (value) return base::operator()(value); base::operator()(value);
return write_null_pointer(this->specs.type != presentation_type::pointer); else
write_null_pointer(this->specs.type != presentation_type::pointer);
} }
OutputIt operator()(basic_string_view<Char> value) { void operator()(basic_string_view<Char> value) { base::operator()(value); }
return base::operator()(value);
void operator()(const void* value) {
if (value)
base::operator()(value);
else
write_null_pointer();
} }
/** Formats a pointer. */ void operator()(typename basic_format_arg<context_type>::handle handle) {
OutputIt operator()(const void* value) { auto parse_ctx = basic_format_parse_context<Char>({});
return value ? base::operator()(value) : write_null_pointer();
}
/** Formats an argument of a custom (user-defined) type. */
OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
auto parse_ctx =
basic_printf_parse_context<Char>(basic_string_view<Char>());
handle.format(parse_ctx, context_); handle.format(parse_ctx, context_);
return this->out;
} }
}; };
template <typename Char> template <typename Char>
void parse_flags(basic_format_specs<Char>& specs, const Char*& it, void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
const Char* end) {
for (; it != end; ++it) { for (; it != end; ++it) {
switch (*it) { switch (*it) {
case '-': case '-':
@ -311,12 +312,10 @@ void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
specs.sign = sign::plus; specs.sign = sign::plus;
break; break;
case '0': case '0':
specs.fill[0] = '0'; specs.fill = '0';
break; break;
case ' ': case ' ':
if (specs.sign != sign::plus) { if (specs.sign != sign::plus) specs.sign = sign::space;
specs.sign = sign::space;
}
break; break;
case '#': case '#':
specs.alt = true; specs.alt = true;
@ -328,8 +327,8 @@ void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
} }
template <typename Char, typename GetArg> template <typename Char, typename GetArg>
int parse_header(const Char*& it, const Char* end, auto parse_header(const Char*& it, const Char* end, format_specs& specs,
basic_format_specs<Char>& specs, GetArg get_arg) { GetArg get_arg) -> int {
int arg_index = -1; int arg_index = -1;
Char c = *it; Char c = *it;
if (c >= '0' && c <= '9') { if (c >= '0' && c <= '9') {
@ -340,11 +339,11 @@ int parse_header(const Char*& it, const Char* end,
++it; ++it;
arg_index = value != -1 ? value : max_value<int>(); arg_index = value != -1 ? value : max_value<int>();
} else { } else {
if (c == '0') specs.fill[0] = '0'; if (c == '0') specs.fill = '0';
if (value != 0) { if (value != 0) {
// Nonzero value means that we parsed width and don't need to // Nonzero value means that we parsed width and don't need to
// parse it or flags again, so return now. // parse it or flags again, so return now.
if (value == -1) FMT_THROW(format_error("number is too big")); if (value == -1) report_error("number is too big");
specs.width = value; specs.width = value;
return arg_index; return arg_index;
} }
@ -355,23 +354,68 @@ int parse_header(const Char*& it, const Char* end,
if (it != end) { if (it != end) {
if (*it >= '0' && *it <= '9') { if (*it >= '0' && *it <= '9') {
specs.width = parse_nonnegative_int(it, end, -1); specs.width = parse_nonnegative_int(it, end, -1);
if (specs.width == -1) FMT_THROW(format_error("number is too big")); if (specs.width == -1) report_error("number is too big");
} else if (*it == '*') { } else if (*it == '*') {
++it; ++it;
specs.width = static_cast<int>(visit_format_arg( specs.width = static_cast<int>(
detail::printf_width_handler<Char>(specs), get_arg(-1))); get_arg(-1).visit(detail::printf_width_handler(specs)));
} }
} }
return arg_index; return arg_index;
} }
inline auto parse_printf_presentation_type(char c, type t, bool& upper)
-> presentation_type {
using pt = presentation_type;
constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
switch (c) {
case 'd':
return in(t, integral_set) ? pt::dec : pt::none;
case 'o':
return in(t, integral_set) ? pt::oct : pt::none;
case 'X':
upper = true;
FMT_FALLTHROUGH;
case 'x':
return in(t, integral_set) ? pt::hex : pt::none;
case 'E':
upper = true;
FMT_FALLTHROUGH;
case 'e':
return in(t, float_set) ? pt::exp : pt::none;
case 'F':
upper = true;
FMT_FALLTHROUGH;
case 'f':
return in(t, float_set) ? pt::fixed : pt::none;
case 'G':
upper = true;
FMT_FALLTHROUGH;
case 'g':
return in(t, float_set) ? pt::general : pt::none;
case 'A':
upper = true;
FMT_FALLTHROUGH;
case 'a':
return in(t, float_set) ? pt::hexfloat : pt::none;
case 'c':
return in(t, integral_set) ? pt::chr : pt::none;
case 's':
return in(t, string_set | cstring_set) ? pt::string : pt::none;
case 'p':
return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
default:
return pt::none;
}
}
template <typename Char, typename Context> template <typename Char, typename Context>
void vprintf(buffer<Char>& buf, basic_string_view<Char> format, void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
basic_format_args<Context> args) { basic_format_args<Context> args) {
using OutputIt = buffer_appender<Char>; using iterator = basic_appender<Char>;
auto out = OutputIt(buf); auto out = iterator(buf);
auto context = basic_printf_context<OutputIt, Char>(out, args); auto context = basic_printf_context<Char>(out, args);
auto parse_ctx = basic_printf_parse_context<Char>(format); auto parse_ctx = basic_format_parse_context<Char>(format);
// Returns the argument with specified index or, if arg_index is -1, the next // Returns the argument with specified index or, if arg_index is -1, the next
// argument. // argument.
@ -387,26 +431,24 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
const Char* end = parse_ctx.end(); const Char* end = parse_ctx.end();
auto it = start; auto it = start;
while (it != end) { while (it != end) {
if (!detail::find<false, Char>(it, end, '%', it)) { if (!find<false, Char>(it, end, '%', it)) {
it = end; // detail::find leaves it == nullptr if it doesn't find '%' it = end; // find leaves it == nullptr if it doesn't find '%'.
break; break;
} }
Char c = *it++; Char c = *it++;
if (it != end && *it == c) { if (it != end && *it == c) {
out = detail::write( write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
start = ++it; start = ++it;
continue; continue;
} }
out = detail::write(out, basic_string_view<Char>( write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
start, detail::to_unsigned(it - 1 - start)));
basic_format_specs<Char> specs; auto specs = format_specs();
specs.align = align::right; specs.align = align::right;
// Parse argument index, flags and width. // Parse argument index, flags and width.
int arg_index = parse_header(it, end, specs, get_arg); int arg_index = parse_header(it, end, specs, get_arg);
if (arg_index == 0) parse_ctx.on_error("argument not found"); if (arg_index == 0) report_error("argument not found");
// Parse precision. // Parse precision.
if (it != end && *it == '.') { if (it != end && *it == '.') {
@ -416,8 +458,8 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
specs.precision = parse_nonnegative_int(it, end, 0); specs.precision = parse_nonnegative_int(it, end, 0);
} else if (c == '*') { } else if (c == '*') {
++it; ++it;
specs.precision = static_cast<int>( specs.precision =
visit_format_arg(detail::printf_precision_handler(), get_arg(-1))); static_cast<int>(get_arg(-1).visit(printf_precision_handler()));
} else { } else {
specs.precision = 0; specs.precision = 0;
} }
@ -426,32 +468,30 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
auto arg = get_arg(arg_index); auto arg = get_arg(arg_index);
// For d, i, o, u, x, and X conversion specifiers, if a precision is // For d, i, o, u, x, and X conversion specifiers, if a precision is
// specified, the '0' flag is ignored // specified, the '0' flag is ignored
if (specs.precision >= 0 && arg.is_integral()) if (specs.precision >= 0 && arg.is_integral()) {
specs.fill[0] = // Ignore '0' for non-numeric types or if '-' present.
' '; // Ignore '0' flag for non-numeric types or if '-' present. specs.fill = ' ';
if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) { }
auto str = visit_format_arg(detail::get_cstring<Char>(), arg); if (specs.precision >= 0 && arg.type() == type::cstring_type) {
auto str = arg.visit(get_cstring<Char>());
auto str_end = str + specs.precision; auto str_end = str + specs.precision;
auto nul = std::find(str, str_end, Char()); auto nul = std::find(str, str_end, Char());
arg = detail::make_arg<basic_printf_context<OutputIt, Char>>( auto sv = basic_string_view<Char>(
basic_string_view<Char>( str, to_unsigned(nul != str_end ? nul - str : specs.precision));
str, detail::to_unsigned(nul != str_end ? nul - str arg = make_arg<basic_printf_context<Char>>(sv);
: specs.precision)));
} }
if (specs.alt && visit_format_arg(detail::is_zero_int(), arg)) if (specs.alt && arg.visit(is_zero_int())) specs.alt = false;
specs.alt = false; if (specs.fill.template get<Char>() == '0') {
if (specs.fill[0] == '0') {
if (arg.is_arithmetic() && specs.align != align::left) if (arg.is_arithmetic() && specs.align != align::left)
specs.align = align::numeric; specs.align = align::numeric;
else else
specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types or if '-' specs.fill = ' '; // Ignore '0' flag for non-numeric types or if '-'
// flag is also present. // flag is also present.
} }
// Parse length and convert the argument to the required type. // Parse length and convert the argument to the required type.
c = it != end ? *it++ : 0; c = it != end ? *it++ : 0;
Char t = it != end ? *it : 0; Char t = it != end ? *it : 0;
using detail::convert_arg;
switch (c) { switch (c) {
case 'h': case 'h':
if (t == 'h') { if (t == 'h') {
@ -490,7 +530,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
} }
// Parse type. // Parse type.
if (it == end) FMT_THROW(format_error("invalid format string")); if (it == end) report_error("invalid format string");
char type = static_cast<char>(*it++); char type = static_cast<char>(*it++);
if (arg.is_integral()) { if (arg.is_integral()) {
// Normalize type. // Normalize type.
@ -500,141 +540,117 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
type = 'd'; type = 'd';
break; break;
case 'c': case 'c':
visit_format_arg( arg.visit(char_converter<basic_printf_context<Char>>(arg));
detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
arg);
break; break;
} }
} }
specs.type = parse_presentation_type(type); bool upper = false;
specs.type = parse_printf_presentation_type(type, arg.type(), upper);
if (specs.type == presentation_type::none) if (specs.type == presentation_type::none)
parse_ctx.on_error("invalid type specifier"); report_error("invalid format specifier");
specs.upper = upper;
start = it; start = it;
// Format argument. // Format argument.
out = visit_format_arg( arg.visit(printf_arg_formatter<Char>(out, specs, context));
detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
} }
detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start))); write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
} }
FMT_END_DETAIL_NAMESPACE } // namespace detail
template <typename Char> using printf_context = basic_printf_context<char>;
using basic_printf_context_t = using wprintf_context = basic_printf_context<wchar_t>;
basic_printf_context<detail::buffer_appender<Char>, Char>;
using printf_context = basic_printf_context_t<char>;
using wprintf_context = basic_printf_context_t<wchar_t>;
using printf_args = basic_format_args<printf_context>; using printf_args = basic_format_args<printf_context>;
using wprintf_args = basic_format_args<wprintf_context>; using wprintf_args = basic_format_args<wprintf_context>;
/** /// Constructs an `format_arg_store` object that contains references to
\rst /// arguments and can be implicitly converted to `printf_args`.
Constructs an `~fmt::format_arg_store` object that contains references to template <typename Char = char, typename... T>
arguments and can be implicitly converted to `~fmt::printf_args`. inline auto make_printf_args(T&... args)
\endrst -> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) {
*/ return fmt::make_format_args<basic_printf_context<Char>>(args...);
template <typename... T>
inline auto make_printf_args(const T&... args)
-> format_arg_store<printf_context, T...> {
return {args...};
} }
/** template <typename Char> struct vprintf_args {
\rst using type = basic_format_args<basic_printf_context<Char>>;
Constructs an `~fmt::format_arg_store` object that contains references to };
arguments and can be implicitly converted to `~fmt::wprintf_args`.
\endrst
*/
template <typename... T>
inline auto make_wprintf_args(const T&... args)
-> format_arg_store<wprintf_context, T...> {
return {args...};
}
template <typename S, typename Char = char_t<S>> template <typename Char>
inline auto vsprintf( inline auto vsprintf(basic_string_view<Char> fmt,
const S& fmt, typename vprintf_args<Char>::type args)
basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
-> std::basic_string<Char> { -> std::basic_string<Char> {
basic_memory_buffer<Char> buffer; auto buf = basic_memory_buffer<Char>();
vprintf(buffer, detail::to_string_view(fmt), args); detail::vprintf(buf, fmt, args);
return to_string(buffer); return to_string(buf);
} }
/** /**
\rst * Formats `args` according to specifications in `fmt` and returns the result
Formats arguments and returns the result as a string. * as as string.
*
**Example**:: * **Example**:
*
std::string message = fmt::sprintf("The answer is %d", 42); * std::string message = fmt::sprintf("The answer is %d", 42);
\endrst */
*/ template <typename S, typename... T, typename Char = char_t<S>>
template <typename S, typename... T,
typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> { inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
using context = basic_printf_context_t<Char>;
return vsprintf(detail::to_string_view(fmt), return vsprintf(detail::to_string_view(fmt),
fmt::make_format_args<context>(args...)); fmt::make_format_args<basic_printf_context<Char>>(args...));
} }
template <typename S, typename Char = char_t<S>> template <typename Char>
inline auto vfprintf( inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
std::FILE* f, const S& fmt, typename vprintf_args<Char>::type args) -> int {
basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) auto buf = basic_memory_buffer<Char>();
-> int { detail::vprintf(buf, fmt, args);
basic_memory_buffer<Char> buffer; size_t size = buf.size();
vprintf(buffer, detail::to_string_view(fmt), args); return std::fwrite(buf.data(), sizeof(Char), size, f) < size
size_t size = buffer.size();
return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
? -1 ? -1
: static_cast<int>(size); : static_cast<int>(size);
} }
/** /**
\rst * Formats `args` according to specifications in `fmt` and writes the output
Prints formatted data to the file *f*. * to `f`.
*
**Example**:: * **Example**:
*
fmt::fprintf(stderr, "Don't %s!", "panic"); * fmt::fprintf(stderr, "Don't %s!", "panic");
\endrst
*/ */
template <typename S, typename... T, typename Char = char_t<S>> template <typename S, typename... T, typename Char = char_t<S>>
inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int { inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
using context = basic_printf_context_t<Char>;
return vfprintf(f, detail::to_string_view(fmt), return vfprintf(f, detail::to_string_view(fmt),
fmt::make_format_args<context>(args...)); make_printf_args<Char>(args...));
} }
template <typename S, typename Char = char_t<S>> template <typename Char>
inline auto vprintf( FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt,
const S& fmt, typename vprintf_args<Char>::type args)
basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
-> int { -> int {
return vfprintf(stdout, detail::to_string_view(fmt), args); return vfprintf(stdout, fmt, args);
} }
/** /**
\rst * Formats `args` according to specifications in `fmt` and writes the output
Prints formatted data to ``stdout``. * to `stdout`.
*
**Example**:: * **Example**:
*
fmt::printf("Elapsed time: %.2f seconds", 1.23); * fmt::printf("Elapsed time: %.2f seconds", 1.23);
\endrst
*/ */
template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)> template <typename... T>
inline auto printf(const S& fmt, const T&... args) -> int { inline auto printf(string_view fmt, const T&... args) -> int {
return vprintf( return vfprintf(stdout, fmt, make_printf_args(args...));
detail::to_string_view(fmt), }
fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...)); template <typename... T>
FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
const T&... args) -> int {
return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...));
} }
FMT_MODULE_EXPORT_END FMT_END_EXPORT
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // FMT_PRINTF_H_ #endif // FMT_PRINTF_H_

758
Tool/spdlog/include/spdlog/fmt/bundled/ranges.h
View File

@ -1,80 +1,38 @@
// Formatting library for C++ - experimental range support // Formatting library for C++ - range and tuple support
// //
// Copyright (c) 2012 - present, Victor Zverovich // Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
// All rights reserved. // All rights reserved.
// //
// For the license information refer to format.h. // 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_ #ifndef FMT_RANGES_H_
#define FMT_RANGES_H_ #define FMT_RANGES_H_
#include <initializer_list> #ifndef FMT_MODULE
#include <tuple> # include <initializer_list>
#include <type_traits> # include <iterator>
# include <string>
# include <tuple>
# include <type_traits>
# include <utility>
#endif
#include "format.h" #include "format.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
FMT_EXPORT
enum class range_format { disabled, map, set, sequence, string, debug_string };
namespace detail { namespace detail {
template <typename RangeT, typename OutputIterator>
OutputIterator copy(const RangeT& range, OutputIterator out) {
for (auto it = range.begin(), end = range.end(); it != end; ++it)
*out++ = *it;
return out;
}
template <typename OutputIterator>
OutputIterator copy(const char* str, OutputIterator out) {
while (*str) *out++ = *str++;
return out;
}
template <typename OutputIterator>
OutputIterator copy(char ch, OutputIterator out) {
*out++ = ch;
return out;
}
template <typename OutputIterator>
OutputIterator copy(wchar_t ch, OutputIterator out) {
*out++ = ch;
return out;
}
// Returns true if T has a std::string-like interface, like std::string_view.
template <typename T> class is_std_string_like {
template <typename U>
static auto check(U* p)
-> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
template <typename> static void check(...);
public:
static constexpr const bool value =
is_string<T>::value ||
std::is_convertible<T, std_string_view<char>>::value ||
!std::is_void<decltype(check<T>(nullptr))>::value;
};
template <typename Char>
struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};
template <typename T> class is_map { template <typename T> class is_map {
template <typename U> static auto check(U*) -> typename U::mapped_type; template <typename U> static auto check(U*) -> typename U::mapped_type;
template <typename> static void check(...); template <typename> static void check(...);
public: public:
#ifdef FMT_FORMAT_MAP_AS_LIST
static constexpr const bool value = false;
#else
static constexpr const bool value = static constexpr const bool value =
!std::is_void<decltype(check<T>(nullptr))>::value; !std::is_void<decltype(check<T>(nullptr))>::value;
#endif
}; };
template <typename T> class is_set { template <typename T> class is_set {
@ -82,12 +40,8 @@ template <typename T> class is_set {
template <typename> static void check(...); template <typename> static void check(...);
public: public:
#ifdef FMT_FORMAT_SET_AS_LIST
static constexpr const bool value = false;
#else
static constexpr const bool value = static constexpr const bool value =
!std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value; !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
#endif
}; };
template <typename... Ts> struct conditional_helper {}; template <typename... Ts> struct conditional_helper {};
@ -116,17 +70,17 @@ template <typename T, typename Enable = void>
struct has_member_fn_begin_end_t : std::false_type {}; struct has_member_fn_begin_end_t : std::false_type {};
template <typename T> template <typename T>
struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()), struct has_member_fn_begin_end_t<T, void_t<decltype(*std::declval<T>().begin()),
decltype(std::declval<T>().end())>> decltype(std::declval<T>().end())>>
: std::true_type {}; : std::true_type {};
// Member function overload // Member function overloads.
template <typename T> template <typename T>
auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin()); auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
template <typename T> template <typename T>
auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end()); auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
// ADL overload. Only participates in overload resolution if member functions // ADL overloads. Only participate in overload resolution if member functions
// are not found. // are not found.
template <typename T> template <typename T>
auto range_begin(T&& rng) auto range_begin(T&& rng)
@ -147,18 +101,19 @@ struct has_mutable_begin_end : std::false_type {};
template <typename T> template <typename T>
struct has_const_begin_end< struct has_const_begin_end<
T, T, void_t<decltype(*detail::range_begin(
void_t< std::declval<const remove_cvref_t<T>&>())),
decltype(detail::range_begin(std::declval<const remove_cvref_t<T>&>())), decltype(detail::range_end(
decltype(detail::range_end(std::declval<const remove_cvref_t<T>&>()))>> std::declval<const remove_cvref_t<T>&>()))>>
: std::true_type {}; : std::true_type {};
template <typename T> template <typename T>
struct has_mutable_begin_end< struct has_mutable_begin_end<
T, void_t<decltype(detail::range_begin(std::declval<T>())), T, void_t<decltype(*detail::range_begin(std::declval<T&>())),
decltype(detail::range_end(std::declval<T>())), decltype(detail::range_end(std::declval<T&>())),
enable_if_t<std::is_copy_constructible<T>::value>>> // the extra int here is because older versions of MSVC don't
: std::true_type {}; // SFINAE properly unless there are distinct types
int>> : std::true_type {};
template <typename T> template <typename T>
struct is_range_<T, void> struct is_range_<T, void>
@ -188,7 +143,7 @@ template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
template <typename T, T... N> struct integer_sequence { template <typename T, T... N> struct integer_sequence {
using value_type = T; using value_type = T;
static FMT_CONSTEXPR size_t size() { return sizeof...(N); } static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); }
}; };
template <size_t... N> using index_sequence = integer_sequence<size_t, N...>; template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
@ -211,41 +166,62 @@ class is_tuple_formattable_ {
static constexpr const bool value = false; static constexpr const bool value = false;
}; };
template <typename T, typename C> class is_tuple_formattable_<T, C, true> { template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
template <std::size_t... I> template <size_t... Is>
static std::true_type check2(index_sequence<I...>, static auto all_true(index_sequence<Is...>,
integer_sequence<bool, (I == I)...>); integer_sequence<bool, (Is >= 0)...>) -> std::true_type;
static std::false_type check2(...); static auto all_true(...) -> std::false_type;
template <std::size_t... I>
static decltype(check2( template <size_t... Is>
index_sequence<I...>{}, static auto check(index_sequence<Is...>) -> decltype(all_true(
integer_sequence< index_sequence<Is...>{},
bool, (is_formattable<typename std::tuple_element<I, T>::type, integer_sequence<bool,
C>::value)...>{})) check(index_sequence<I...>); (is_formattable<typename std::tuple_element<Is, T>::type,
C>::value)...>{}));
public: public:
static constexpr const bool value = static constexpr const bool value =
decltype(check(tuple_index_sequence<T>{}))::value; decltype(check(tuple_index_sequence<T>{}))::value;
}; };
template <class Tuple, class F, size_t... Is> template <typename Tuple, typename F, size_t... Is>
void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) noexcept { FMT_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) {
using std::get; using std::get;
// using free function get<I>(T) now. // Using a free function get<Is>(Tuple) now.
const int _[] = {0, ((void)f(get<Is>(tup)), 0)...}; const int unused[] = {0, ((void)f(get<Is>(t)), 0)...};
(void)_; // blocks warnings ignore_unused(unused);
} }
template <class T> template <typename Tuple, typename F>
FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes( FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) {
T const&) { for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(),
return {}; std::forward<Tuple>(t), std::forward<F>(f));
} }
template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) { template <typename Tuple1, typename Tuple2, typename F, size_t... Is>
const auto indexes = get_indexes(tup); void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) {
for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f)); using std::get;
const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...};
ignore_unused(unused);
} }
template <typename Tuple1, typename Tuple2, typename F>
void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {
for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(),
std::forward<Tuple1>(t1), std::forward<Tuple2>(t2),
std::forward<F>(f));
}
namespace tuple {
// Workaround a bug in MSVC 2019 (v140).
template <typename Char, typename... T>
using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>;
using std::get;
template <typename Tuple, typename Char, std::size_t... Is>
auto get_formatters(index_sequence<Is...>)
-> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>;
} // namespace tuple
#if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920 #if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
// Older MSVC doesn't get the reference type correctly for arrays. // Older MSVC doesn't get the reference type correctly for arrays.
template <typename R> struct range_reference_type_impl { template <typename R> struct range_reference_type_impl {
@ -269,45 +245,48 @@ using range_reference_type =
template <typename Range> template <typename Range>
using uncvref_type = remove_cvref_t<range_reference_type<Range>>; using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
template <typename Range> template <typename Formatter>
using uncvref_first_type = FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
remove_cvref_t<decltype(std::declval<range_reference_type<Range>>().first)>; -> decltype(f.set_debug_format(set)) {
f.set_debug_format(set);
template <typename Range>
using uncvref_second_type = remove_cvref_t<
decltype(std::declval<range_reference_type<Range>>().second)>;
template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
*out++ = ',';
*out++ = ' ';
return out;
} }
template <typename Formatter>
FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
template <typename Char, typename OutputIt> template <typename T>
auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt { struct range_format_kind_
return write_escaped_string(out, str); : std::integral_constant<range_format,
} std::is_same<uncvref_type<T>, T>::value
? range_format::disabled
: is_map<T>::value ? range_format::map
: is_set<T>::value ? range_format::set
: range_format::sequence> {};
template <typename Char, typename OutputIt, typename T, template <range_format K>
FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)> using range_format_constant = std::integral_constant<range_format, K>;
inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
auto sv = std_string_view<Char>(str);
return write_range_entry<Char>(out, basic_string_view<Char>(sv));
}
template <typename Char, typename OutputIt, typename Arg, // These are not generic lambdas for compatibility with C++11.
FMT_ENABLE_IF(std::is_same<Arg, Char>::value)> template <typename ParseContext> struct parse_empty_specs {
OutputIt write_range_entry(OutputIt out, const Arg v) { template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
return write_escaped_char(out, v); f.parse(ctx);
} detail::maybe_set_debug_format(f, true);
}
ParseContext& ctx;
};
template <typename FormatContext> struct format_tuple_element {
using char_type = typename FormatContext::char_type;
template < template <typename T>
typename Char, typename OutputIt, typename Arg, void operator()(const formatter<T, char_type>& f, const T& v) {
FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value && if (i > 0) ctx.advance_to(detail::copy<char_type>(separator, ctx.out()));
!std::is_same<Arg, Char>::value)> ctx.advance_to(f.format(v, ctx));
OutputIt write_range_entry(OutputIt out, const Arg& v) { ++i;
return write<Char>(out, v); }
}
int i;
FormatContext& ctx;
basic_string_view<char_type> separator;
};
} // namespace detail } // namespace detail
@ -321,29 +300,20 @@ template <typename T, typename C> struct is_tuple_formattable {
detail::is_tuple_formattable_<T, C>::value; detail::is_tuple_formattable_<T, C>::value;
}; };
template <typename TupleT, typename Char> template <typename Tuple, typename Char>
struct formatter<TupleT, Char, struct formatter<Tuple, Char,
enable_if_t<fmt::is_tuple_like<TupleT>::value && enable_if_t<fmt::is_tuple_like<Tuple>::value &&
fmt::is_tuple_formattable<TupleT, Char>::value>> { fmt::is_tuple_formattable<Tuple, Char>::value>> {
private: private:
decltype(detail::tuple::get_formatters<Tuple, Char>(
detail::tuple_index_sequence<Tuple>())) formatters_;
basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{}; basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
basic_string_view<Char> opening_bracket_ = basic_string_view<Char> opening_bracket_ =
detail::string_literal<Char, '('>{}; detail::string_literal<Char, '('>{};
basic_string_view<Char> closing_bracket_ = basic_string_view<Char> closing_bracket_ =
detail::string_literal<Char, ')'>{}; detail::string_literal<Char, ')'>{};
// C++11 generic lambda for format().
template <typename FormatContext> struct format_each {
template <typename T> void operator()(const T& v) {
if (i > 0) out = detail::copy_str<Char>(separator, out);
out = detail::write_range_entry<Char>(out, v);
++i;
}
int i;
typename FormatContext::iterator& out;
basic_string_view<Char> separator;
};
public: public:
FMT_CONSTEXPR formatter() {} FMT_CONSTEXPR formatter() {}
@ -359,25 +329,26 @@ struct formatter<TupleT, Char,
template <typename ParseContext> template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin(); auto it = ctx.begin();
if (it != ctx.end() && *it != '}') report_error("invalid format specifier");
detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
return it;
} }
template <typename FormatContext = format_context> template <typename FormatContext>
auto format(const TupleT& values, FormatContext& ctx) const auto format(const Tuple& value, FormatContext& ctx) const
-> decltype(ctx.out()) { -> decltype(ctx.out()) {
auto out = ctx.out(); ctx.advance_to(detail::copy<Char>(opening_bracket_, ctx.out()));
out = detail::copy_str<Char>(opening_bracket_, out); detail::for_each2(
detail::for_each(values, format_each<FormatContext>{0, out, separator_}); formatters_, value,
out = detail::copy_str<Char>(closing_bracket_, out); detail::format_tuple_element<FormatContext>{0, ctx, separator_});
return out; return detail::copy<Char>(closing_bracket_, ctx.out());
} }
}; };
template <typename T, typename Char> struct is_range { template <typename T, typename Char> struct is_range {
static constexpr const bool value = static constexpr const bool value =
detail::is_range_<T>::value && !detail::is_std_string_like<T>::value && detail::is_range_<T>::value && !detail::has_to_string_view<T>::value;
!std::is_convertible<T, std::basic_string<Char>>::value &&
!std::is_convertible<T, detail::std_string_view<Char>>::value;
}; };
namespace detail { namespace detail {
@ -398,12 +369,10 @@ template <typename Context> struct range_mapper {
}; };
template <typename Char, typename Element> template <typename Char, typename Element>
using range_formatter_type = conditional_t< using range_formatter_type =
is_formattable<Element, Char>::value, formatter<remove_cvref_t<decltype(range_mapper<buffered_context<Char>>{}
formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map( .map(std::declval<Element>()))>,
std::declval<Element>()))>, Char>;
Char>,
fallback_formatter<Element, Char>>;
template <typename R> template <typename R>
using maybe_const_range = using maybe_const_range =
@ -413,43 +382,48 @@ using maybe_const_range =
#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
template <typename R, typename Char> template <typename R, typename Char>
struct is_formattable_delayed struct is_formattable_delayed
: disjunction< : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
is_formattable<uncvref_type<maybe_const_range<R>>, Char>,
has_fallback_formatter<uncvref_type<maybe_const_range<R>>, Char>> {};
#endif #endif
} // namespace detail } // namespace detail
template <typename...> struct conjunction : std::true_type {};
template <typename P> struct conjunction<P> : P {};
template <typename P1, typename... Pn>
struct conjunction<P1, Pn...>
: conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
template <typename T, typename Char, typename Enable = void> template <typename T, typename Char, typename Enable = void>
struct range_formatter; struct range_formatter;
template <typename T, typename Char> template <typename T, typename Char>
struct range_formatter< struct range_formatter<
T, Char, T, Char,
enable_if_t<conjunction< enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
std::is_same<T, remove_cvref_t<T>>, is_formattable<T, Char>>::value>> {
disjunction<is_formattable<T, Char>,
detail::has_fallback_formatter<T, Char>>>::value>> {
private: private:
detail::range_formatter_type<Char, T> underlying_; detail::range_formatter_type<Char, T> underlying_;
bool custom_specs_ = false;
basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{}; basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
basic_string_view<Char> opening_bracket_ = basic_string_view<Char> opening_bracket_ =
detail::string_literal<Char, '['>{}; detail::string_literal<Char, '['>{};
basic_string_view<Char> closing_bracket_ = basic_string_view<Char> closing_bracket_ =
detail::string_literal<Char, ']'>{}; detail::string_literal<Char, ']'>{};
bool is_debug = false;
template <class U> template <typename Output, typename It, typename Sentinel, typename U = T,
FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, int) FMT_ENABLE_IF(std::is_same<U, Char>::value)>
-> decltype(u.set_debug_format()) { auto write_debug_string(Output& out, It it, Sentinel end) const -> Output {
u.set_debug_format(); auto buf = basic_memory_buffer<Char>();
for (; it != end; ++it) buf.push_back(*it);
auto specs = format_specs();
specs.type = presentation_type::debug;
return detail::write<Char>(
out, basic_string_view<Char>(buf.data(), buf.size()), specs);
} }
template <class U> template <typename Output, typename It, typename Sentinel, typename U = T,
FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {} FMT_ENABLE_IF(!std::is_same<U, Char>::value)>
auto write_debug_string(Output& out, It, Sentinel) const -> Output {
FMT_CONSTEXPR void maybe_set_debug_format() { return out;
maybe_set_debug_format(underlying_, 0);
} }
public: public:
@ -473,105 +447,66 @@ struct range_formatter<
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
auto it = ctx.begin(); auto it = ctx.begin();
auto end = ctx.end(); auto end = ctx.end();
if (it == end || *it == '}') { detail::maybe_set_debug_format(underlying_, true);
maybe_set_debug_format(); if (it == end) return underlying_.parse(ctx);
switch (detail::to_ascii(*it)) {
case 'n':
set_brackets({}, {});
++it;
break;
case '?':
is_debug = true;
set_brackets({}, {});
++it;
if (it == end || *it != 's') report_error("invalid format specifier");
FMT_FALLTHROUGH;
case 's':
if (!std::is_same<T, Char>::value)
report_error("invalid format specifier");
if (!is_debug) {
set_brackets(detail::string_literal<Char, '"'>{},
detail::string_literal<Char, '"'>{});
set_separator({});
detail::maybe_set_debug_format(underlying_, false);
}
++it;
return it; return it;
} }
if (*it == 'n') { if (it != end && *it != '}') {
set_brackets({}, {}); if (*it != ':') report_error("invalid format specifier");
detail::maybe_set_debug_format(underlying_, false);
++it; ++it;
} }
if (*it == '}') {
maybe_set_debug_format();
return it;
}
if (*it != ':')
FMT_THROW(format_error("no other top-level range formatters supported"));
custom_specs_ = true;
++it;
ctx.advance_to(it); ctx.advance_to(it);
return underlying_.parse(ctx); return underlying_.parse(ctx);
} }
template <typename R, class FormatContext> template <typename R, typename FormatContext>
auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) { auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
detail::range_mapper<buffer_context<Char>> mapper; auto mapper = detail::range_mapper<buffered_context<Char>>();
auto out = ctx.out(); auto out = ctx.out();
out = detail::copy_str<Char>(opening_bracket_, out);
int i = 0;
auto it = detail::range_begin(range); auto it = detail::range_begin(range);
auto end = detail::range_end(range); auto end = detail::range_end(range);
if (is_debug) return write_debug_string(out, std::move(it), end);
out = detail::copy<Char>(opening_bracket_, out);
int i = 0;
for (; it != end; ++it) { for (; it != end; ++it) {
if (i > 0) out = detail::copy_str<Char>(separator_, out); if (i > 0) out = detail::copy<Char>(separator_, out);
;
ctx.advance_to(out); ctx.advance_to(out);
out = underlying_.format(mapper.map(*it), ctx); auto&& item = *it; // Need an lvalue
out = underlying_.format(mapper.map(item), ctx);
++i; ++i;
} }
out = detail::copy_str<Char>(closing_bracket_, out); out = detail::copy<Char>(closing_bracket_, out);
return out; return out;
} }
}; };
enum class range_format { disabled, map, set, sequence, string, debug_string }; FMT_EXPORT
namespace detail {
template <typename T> struct range_format_kind_ {
static constexpr auto value = std::is_same<range_reference_type<T>, T>::value
? range_format::disabled
: is_map<T>::value ? range_format::map
: is_set<T>::value ? range_format::set
: range_format::sequence;
};
template <range_format K, typename R, typename Char, typename Enable = void>
struct range_default_formatter;
template <range_format K>
using range_format_constant = std::integral_constant<range_format, K>;
template <range_format K, typename R, typename Char>
struct range_default_formatter<
K, R, Char,
enable_if_t<(K == range_format::sequence || K == range_format::map ||
K == range_format::set)>> {
using range_type = detail::maybe_const_range<R>;
range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
FMT_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); }
FMT_CONSTEXPR void init(range_format_constant<range_format::set>) {
underlying_.set_brackets(detail::string_literal<Char, '{'>{},
detail::string_literal<Char, '}'>{});
}
FMT_CONSTEXPR void init(range_format_constant<range_format::map>) {
underlying_.set_brackets(detail::string_literal<Char, '{'>{},
detail::string_literal<Char, '}'>{});
underlying_.underlying().set_brackets({}, {});
underlying_.underlying().set_separator(
detail::string_literal<Char, ':', ' '>{});
}
FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return underlying_.parse(ctx);
}
template <typename FormatContext>
auto format(range_type& range, FormatContext& ctx) const
-> decltype(ctx.out()) {
return underlying_.format(range, ctx);
}
};
} // namespace detail
template <typename T, typename Char, typename Enable = void> template <typename T, typename Char, typename Enable = void>
struct range_format_kind struct range_format_kind
: conditional_t< : conditional_t<
@ -581,18 +516,221 @@ struct range_format_kind
template <typename R, typename Char> template <typename R, typename Char>
struct formatter< struct formatter<
R, Char, R, Char,
enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value != enable_if_t<conjunction<
range_format::disabled> bool_constant<
range_format_kind<R, Char>::value != range_format::disabled &&
range_format_kind<R, Char>::value != range_format::map &&
range_format_kind<R, Char>::value != range_format::string &&
range_format_kind<R, Char>::value != range_format::debug_string>
// Workaround a bug in MSVC 2015 and earlier. // Workaround a bug in MSVC 2015 and earlier.
#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
, ,
detail::is_formattable_delayed<R, Char> detail::is_formattable_delayed<R, Char>
#endif #endif
>::value>> >::value>> {
: detail::range_default_formatter<range_format_kind<R, Char>::value, R, private:
Char> { using range_type = detail::maybe_const_range<R>;
range_formatter<detail::uncvref_type<range_type>, Char> range_formatter_;
public:
using nonlocking = void;
FMT_CONSTEXPR formatter() {
if (detail::const_check(range_format_kind<R, Char>::value !=
range_format::set))
return;
range_formatter_.set_brackets(detail::string_literal<Char, '{'>{},
detail::string_literal<Char, '}'>{});
}
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return range_formatter_.parse(ctx);
}
template <typename FormatContext>
auto format(range_type& range, FormatContext& ctx) const
-> decltype(ctx.out()) {
return range_formatter_.format(range, ctx);
}
}; };
// A map formatter.
template <typename R, typename Char>
struct formatter<
R, Char,
enable_if_t<range_format_kind<R, Char>::value == range_format::map>> {
private:
using map_type = detail::maybe_const_range<R>;
using element_type = detail::uncvref_type<map_type>;
decltype(detail::tuple::get_formatters<element_type, Char>(
detail::tuple_index_sequence<element_type>())) formatters_;
bool no_delimiters_ = false;
public:
FMT_CONSTEXPR formatter() {}
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
auto it = ctx.begin();
auto end = ctx.end();
if (it != end) {
if (detail::to_ascii(*it) == 'n') {
no_delimiters_ = true;
++it;
}
if (it != end && *it != '}') {
if (*it != ':') report_error("invalid format specifier");
++it;
}
ctx.advance_to(it);
}
detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
return it;
}
template <typename FormatContext>
auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) {
auto out = ctx.out();
basic_string_view<Char> open = detail::string_literal<Char, '{'>{};
if (!no_delimiters_) out = detail::copy<Char>(open, out);
int i = 0;
auto mapper = detail::range_mapper<buffered_context<Char>>();
basic_string_view<Char> sep = detail::string_literal<Char, ',', ' '>{};
for (auto&& value : map) {
if (i > 0) out = detail::copy<Char>(sep, out);
ctx.advance_to(out);
detail::for_each2(formatters_, mapper.map(value),
detail::format_tuple_element<FormatContext>{
0, ctx, detail::string_literal<Char, ':', ' '>{}});
++i;
}
basic_string_view<Char> close = detail::string_literal<Char, '}'>{};
if (!no_delimiters_) out = detail::copy<Char>(close, out);
return out;
}
};
// A (debug_)string formatter.
template <typename R, typename Char>
struct formatter<
R, Char,
enable_if_t<range_format_kind<R, Char>::value == range_format::string ||
range_format_kind<R, Char>::value ==
range_format::debug_string>> {
private:
using range_type = detail::maybe_const_range<R>;
using string_type =
conditional_t<std::is_constructible<
detail::std_string_view<Char>,
decltype(detail::range_begin(std::declval<R>())),
decltype(detail::range_end(std::declval<R>()))>::value,
detail::std_string_view<Char>, std::basic_string<Char>>;
formatter<string_type, Char> underlying_;
public:
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return underlying_.parse(ctx);
}
template <typename FormatContext>
auto format(range_type& range, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
if (detail::const_check(range_format_kind<R, Char>::value ==
range_format::debug_string))
*out++ = '"';
out = underlying_.format(
string_type{detail::range_begin(range), detail::range_end(range)}, ctx);
if (detail::const_check(range_format_kind<R, Char>::value ==
range_format::debug_string))
*out++ = '"';
return out;
}
};
template <typename It, typename Sentinel, typename Char = char>
struct join_view : detail::view {
It begin;
Sentinel end;
basic_string_view<Char> sep;
join_view(It b, Sentinel e, basic_string_view<Char> s)
: begin(std::move(b)), end(e), sep(s) {}
};
template <typename It, typename Sentinel, typename Char>
struct formatter<join_view<It, Sentinel, Char>, Char> {
private:
using value_type =
#ifdef __cpp_lib_ranges
std::iter_value_t<It>;
#else
typename std::iterator_traits<It>::value_type;
#endif
formatter<remove_cvref_t<value_type>, Char> value_formatter_;
using view_ref = conditional_t<std::is_copy_constructible<It>::value,
const join_view<It, Sentinel, Char>&,
join_view<It, Sentinel, Char>&&>;
public:
using nonlocking = void;
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
return value_formatter_.parse(ctx);
}
template <typename FormatContext>
auto format(view_ref& value, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto it = std::forward<view_ref>(value).begin;
auto out = ctx.out();
if (it == value.end) return out;
out = value_formatter_.format(*it, ctx);
++it;
while (it != value.end) {
out = detail::copy<Char>(value.sep.begin(), value.sep.end(), out);
ctx.advance_to(out);
out = value_formatter_.format(*it, ctx);
++it;
}
return out;
}
};
/// Returns a view that formats the iterator range `[begin, end)` with elements
/// separated by `sep`.
template <typename It, typename Sentinel>
auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
return {std::move(begin), end, sep};
}
/**
* Returns a view that formats `range` with elements separated by `sep`.
*
* **Example**:
*
* auto v = std::vector<int>{1, 2, 3};
* fmt::print("{}", fmt::join(v, ", "));
* // Output: 1, 2, 3
*
* `fmt::join` applies passed format specifiers to the range elements:
*
* fmt::print("{:02}", fmt::join(v, ", "));
* // Output: 01, 02, 03
*/
template <typename Range>
auto join(Range&& r, string_view sep)
-> join_view<decltype(detail::range_begin(r)),
decltype(detail::range_end(r))> {
return {detail::range_begin(r), detail::range_end(r), sep};
}
template <typename Char, typename... T> struct tuple_join_view : detail::view { template <typename Char, typename... T> struct tuple_join_view : detail::view {
const std::tuple<T...>& tuple; const std::tuple<T...>& tuple;
basic_string_view<Char> sep; basic_string_view<Char> sep;
@ -601,9 +739,6 @@ template <typename Char, typename... T> struct tuple_join_view : detail::view {
: tuple(t), sep{s} {} : tuple(t), sep{s} {}
}; };
template <typename Char, typename... T>
using tuple_arg_join = tuple_join_view<Char, T...>;
// Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers // Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
// support in tuple_join. It is disabled by default because of issues with // support in tuple_join. It is disabled by default because of issues with
// the dynamic width and precision. // the dynamic width and precision.
@ -645,7 +780,7 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
if (N > 1) { if (N > 1) {
auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>()); auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
if (end != end1) if (end != end1)
FMT_THROW(format_error("incompatible format specs for tuple elements")); report_error("incompatible format specs for tuple elements");
} }
#endif #endif
return end; return end;
@ -664,27 +799,61 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
typename FormatContext::iterator { typename FormatContext::iterator {
auto out = std::get<sizeof...(T) - N>(formatters_) auto out = std::get<sizeof...(T) - N>(formatters_)
.format(std::get<sizeof...(T) - N>(value.tuple), ctx); .format(std::get<sizeof...(T) - N>(value.tuple), ctx);
if (N > 1) { if (N <= 1) return out;
out = std::copy(value.sep.begin(), value.sep.end(), out); out = detail::copy<Char>(value.sep, out);
ctx.advance_to(out); ctx.advance_to(out);
return do_format(value, ctx, std::integral_constant<size_t, N - 1>()); return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
}
return out;
} }
}; };
FMT_MODULE_EXPORT_BEGIN namespace detail {
// Check if T has an interface like a container adaptor (e.g. std::stack,
// std::queue, std::priority_queue).
template <typename T> class is_container_adaptor_like {
template <typename U> static auto check(U* p) -> typename U::container_type;
template <typename> static void check(...);
public:
static constexpr const bool value =
!std::is_void<decltype(check<T>(nullptr))>::value;
};
template <typename Container> struct all {
const Container& c;
auto begin() const -> typename Container::const_iterator { return c.begin(); }
auto end() const -> typename Container::const_iterator { return c.end(); }
};
} // namespace detail
template <typename T, typename Char>
struct formatter<
T, Char,
enable_if_t<conjunction<detail::is_container_adaptor_like<T>,
bool_constant<range_format_kind<T, Char>::value ==
range_format::disabled>>::value>>
: formatter<detail::all<typename T::container_type>, Char> {
using all = detail::all<typename T::container_type>;
template <typename FormatContext>
auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) {
struct getter : T {
static auto get(const T& t) -> all {
return {t.*(&getter::c)}; // Access c through the derived class.
}
};
return formatter<all>::format(getter::get(t), ctx);
}
};
FMT_BEGIN_EXPORT
/** /**
\rst * Returns an object that formats `std::tuple` with elements separated by `sep`.
Returns an object that formats `tuple` with elements separated by `sep`. *
* **Example**:
**Example**:: *
* auto t = std::tuple<int, char>{1, 'a'};
std::tuple<int, char> t = {1, 'a'}; * fmt::print("{}", fmt::join(t, ", "));
fmt::print("{}", fmt::join(t, ", ")); * // Output: 1, a
// Output: "1, a"
\endrst
*/ */
template <typename... T> template <typename... T>
FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep) FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
@ -692,23 +861,14 @@ FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
return {tuple, sep}; return {tuple, sep};
} }
template <typename... T>
FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
basic_string_view<wchar_t> sep)
-> tuple_join_view<wchar_t, T...> {
return {tuple, sep};
}
/** /**
\rst * Returns an object that formats `std::initializer_list` with elements
Returns an object that formats `initializer_list` with elements separated by * separated by `sep`.
`sep`. *
* **Example**:
**Example**:: *
* fmt::print("{}", fmt::join({1, 2, 3}, ", "));
fmt::print("{}", fmt::join({1, 2, 3}, ", ")); * // Output: "1, 2, 3"
// Output: "1, 2, 3"
\endrst
*/ */
template <typename T> template <typename T>
auto join(std::initializer_list<T> list, string_view sep) auto join(std::initializer_list<T> list, string_view sep)
@ -716,7 +876,7 @@ auto join(std::initializer_list<T> list, string_view sep)
return join(std::begin(list), std::end(list), sep); return join(std::begin(list), std::end(list), sep);
} }
FMT_MODULE_EXPORT_END FMT_END_EXPORT
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // FMT_RANGES_H_ #endif // FMT_RANGES_H_

670
Tool/spdlog/include/spdlog/fmt/bundled/std.h
View File

@ -8,127 +8,350 @@
#ifndef FMT_STD_H_ #ifndef FMT_STD_H_
#define FMT_STD_H_ #define FMT_STD_H_
#include <thread> #include "format.h"
#include <type_traits>
#include <utility>
#include "ostream.h" #include "ostream.h"
#ifndef FMT_MODULE
# include <atomic>
# include <bitset>
# include <complex>
# include <cstdlib>
# include <exception>
# include <memory>
# include <thread>
# include <type_traits>
# include <typeinfo>
# include <utility>
# include <vector>
// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.
# if FMT_CPLUSPLUS >= 201703L
# if FMT_HAS_INCLUDE(<filesystem>)
# include <filesystem>
# endif
# if FMT_HAS_INCLUDE(<variant>)
# include <variant>
# endif
# if FMT_HAS_INCLUDE(<optional>)
# include <optional>
# endif
# endif
// Use > instead of >= in the version check because <source_location> may be
// available after C++17 but before C++20 is marked as implemented.
# if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
# include <source_location>
# endif
# if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>)
# include <expected>
# endif
#endif // FMT_MODULE
#if FMT_HAS_INCLUDE(<version>) #if FMT_HAS_INCLUDE(<version>)
# include <version> # include <version>
#endif #endif
// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
#if FMT_CPLUSPLUS >= 201703L // GCC 4 does not support FMT_HAS_INCLUDE.
# if FMT_HAS_INCLUDE(<filesystem>) #if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
# include <filesystem> # include <cxxabi.h>
# endif // Android NDK with gabi++ library on some architectures does not implement
# if FMT_HAS_INCLUDE(<variant>) // abi::__cxa_demangle().
# include <variant> # ifndef __GABIXX_CXXABI_H__
# define FMT_HAS_ABI_CXA_DEMANGLE
# endif # endif
#endif #endif
#ifdef __cpp_lib_filesystem // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
#ifndef FMT_CPP_LIB_FILESYSTEM
# ifdef __cpp_lib_filesystem
# define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
# else
# define FMT_CPP_LIB_FILESYSTEM 0
# endif
#endif
#ifndef FMT_CPP_LIB_VARIANT
# ifdef __cpp_lib_variant
# define FMT_CPP_LIB_VARIANT __cpp_lib_variant
# else
# define FMT_CPP_LIB_VARIANT 0
# endif
#endif
#if FMT_CPP_LIB_FILESYSTEM
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
namespace detail { namespace detail {
template <typename Char> template <typename Char, typename PathChar>
auto get_path_string(const std::filesystem::path& p,
const std::basic_string<PathChar>& native) {
if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
else
return p.string<Char>();
}
template <typename Char, typename PathChar>
void write_escaped_path(basic_memory_buffer<Char>& quoted, void write_escaped_path(basic_memory_buffer<Char>& quoted,
const std::filesystem::path& p) { const std::filesystem::path& p,
write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>()); const std::basic_string<PathChar>& native) {
} if constexpr (std::is_same_v<Char, char> &&
# ifdef _WIN32 std::is_same_v<PathChar, wchar_t>) {
template <> auto buf = basic_memory_buffer<wchar_t>();
inline void write_escaped_path<char>(basic_memory_buffer<char>& quoted, write_escaped_string<wchar_t>(std::back_inserter(buf), native);
const std::filesystem::path& p) { bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
auto s = p.u8string(); FMT_ASSERT(valid, "invalid utf16");
write_escaped_string<char>( } else if constexpr (std::is_same_v<Char, PathChar>) {
std::back_inserter(quoted), write_escaped_string<std::filesystem::path::value_type>(
string_view(reinterpret_cast<const char*>(s.c_str()), s.size())); std::back_inserter(quoted), native);
} } else {
# endif write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
template <> }
inline void write_escaped_path<std::filesystem::path::value_type>(
basic_memory_buffer<std::filesystem::path::value_type>& quoted,
const std::filesystem::path& p) {
write_escaped_string<std::filesystem::path::value_type>(
std::back_inserter(quoted), p.native());
} }
} // namespace detail } // namespace detail
template <typename Char> FMT_EXPORT
struct formatter<std::filesystem::path, Char> template <typename Char> struct formatter<std::filesystem::path, Char> {
: formatter<basic_string_view<Char>> { private:
format_specs specs_;
detail::arg_ref<Char> width_ref_;
bool debug_ = false;
char path_type_ = 0;
public:
FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
auto it = ctx.begin(), end = ctx.end();
if (it == end) return it;
it = detail::parse_align(it, end, specs_);
if (it == end) return it;
it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
if (it != end && *it == '?') {
debug_ = true;
++it;
}
if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++);
return it;
}
template <typename FormatContext> template <typename FormatContext>
auto format(const std::filesystem::path& p, FormatContext& ctx) const -> auto format(const std::filesystem::path& p, FormatContext& ctx) const {
typename FormatContext::iterator { auto specs = specs_;
basic_memory_buffer<Char> quoted; auto path_string =
detail::write_escaped_path(quoted, p); !path_type_ ? p.native()
return formatter<basic_string_view<Char>>::format( : p.generic_string<std::filesystem::path::value_type>();
basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
ctx);
if (!debug_) {
auto s = detail::get_path_string<Char>(p, path_string);
return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
}
auto quoted = basic_memory_buffer<Char>();
detail::write_escaped_path(quoted, p, path_string);
return detail::write(ctx.out(),
basic_string_view<Char>(quoted.data(), quoted.size()),
specs);
} }
}; };
class path : public std::filesystem::path {
public:
auto display_string() const -> std::string {
const std::filesystem::path& base = *this;
return fmt::format(FMT_STRING("{}"), base);
}
auto system_string() const -> std::string { return string(); }
auto generic_display_string() const -> std::string {
const std::filesystem::path& base = *this;
return fmt::format(FMT_STRING("{:g}"), base);
}
auto generic_system_string() const -> std::string { return generic_string(); }
};
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif #endif // FMT_CPP_LIB_FILESYSTEM
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
FMT_EXPORT
template <std::size_t N, typename Char>
struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
private:
// Functor because C++11 doesn't support generic lambdas.
struct writer {
const std::bitset<N>& bs;
template <typename OutputIt>
FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
for (auto pos = N; pos > 0; --pos) {
out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
}
return out;
}
};
public:
template <typename FormatContext>
auto format(const std::bitset<N>& bs, FormatContext& ctx) const
-> decltype(ctx.out()) {
return write_padded(ctx, writer{bs});
}
};
FMT_EXPORT
template <typename Char> template <typename Char>
struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {}; struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
FMT_END_NAMESPACE FMT_END_NAMESPACE
#ifdef __cpp_lib_variant #ifdef __cpp_lib_optional
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
template <typename Char> struct formatter<std::monostate, Char> { FMT_EXPORT
template <typename T, typename Char>
struct formatter<std::optional<T>, Char,
std::enable_if_t<is_formattable<T, Char>::value>> {
private:
formatter<T, Char> underlying_;
static constexpr basic_string_view<Char> optional =
detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
'('>{};
static constexpr basic_string_view<Char> none =
detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
template <class U>
FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
-> decltype(u.set_debug_format(set)) {
u.set_debug_format(set);
}
template <class U>
FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
public:
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
maybe_set_debug_format(underlying_, true);
return underlying_.parse(ctx);
}
template <typename FormatContext>
auto format(const std::optional<T>& opt, FormatContext& ctx) const
-> decltype(ctx.out()) {
if (!opt) return detail::write<Char>(ctx.out(), none);
auto out = ctx.out();
out = detail::write<Char>(out, optional);
ctx.advance_to(out);
out = underlying_.format(*opt, ctx);
return detail::write(out, ')');
}
};
FMT_END_NAMESPACE
#endif // __cpp_lib_optional
#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT
FMT_BEGIN_NAMESPACE
namespace detail {
template <typename Char, typename OutputIt, typename T>
auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt {
if constexpr (has_to_string_view<T>::value)
return write_escaped_string<Char>(out, detail::to_string_view(v));
if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v);
return write<Char>(out, v);
}
} // namespace detail
FMT_END_NAMESPACE
#endif
#ifdef __cpp_lib_expected
FMT_BEGIN_NAMESPACE
FMT_EXPORT
template <typename T, typename E, typename Char>
struct formatter<std::expected<T, E>, Char,
std::enable_if_t<is_formattable<T, Char>::value &&
is_formattable<E, Char>::value>> {
template <typename ParseContext> template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin(); return ctx.begin();
} }
template <typename FormatContext> template <typename FormatContext>
auto format(const std::monostate&, FormatContext& ctx) const auto format(const std::expected<T, E>& value, FormatContext& ctx) const
-> decltype(ctx.out()) { -> decltype(ctx.out()) {
auto out = ctx.out(); auto out = ctx.out();
out = detail::write<Char>(out, "monostate");
if (value.has_value()) {
out = detail::write<Char>(out, "expected(");
out = detail::write_escaped_alternative<Char>(out, *value);
} else {
out = detail::write<Char>(out, "unexpected(");
out = detail::write_escaped_alternative<Char>(out, value.error());
}
*out++ = ')';
return out; return out;
} }
}; };
FMT_END_NAMESPACE
#endif // __cpp_lib_expected
#ifdef __cpp_lib_source_location
FMT_BEGIN_NAMESPACE
FMT_EXPORT
template <> struct formatter<std::source_location> {
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
return ctx.begin();
}
template <typename FormatContext>
auto format(const std::source_location& loc, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
out = detail::write(out, loc.file_name());
out = detail::write(out, ':');
out = detail::write<char>(out, loc.line());
out = detail::write(out, ':');
out = detail::write<char>(out, loc.column());
out = detail::write(out, ": ");
out = detail::write(out, loc.function_name());
return out;
}
};
FMT_END_NAMESPACE
#endif
#if FMT_CPP_LIB_VARIANT
FMT_BEGIN_NAMESPACE
namespace detail { namespace detail {
template <typename T> template <typename T>
using variant_index_sequence = using variant_index_sequence =
std::make_index_sequence<std::variant_size<T>::value>; std::make_index_sequence<std::variant_size<T>::value>;
// variant_size and variant_alternative check. template <typename> struct is_variant_like_ : std::false_type {};
template <typename T, typename U = void> template <typename... Types>
struct is_variant_like_ : std::false_type {}; struct is_variant_like_<std::variant<Types...>> : std::true_type {};
template <typename T>
struct is_variant_like_<T, std::void_t<decltype(std::variant_size<T>::value)>>
: std::true_type {};
// formattable element check // formattable element check.
template <typename T, typename C> class is_variant_formattable_ { template <typename T, typename C> class is_variant_formattable_ {
template <std::size_t... I> template <std::size_t... Is>
static std::conjunction< static std::conjunction<
is_formattable<std::variant_alternative_t<I, T>, C>...> is_formattable<std::variant_alternative_t<Is, T>, C>...>
check(std::index_sequence<I...>); check(std::index_sequence<Is...>);
public: public:
static constexpr const bool value = static constexpr const bool value =
decltype(check(variant_index_sequence<T>{}))::value; decltype(check(variant_index_sequence<T>{}))::value;
}; };
template <typename Char, typename OutputIt, typename T>
auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
if constexpr (is_string<T>::value)
return write_escaped_string<Char>(out, detail::to_string_view(v));
else if constexpr (std::is_same_v<T, Char>)
return write_escaped_char(out, v);
else
return write<Char>(out, v);
}
} // namespace detail } // namespace detail
template <typename T> struct is_variant_like { template <typename T> struct is_variant_like {
@ -140,6 +363,21 @@ template <typename T, typename C> struct is_variant_formattable {
detail::is_variant_formattable_<T, C>::value; detail::is_variant_formattable_<T, C>::value;
}; };
FMT_EXPORT
template <typename Char> struct formatter<std::monostate, Char> {
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext>
auto format(const std::monostate&, FormatContext& ctx) const
-> decltype(ctx.out()) {
return detail::write<Char>(ctx.out(), "monostate");
}
};
FMT_EXPORT
template <typename Variant, typename Char> template <typename Variant, typename Char>
struct formatter< struct formatter<
Variant, Char, Variant, Char,
@ -156,16 +394,306 @@ struct formatter<
auto out = ctx.out(); auto out = ctx.out();
out = detail::write<Char>(out, "variant("); out = detail::write<Char>(out, "variant(");
std::visit( FMT_TRY {
[&](const auto& v) { std::visit(
out = detail::write_variant_alternative<Char>(out, v); [&](const auto& v) {
}, out = detail::write_escaped_alternative<Char>(out, v);
value); },
value);
}
FMT_CATCH(const std::bad_variant_access&) {
detail::write<Char>(out, "valueless by exception");
}
*out++ = ')'; *out++ = ')';
return out; return out;
} }
}; };
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // FMT_CPP_LIB_VARIANT
FMT_BEGIN_NAMESPACE
FMT_EXPORT
template <typename Char> struct formatter<std::error_code, Char> {
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext>
FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
out = detail::write_bytes<Char>(out, ec.category().name(), format_specs());
out = detail::write<Char>(out, Char(':'));
out = detail::write<Char>(out, ec.value());
return out;
}
};
#if FMT_USE_RTTI
namespace detail {
template <typename Char, typename OutputIt>
auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
# ifdef FMT_HAS_ABI_CXA_DEMANGLE
int status = 0;
std::size_t size = 0;
std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
string_view demangled_name_view;
if (demangled_name_ptr) {
demangled_name_view = demangled_name_ptr.get();
// Normalization of stdlib inline namespace names.
// libc++ inline namespaces.
// std::__1::* -> std::*
// std::__1::__fs::* -> std::*
// libstdc++ inline namespaces.
// std::__cxx11::* -> std::*
// std::filesystem::__cxx11::* -> std::filesystem::*
if (demangled_name_view.starts_with("std::")) {
char* begin = demangled_name_ptr.get();
char* to = begin + 5; // std::
for (char *from = to, *end = begin + demangled_name_view.size();
from < end;) {
// This is safe, because demangled_name is NUL-terminated.
if (from[0] == '_' && from[1] == '_') {
char* next = from + 1;
while (next < end && *next != ':') next++;
if (next[0] == ':' && next[1] == ':') {
from = next + 2;
continue;
}
}
*to++ = *from++;
}
demangled_name_view = {begin, detail::to_unsigned(to - begin)};
}
} else {
demangled_name_view = string_view(ti.name());
}
return detail::write_bytes<Char>(out, demangled_name_view);
# elif FMT_MSC_VERSION
const string_view demangled_name(ti.name());
for (std::size_t i = 0; i < demangled_name.size(); ++i) {
auto sub = demangled_name;
sub.remove_prefix(i);
if (sub.starts_with("enum ")) {
i += 4;
continue;
}
if (sub.starts_with("class ") || sub.starts_with("union ")) {
i += 5;
continue;
}
if (sub.starts_with("struct ")) {
i += 6;
continue;
}
if (*sub.begin() != ' ') *out++ = *sub.begin();
}
return out;
# else
return detail::write_bytes<Char>(out, string_view(ti.name()));
# endif
}
} // namespace detail
FMT_EXPORT
template <typename Char>
struct formatter<std::type_info, Char // DEPRECATED! Mixing code unit types.
> {
public:
FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename Context>
auto format(const std::type_info& ti, Context& ctx) const
-> decltype(ctx.out()) {
return detail::write_demangled_name<Char>(ctx.out(), ti);
}
};
#endif #endif
FMT_EXPORT
template <typename T, typename Char>
struct formatter<
T, Char, // DEPRECATED! Mixing code unit types.
typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
private:
bool with_typename_ = false;
public:
FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-> decltype(ctx.begin()) {
auto it = ctx.begin();
auto end = ctx.end();
if (it == end || *it == '}') return it;
if (*it == 't') {
++it;
with_typename_ = FMT_USE_RTTI != 0;
}
return it;
}
template <typename Context>
auto format(const std::exception& ex, Context& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
#if FMT_USE_RTTI
if (with_typename_) {
out = detail::write_demangled_name<Char>(out, typeid(ex));
*out++ = ':';
*out++ = ' ';
}
#endif
return detail::write_bytes<Char>(out, string_view(ex.what()));
}
};
namespace detail {
template <typename T, typename Enable = void>
struct has_flip : std::false_type {};
template <typename T>
struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
: std::true_type {};
template <typename T> struct is_bit_reference_like {
static constexpr const bool value =
std::is_convertible<T, bool>::value &&
std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
};
#ifdef _LIBCPP_VERSION
// Workaround for libc++ incompatibility with C++ standard.
// According to the Standard, `bitset::operator[] const` returns bool.
template <typename C>
struct is_bit_reference_like<std::__bit_const_reference<C>> {
static constexpr const bool value = true;
};
#endif
} // namespace detail
// We can't use std::vector<bool, Allocator>::reference and
// std::bitset<N>::reference because the compiler can't deduce Allocator and N
// in partial specialization.
FMT_EXPORT
template <typename BitRef, typename Char>
struct formatter<BitRef, Char,
enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
: formatter<bool, Char> {
template <typename FormatContext>
FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
-> decltype(ctx.out()) {
return formatter<bool, Char>::format(v, ctx);
}
};
template <typename T, typename Deleter>
auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
return p.get();
}
template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
return p.get();
}
FMT_EXPORT
template <typename T, typename Char>
struct formatter<std::atomic<T>, Char,
enable_if_t<is_formattable<T, Char>::value>>
: formatter<T, Char> {
template <typename FormatContext>
auto format(const std::atomic<T>& v, FormatContext& ctx) const
-> decltype(ctx.out()) {
return formatter<T, Char>::format(v.load(), ctx);
}
};
#ifdef __cpp_lib_atomic_flag_test
FMT_EXPORT
template <typename Char>
struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
template <typename FormatContext>
auto format(const std::atomic_flag& v, FormatContext& ctx) const
-> decltype(ctx.out()) {
return formatter<bool, Char>::format(v.test(), ctx);
}
};
#endif // __cpp_lib_atomic_flag_test
FMT_EXPORT
template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
private:
detail::dynamic_format_specs<Char> specs_;
template <typename FormatContext, typename OutputIt>
FMT_CONSTEXPR auto do_format(const std::complex<T>& c,
detail::dynamic_format_specs<Char>& specs,
FormatContext& ctx, OutputIt out) const
-> OutputIt {
if (c.real() != 0) {
*out++ = Char('(');
out = detail::write<Char>(out, c.real(), specs, ctx.locale());
specs.sign = sign::plus;
out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
if (!detail::isfinite(c.imag())) *out++ = Char(' ');
*out++ = Char('i');
*out++ = Char(')');
return out;
}
out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
if (!detail::isfinite(c.imag())) *out++ = Char(' ');
*out++ = Char('i');
return out;
}
public:
FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-> decltype(ctx.begin()) {
if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
detail::type_constant<T, Char>::value);
}
template <typename FormatContext>
auto format(const std::complex<T>& c, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto specs = specs_;
if (specs.width_ref.kind != detail::arg_id_kind::none ||
specs.precision_ref.kind != detail::arg_id_kind::none) {
detail::handle_dynamic_spec<detail::width_checker>(specs.width,
specs.width_ref, ctx);
detail::handle_dynamic_spec<detail::precision_checker>(
specs.precision, specs.precision_ref, ctx);
}
if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());
auto buf = basic_memory_buffer<Char>();
auto outer_specs = format_specs();
outer_specs.width = specs.width;
outer_specs.fill = specs.fill;
outer_specs.align = specs.align;
specs.width = 0;
specs.fill = {};
specs.align = align::none;
do_format(c, specs, ctx, basic_appender<Char>(buf));
return detail::write<Char>(ctx.out(),
basic_string_view<Char>(buf.data(), buf.size()),
outer_specs);
}
};
FMT_END_NAMESPACE
#endif // FMT_STD_H_ #endif // FMT_STD_H_

251
Tool/spdlog/include/spdlog/fmt/bundled/xchar.h
View File

@ -8,21 +8,58 @@
#ifndef FMT_XCHAR_H_ #ifndef FMT_XCHAR_H_
#define FMT_XCHAR_H_ #define FMT_XCHAR_H_
#include <cwchar> #include "color.h"
#include "format.h" #include "format.h"
#include "ranges.h"
#ifndef FMT_MODULE
# include <cwchar>
# if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
# include <locale>
# endif
#endif
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
namespace detail { namespace detail {
template <typename T> template <typename T>
using is_exotic_char = bool_constant<!std::is_same<T, char>::value>; using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
}
FMT_MODULE_EXPORT_BEGIN template <typename S, typename = void> struct format_string_char {};
template <typename S>
struct format_string_char<
S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> {
using type = char_t<S>;
};
template <typename S>
struct format_string_char<S, enable_if_t<is_compile_string<S>::value>> {
using type = typename S::char_type;
};
template <typename S>
using format_string_char_t = typename format_string_char<S>::type;
inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
const format_specs& specs, locale_ref loc) -> bool {
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
auto& numpunct =
std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
auto separator = std::wstring();
auto grouping = numpunct.grouping();
if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
#endif
return false;
}
} // namespace detail
FMT_BEGIN_EXPORT
using wstring_view = basic_string_view<wchar_t>; using wstring_view = basic_string_view<wchar_t>;
using wformat_parse_context = basic_format_parse_context<wchar_t>; using wformat_parse_context = basic_format_parse_context<wchar_t>;
using wformat_context = buffer_context<wchar_t>; using wformat_context = buffered_context<wchar_t>;
using wformat_args = basic_format_args<wformat_context>; using wformat_args = basic_format_args<wformat_context>;
using wmemory_buffer = basic_memory_buffer<wchar_t>; using wmemory_buffer = basic_memory_buffer<wchar_t>;
@ -33,23 +70,30 @@ inline auto runtime(wstring_view s) -> wstring_view { return s; }
#else #else
template <typename... Args> template <typename... Args>
using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>; using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
inline auto runtime(wstring_view s) -> basic_runtime<wchar_t> { return {{s}}; } inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
return {{s}};
}
#endif #endif
template <> struct is_char<wchar_t> : std::true_type {}; template <> struct is_char<wchar_t> : std::true_type {};
template <> struct is_char<detail::char8_type> : std::true_type {};
template <> struct is_char<char16_t> : std::true_type {}; template <> struct is_char<char16_t> : std::true_type {};
template <> struct is_char<char32_t> : std::true_type {}; template <> struct is_char<char32_t> : std::true_type {};
template <typename... Args> #ifdef __cpp_char8_t
constexpr format_arg_store<wformat_context, Args...> make_wformat_args( template <>
const Args&... args) { struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled()> {};
return {args...}; #endif
template <typename... T>
constexpr auto make_wformat_args(T&... args)
-> decltype(fmt::make_format_args<wformat_context>(args...)) {
return fmt::make_format_args<wformat_context>(args...);
} }
inline namespace literals { inline namespace literals {
#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS #if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) { constexpr auto operator""_a(const wchar_t* s, size_t)
-> detail::udl_arg<wchar_t> {
return {s}; return {s};
} }
#endif #endif
@ -74,13 +118,19 @@ auto join(std::initializer_list<T> list, wstring_view sep)
return join(std::begin(list), std::end(list), sep); return join(std::begin(list), std::end(list), sep);
} }
template <typename... T>
auto join(const std::tuple<T...>& tuple, basic_string_view<wchar_t> sep)
-> tuple_join_view<wchar_t, T...> {
return {tuple, sep};
}
template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)> template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
auto vformat(basic_string_view<Char> format_str, auto vformat(basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) typename detail::vformat_args<Char>::type args)
-> std::basic_string<Char> { -> std::basic_string<Char> {
basic_memory_buffer<Char> buffer; auto buf = basic_memory_buffer<Char>();
detail::vformat_to(buffer, format_str, args); detail::vformat_to(buf, format_str, args);
return to_string(buffer); return to_string(buf);
} }
template <typename... T> template <typename... T>
@ -88,119 +138,130 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
} }
// Pass char_t as a default template parameter instead of using template <typename OutputIt, typename... T>
// std::basic_string<char_t<S>> to reduce the symbol size. auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args)
template <typename S, typename... Args, typename Char = char_t<S>, -> OutputIt {
FMT_ENABLE_IF(!std::is_same<Char, char>::value && return vformat_to(out, fmt::wstring_view(fmt),
!std::is_same<Char, wchar_t>::value)> fmt::make_wformat_args(args...));
auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
return vformat(detail::to_string_view(format_str),
fmt::make_format_args<buffer_context<Char>>(args...));
} }
template <typename Locale, typename S, typename Char = char_t<S>, // Pass char_t as a default template parameter instead of using
// std::basic_string<char_t<S>> to reduce the symbol size.
template <typename S, typename... T,
typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
!std::is_same<Char, wchar_t>::value)>
auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
return vformat(detail::to_string_view(format_str),
fmt::make_format_args<buffered_context<Char>>(args...));
}
template <typename Locale, typename S,
typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_locale<Locale>::value&& FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
detail::is_exotic_char<Char>::value)> detail::is_exotic_char<Char>::value)>
inline auto vformat( inline auto vformat(const Locale& loc, const S& format_str,
const Locale& loc, const S& format_str, typename detail::vformat_args<Char>::type args)
basic_format_args<buffer_context<type_identity_t<Char>>> args)
-> std::basic_string<Char> { -> std::basic_string<Char> {
return detail::vformat(loc, detail::to_string_view(format_str), args); return detail::vformat(loc, detail::to_string_view(format_str), args);
} }
template <typename Locale, typename S, typename... Args, template <typename Locale, typename S, typename... T,
typename Char = char_t<S>, typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_locale<Locale>::value&& FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
detail::is_exotic_char<Char>::value)> detail::is_exotic_char<Char>::value)>
inline auto format(const Locale& loc, const S& format_str, Args&&... args) inline auto format(const Locale& loc, const S& format_str, T&&... args)
-> std::basic_string<Char> { -> std::basic_string<Char> {
return detail::vformat(loc, detail::to_string_view(format_str), return detail::vformat(
fmt::make_format_args<buffer_context<Char>>(args...)); loc, detail::to_string_view(format_str),
fmt::make_format_args<buffered_context<Char>>(args...));
} }
template <typename OutputIt, typename S, typename Char = char_t<S>, template <typename OutputIt, typename S,
typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
detail::is_exotic_char<Char>::value)> detail::is_exotic_char<Char>::value)>
auto vformat_to(OutputIt out, const S& format_str, auto vformat_to(OutputIt out, const S& format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) typename detail::vformat_args<Char>::type args) -> OutputIt {
-> OutputIt {
auto&& buf = detail::get_buffer<Char>(out); auto&& buf = detail::get_buffer<Char>(out);
detail::vformat_to(buf, detail::to_string_view(format_str), args); detail::vformat_to(buf, detail::to_string_view(format_str), args);
return detail::get_iterator(buf); return detail::get_iterator(buf, out);
} }
template <typename OutputIt, typename S, typename... Args, template <typename OutputIt, typename S, typename... T,
typename Char = char_t<S>, typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&
detail::is_exotic_char<Char>::value)> !std::is_same<Char, char>::value &&
inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt { !std::is_same<Char, wchar_t>::value)>
inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
return vformat_to(out, detail::to_string_view(fmt), return vformat_to(out, detail::to_string_view(fmt),
fmt::make_format_args<buffer_context<Char>>(args...)); fmt::make_format_args<buffered_context<Char>>(args...));
} }
template <typename Locale, typename S, typename OutputIt, typename... Args, template <typename Locale, typename S, typename OutputIt, typename... Args,
typename Char = char_t<S>, typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
detail::is_locale<Locale>::value&& detail::is_locale<Locale>::value&&
detail::is_exotic_char<Char>::value)> detail::is_exotic_char<Char>::value)>
inline auto vformat_to( inline auto vformat_to(OutputIt out, const Locale& loc, const S& format_str,
OutputIt out, const Locale& loc, const S& format_str, typename detail::vformat_args<Char>::type args)
basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt { -> OutputIt {
auto&& buf = detail::get_buffer<Char>(out); auto&& buf = detail::get_buffer<Char>(out);
vformat_to(buf, detail::to_string_view(format_str), args, vformat_to(buf, detail::to_string_view(format_str), args,
detail::locale_ref(loc)); detail::locale_ref(loc));
return detail::get_iterator(buf); return detail::get_iterator(buf, out);
} }
template < template <typename OutputIt, typename Locale, typename S, typename... T,
typename OutputIt, typename Locale, typename S, typename... Args, typename Char = detail::format_string_char_t<S>,
typename Char = char_t<S>, bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
bool enable = detail::is_output_iterator<OutputIt, Char>::value&& detail::is_locale<Locale>::value &&
detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value> detail::is_exotic_char<Char>::value>
inline auto format_to(OutputIt out, const Locale& loc, const S& format_str, inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
Args&&... args) -> T&&... args) ->
typename std::enable_if<enable, OutputIt>::type { typename std::enable_if<enable, OutputIt>::type {
return vformat_to(out, loc, to_string_view(format_str), return vformat_to(out, loc, detail::to_string_view(format_str),
fmt::make_format_args<buffer_context<Char>>(args...)); fmt::make_format_args<buffered_context<Char>>(args...));
} }
template <typename OutputIt, typename Char, typename... Args, template <typename OutputIt, typename Char, typename... Args,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
detail::is_exotic_char<Char>::value)> detail::is_exotic_char<Char>::value)>
inline auto vformat_to_n( inline auto vformat_to_n(OutputIt out, size_t n,
OutputIt out, size_t n, basic_string_view<Char> format_str, basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) typename detail::vformat_args<Char>::type args)
-> format_to_n_result<OutputIt> { -> format_to_n_result<OutputIt> {
detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out, using traits = detail::fixed_buffer_traits;
n); auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
detail::vformat_to(buf, format_str, args); detail::vformat_to(buf, format_str, args);
return {buf.out(), buf.count()}; return {buf.out(), buf.count()};
} }
template <typename OutputIt, typename S, typename... Args, template <typename OutputIt, typename S, typename... T,
typename Char = char_t<S>, typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
detail::is_exotic_char<Char>::value)> detail::is_exotic_char<Char>::value)>
inline auto format_to_n(OutputIt out, size_t n, const S& fmt, inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
const Args&... args) -> format_to_n_result<OutputIt> { -> format_to_n_result<OutputIt> {
return vformat_to_n(out, n, detail::to_string_view(fmt), return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
fmt::make_format_args<buffer_context<Char>>(args...)); fmt::make_format_args<buffered_context<Char>>(args...));
} }
template <typename S, typename... Args, typename Char = char_t<S>, template <typename S, typename... T,
typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)> FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
inline auto formatted_size(const S& fmt, Args&&... args) -> size_t { inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
detail::counting_buffer<Char> buf; auto buf = detail::counting_buffer<Char>();
detail::vformat_to(buf, detail::to_string_view(fmt), detail::vformat_to(buf, detail::to_string_view(fmt),
fmt::make_format_args<buffer_context<Char>>(args...)); fmt::make_format_args<buffered_context<Char>>(args...));
return buf.count(); return buf.count();
} }
inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) { inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
wmemory_buffer buffer; auto buf = wmemory_buffer();
detail::vformat_to(buffer, fmt, args); detail::vformat_to(buf, fmt, args);
buffer.push_back(L'\0'); buf.push_back(L'\0');
if (std::fputws(buffer.data(), f) == -1) if (std::fputws(buf.data(), f) == -1)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
} }
@ -217,13 +278,45 @@ template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
return vprint(wstring_view(fmt), fmt::make_wformat_args(args...)); return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
} }
/** template <typename... T>
Converts *value* to ``std::wstring`` using the default format for type *T*. void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
*/ return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
}
template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
}
inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args)
-> std::wstring {
auto buf = wmemory_buffer();
detail::vformat_to(buf, ts, fmt, args);
return fmt::to_string(buf);
}
template <typename... T>
inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args)
-> std::wstring {
return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));
}
template <typename... T>
FMT_DEPRECATED void print(std::FILE* f, const text_style& ts,
wformat_string<T...> fmt, const T&... args) {
vprint(f, ts, fmt, fmt::make_wformat_args(args...));
}
template <typename... T>
FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt,
const T&... args) {
return print(stdout, ts, fmt, args...);
}
/// Converts `value` to `std::wstring` using the default format for type `T`.
template <typename T> inline auto to_wstring(const T& value) -> std::wstring { template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
return format(FMT_STRING(L"{}"), value); return format(FMT_STRING(L"{}"), value);
} }
FMT_MODULE_EXPORT_END FMT_END_EXPORT
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // FMT_XCHAR_H_ #endif // FMT_XCHAR_H_

21
Tool/spdlog/include/spdlog/fmt/chrono.h
View File

@ -7,16 +7,17 @@
// //
// include bundled or external copy of fmtlib's chrono support // include bundled or external copy of fmtlib's chrono support
// //
#include <spdlog/tweakme.h>
#if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_USE_STD_FORMAT)
# if !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_FMT_EXTERNAL)
# ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# ifndef FMT_HEADER_ONLY #ifndef FMT_HEADER_ONLY
# define FMT_HEADER_ONLY #define FMT_HEADER_ONLY
# endif #endif
# endif #endif
# include <spdlog/fmt/bundled/chrono.h> #include <spdlog/fmt/bundled/chrono.h>
# else #else
# include <fmt/chrono.h> #include <fmt/chrono.h>
# endif #endif
#endif #endif

21
Tool/spdlog/include/spdlog/fmt/compile.h
View File

@ -7,16 +7,17 @@
// //
// include bundled or external copy of fmtlib's compile-time support // include bundled or external copy of fmtlib's compile-time support
// //
#include <spdlog/tweakme.h>
#if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_USE_STD_FORMAT)
# if !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_FMT_EXTERNAL)
# ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# ifndef FMT_HEADER_ONLY #ifndef FMT_HEADER_ONLY
# define FMT_HEADER_ONLY #define FMT_HEADER_ONLY
# endif #endif
# endif #endif
# include <spdlog/fmt/bundled/compile.h> #include <spdlog/fmt/bundled/compile.h>
# else #else
# include <fmt/compile.h> #include <fmt/compile.h>
# endif #endif
#endif #endif

31
Tool/spdlog/include/spdlog/fmt/fmt.h
View File

@ -9,25 +9,22 @@
// Include a bundled header-only copy of fmtlib or an external one. // Include a bundled header-only copy of fmtlib or an external one.
// By default spdlog include its own copy. // By default spdlog include its own copy.
// //
#include <spdlog/tweakme.h>
#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format #if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format
# include <format> #include <format>
#elif !defined(SPDLOG_FMT_EXTERNAL) #elif !defined(SPDLOG_FMT_EXTERNAL)
# if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
# define FMT_HEADER_ONLY #define FMT_HEADER_ONLY
# endif #endif
# ifndef FMT_USE_WINDOWS_H #ifndef FMT_USE_WINDOWS_H
# define FMT_USE_WINDOWS_H 0 #define FMT_USE_WINDOWS_H 0
# endif #endif
// enable the 'n' flag in for backward compatibility with fmt 6.x
# define FMT_DEPRECATED_N_SPECIFIER
// enable ostream formatting for backward compatibility with fmt 8.x
# define FMT_DEPRECATED_OSTREAM
# include <spdlog/fmt/bundled/core.h> #include <spdlog/fmt/bundled/core.h>
# include <spdlog/fmt/bundled/format.h> #include <spdlog/fmt/bundled/format.h>
#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib #else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
# include <fmt/core.h> #include <fmt/core.h>
# include <fmt/format.h> #include <fmt/format.h>
#endif #endif

21
Tool/spdlog/include/spdlog/fmt/ostr.h
View File

@ -7,16 +7,17 @@
// //
// include bundled or external copy of fmtlib's ostream support // include bundled or external copy of fmtlib's ostream support
// //
#include <spdlog/tweakme.h>
#if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_USE_STD_FORMAT)
# if !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_FMT_EXTERNAL)
# ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# ifndef FMT_HEADER_ONLY #ifndef FMT_HEADER_ONLY
# define FMT_HEADER_ONLY #define FMT_HEADER_ONLY
# endif #endif
# endif #endif
# include <spdlog/fmt/bundled/ostream.h> #include <spdlog/fmt/bundled/ostream.h>
# else #else
# include <fmt/ostream.h> #include <fmt/ostream.h>
# endif #endif
#endif #endif

21
Tool/spdlog/include/spdlog/fmt/ranges.h
View File

@ -7,16 +7,17 @@
// //
// include bundled or external copy of fmtlib's ranges support // include bundled or external copy of fmtlib's ranges support
// //
#include <spdlog/tweakme.h>
#if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_USE_STD_FORMAT)
# if !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_FMT_EXTERNAL)
# ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# ifndef FMT_HEADER_ONLY #ifndef FMT_HEADER_ONLY
# define FMT_HEADER_ONLY #define FMT_HEADER_ONLY
# endif #endif
# endif #endif
# include <spdlog/fmt/bundled/ranges.h> #include <spdlog/fmt/bundled/ranges.h>
# else #else
# include <fmt/ranges.h> #include <fmt/ranges.h>
# endif #endif
#endif #endif

25
Tool/spdlog/include/spdlog/fmt/std.h
View File

@ -5,19 +5,20 @@
#pragma once #pragma once
// //
// include bundled or external copy of fmtlib's std support (for formatting e.g. std::filesystem::path, std::thread::id, std::monostate, // include bundled or external copy of fmtlib's std support (for formatting e.g.
// std::variant, ...) // std::filesystem::path, std::thread::id, std::monostate, std::variant, ...)
// //
#include <spdlog/tweakme.h>
#if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_USE_STD_FORMAT)
# if !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_FMT_EXTERNAL)
# ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# ifndef FMT_HEADER_ONLY #ifndef FMT_HEADER_ONLY
# define FMT_HEADER_ONLY #define FMT_HEADER_ONLY
# endif #endif
# endif #endif
# include <spdlog/fmt/bundled/std.h> #include <spdlog/fmt/bundled/std.h>
# else #else
# include <fmt/std.h> #include <fmt/std.h>
# endif #endif
#endif #endif

21
Tool/spdlog/include/spdlog/fmt/xchar.h
View File

@ -7,16 +7,17 @@
// //
// include bundled or external copy of fmtlib's xchar support // include bundled or external copy of fmtlib's xchar support
// //
#include <spdlog/tweakme.h>
#if !defined(SPDLOG_USE_STD_FORMAT) #if !defined(SPDLOG_USE_STD_FORMAT)
# if !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_FMT_EXTERNAL)
# ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# ifndef FMT_HEADER_ONLY #ifndef FMT_HEADER_ONLY
# define FMT_HEADER_ONLY #define FMT_HEADER_ONLY
# endif #endif
# endif #endif
# include <spdlog/fmt/bundled/xchar.h> #include <spdlog/fmt/bundled/xchar.h>
# else #else
# include <fmt/xchar.h> #include <fmt/xchar.h>
# endif #endif
#endif #endif

7
Tool/spdlog/include/spdlog/formatter.h
View File

@ -3,16 +3,15 @@
#pragma once #pragma once
#include <spdlog/fmt/fmt.h>
#include <spdlog/details/log_msg.h> #include <spdlog/details/log_msg.h>
#include <spdlog/fmt/fmt.h>
namespace spdlog { namespace spdlog {
class formatter class formatter {
{
public: public:
virtual ~formatter() = default; virtual ~formatter() = default;
virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0; virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0;
virtual std::unique_ptr<formatter> clone() const = 0; virtual std::unique_ptr<formatter> clone() const = 0;
}; };
} // namespace spdlog } // namespace spdlog

2
Tool/spdlog/include/spdlog/fwd.h
View File

@ -15,4 +15,4 @@ namespace level {
enum level_enum : int; enum level_enum : int;
} }
} // namespace spdlog } // namespace spdlog

193
Tool/spdlog/include/spdlog/logger-inl.h
View File

@ -4,12 +4,12 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/logger.h> #include <spdlog/logger.h>
#endif #endif
#include <spdlog/sinks/sink.h>
#include <spdlog/details/backtracer.h> #include <spdlog/details/backtracer.h>
#include <spdlog/pattern_formatter.h> #include <spdlog/pattern_formatter.h>
#include <spdlog/sinks/sink.h>
#include <cstdio> #include <cstdio>
@ -17,31 +17,29 @@ namespace spdlog {
// public methods // public methods
SPDLOG_INLINE logger::logger(const logger &other) SPDLOG_INLINE logger::logger(const logger &other)
: name_(other.name_) : name_(other.name_),
, sinks_(other.sinks_) sinks_(other.sinks_),
, level_(other.level_.load(std::memory_order_relaxed)) level_(other.level_.load(std::memory_order_relaxed)),
, flush_level_(other.flush_level_.load(std::memory_order_relaxed)) flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
, custom_err_handler_(other.custom_err_handler_) custom_err_handler_(other.custom_err_handler_),
, tracer_(other.tracer_) tracer_(other.tracer_) {}
{}
SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)), SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT
sinks_(std::move(other.sinks_)), : name_(std::move(other.name_)),
level_(other.level_.load(std::memory_order_relaxed)), sinks_(std::move(other.sinks_)),
flush_level_(other.flush_level_.load(std::memory_order_relaxed)), level_(other.level_.load(std::memory_order_relaxed)),
custom_err_handler_(std::move(other.custom_err_handler_)), flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
tracer_(std::move(other.tracer_)) custom_err_handler_(std::move(other.custom_err_handler_)),
tracer_(std::move(other.tracer_))
{} {}
SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT {
{
this->swap(other); this->swap(other);
return *this; return *this;
} }
SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT {
{
name_.swap(other.name_); name_.swap(other.name_);
sinks_.swap(other.sinks_); sinks_.swap(other.sinks_);
@ -59,179 +57,121 @@ SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT
std::swap(tracer_, other.tracer_); std::swap(tracer_, other.tracer_);
} }
SPDLOG_INLINE void swap(logger &a, logger &b) SPDLOG_INLINE void swap(logger &a, logger &b) { a.swap(b); }
{
a.swap(b);
}
SPDLOG_INLINE void logger::set_level(level::level_enum log_level) SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); }
{
level_.store(log_level);
}
SPDLOG_INLINE level::level_enum logger::level() const SPDLOG_INLINE level::level_enum logger::level() const {
{
return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed)); return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed));
} }
SPDLOG_INLINE const std::string &logger::name() const SPDLOG_INLINE const std::string &logger::name() const { return name_; }
{
return name_;
}
// set formatting for the sinks in this logger. // set formatting for the sinks in this logger.
// each sink will get a separate instance of the formatter object. // each sink will get a separate instance of the formatter object.
SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) {
{ for (auto it = sinks_.begin(); it != sinks_.end(); ++it) {
for (auto it = sinks_.begin(); it != sinks_.end(); ++it) if (std::next(it) == sinks_.end()) {
{
if (std::next(it) == sinks_.end())
{
// last element - we can be move it. // last element - we can be move it.
(*it)->set_formatter(std::move(f)); (*it)->set_formatter(std::move(f));
break; // to prevent clang-tidy warning break; // to prevent clang-tidy warning
} } else {
else
{
(*it)->set_formatter(f->clone()); (*it)->set_formatter(f->clone());
} }
} }
} }
SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) {
{
auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type); auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type);
set_formatter(std::move(new_formatter)); set_formatter(std::move(new_formatter));
} }
// create new backtrace sink and move to it all our child sinks // create new backtrace sink and move to it all our child sinks
SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); }
{
tracer_.enable(n_messages);
}
// restore orig sinks and level and delete the backtrace sink // restore orig sinks and level and delete the backtrace sink
SPDLOG_INLINE void logger::disable_backtrace() SPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); }
{
tracer_.disable();
}
SPDLOG_INLINE void logger::dump_backtrace() SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); }
{
dump_backtrace_();
}
// flush functions // flush functions
SPDLOG_INLINE void logger::flush() SPDLOG_INLINE void logger::flush() { flush_(); }
{
flush_();
}
SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); }
{
flush_level_.store(log_level);
}
SPDLOG_INLINE level::level_enum logger::flush_level() const SPDLOG_INLINE level::level_enum logger::flush_level() const {
{
return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed)); return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed));
} }
// sinks // sinks
SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const { return sinks_; }
{
return sinks_;
}
SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() { return sinks_; }
{
return sinks_;
}
// error handler // error handler
SPDLOG_INLINE void logger::set_error_handler(err_handler handler) SPDLOG_INLINE void logger::set_error_handler(err_handler handler) {
{
custom_err_handler_ = std::move(handler); custom_err_handler_ = std::move(handler);
} }
// create new logger with same sinks and configuration. // create new logger with same sinks and configuration.
SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) {
{
auto cloned = std::make_shared<logger>(*this); auto cloned = std::make_shared<logger>(*this);
cloned->name_ = std::move(logger_name); cloned->name_ = std::move(logger_name);
return cloned; return cloned;
} }
// protected methods // protected methods
SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled) SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg,
{ bool log_enabled,
if (log_enabled) bool traceback_enabled) {
{ if (log_enabled) {
sink_it_(log_msg); sink_it_(log_msg);
} }
if (traceback_enabled) if (traceback_enabled) {
{
tracer_.push_back(log_msg); tracer_.push_back(log_msg);
} }
} }
SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) {
{ for (auto &sink : sinks_) {
for (auto &sink : sinks_) if (sink->should_log(msg.level)) {
{ SPDLOG_TRY { sink->log(msg); }
if (sink->should_log(msg.level))
{
SPDLOG_TRY
{
sink->log(msg);
}
SPDLOG_LOGGER_CATCH(msg.source) SPDLOG_LOGGER_CATCH(msg.source)
} }
} }
if (should_flush_(msg)) if (should_flush_(msg)) {
{
flush_(); flush_();
} }
} }
SPDLOG_INLINE void logger::flush_() SPDLOG_INLINE void logger::flush_() {
{ for (auto &sink : sinks_) {
for (auto &sink : sinks_) SPDLOG_TRY { sink->flush(); }
{
SPDLOG_TRY
{
sink->flush();
}
SPDLOG_LOGGER_CATCH(source_loc()) SPDLOG_LOGGER_CATCH(source_loc())
} }
} }
SPDLOG_INLINE void logger::dump_backtrace_() SPDLOG_INLINE void logger::dump_backtrace_() {
{
using details::log_msg; using details::log_msg;
if (tracer_.enabled() && !tracer_.empty()) if (tracer_.enabled() && !tracer_.empty()) {
{ sink_it_(
sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"}); log_msg{name(), level::info, "****************** Backtrace Start ******************"});
tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); }); tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"}); sink_it_(
log_msg{name(), level::info, "****************** Backtrace End ********************"});
} }
} }
SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) {
{
auto flush_level = flush_level_.load(std::memory_order_relaxed); auto flush_level = flush_level_.load(std::memory_order_relaxed);
return (msg.level >= flush_level) && (msg.level != level::off); return (msg.level >= flush_level) && (msg.level != level::off);
} }
SPDLOG_INLINE void logger::err_handler_(const std::string &msg) SPDLOG_INLINE void logger::err_handler_(const std::string &msg) {
{ if (custom_err_handler_) {
if (custom_err_handler_)
{
custom_err_handler_(msg); custom_err_handler_(msg);
} } else {
else
{
using std::chrono::system_clock; using std::chrono::system_clock;
static std::mutex mutex; static std::mutex mutex;
static std::chrono::system_clock::time_point last_report_time; static std::chrono::system_clock::time_point last_report_time;
@ -239,19 +179,20 @@ SPDLOG_INLINE void logger::err_handler_(const std::string &msg)
std::lock_guard<std::mutex> lk{mutex}; std::lock_guard<std::mutex> lk{mutex};
auto now = system_clock::now(); auto now = system_clock::now();
err_counter++; err_counter++;
if (now - last_report_time < std::chrono::seconds(1)) if (now - last_report_time < std::chrono::seconds(1)) {
{
return; return;
} }
last_report_time = now; last_report_time = now;
auto tm_time = details::os::localtime(system_clock::to_time_t(now)); auto tm_time = details::os::localtime(system_clock::to_time_t(now));
char date_buf[64]; char date_buf[64];
std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
#if defined(USING_R) && defined(R_R_H) // if in R environment #if defined(USING_R) && defined(R_R_H) // if in R environment
REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), msg.c_str()); REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(),
msg.c_str());
#else #else
std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), msg.c_str()); std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf,
name().c_str(), msg.c_str());
#endif #endif
} }
} }
} // namespace spdlog } // namespace spdlog

262
Tool/spdlog/include/spdlog/logger.h
View File

@ -15,67 +15,58 @@
// formatted data, and support for different format per sink. // formatted data, and support for different format per sink.
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/log_msg.h>
#include <spdlog/details/backtracer.h> #include <spdlog/details/backtracer.h>
#include <spdlog/details/log_msg.h>
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
# ifndef _WIN32 #ifndef _WIN32
# error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
# endif #endif
# include <spdlog/details/os.h> #include <spdlog/details/os.h>
#endif #endif
#include <vector> #include <vector>
#ifndef SPDLOG_NO_EXCEPTIONS #ifndef SPDLOG_NO_EXCEPTIONS
# define SPDLOG_LOGGER_CATCH(location) \ #define SPDLOG_LOGGER_CATCH(location) \
catch (const std::exception &ex) \ catch (const std::exception &ex) { \
{ \ if (location.filename) { \
if (location.filename) \ err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \
{ \ location.filename, location.line)); \
err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line)); \ } else { \
} \ err_handler_(ex.what()); \
else \ } \
{ \ } \
err_handler_(ex.what()); \ catch (...) { \
} \ err_handler_("Rethrowing unknown exception in logger"); \
} \ throw; \
catch (...) \
{ \
err_handler_("Rethrowing unknown exception in logger"); \
throw; \
} }
#else #else
# define SPDLOG_LOGGER_CATCH(location) #define SPDLOG_LOGGER_CATCH(location)
#endif #endif
namespace spdlog { namespace spdlog {
class SPDLOG_API logger class SPDLOG_API logger {
{
public: public:
// Empty logger // Empty logger
explicit logger(std::string name) explicit logger(std::string name)
: name_(std::move(name)) : name_(std::move(name)),
, sinks_() sinks_() {}
{}
// Logger with range on sinks // Logger with range on sinks
template<typename It> template <typename It>
logger(std::string name, It begin, It end) logger(std::string name, It begin, It end)
: name_(std::move(name)) : name_(std::move(name)),
, sinks_(begin, end) sinks_(begin, end) {}
{}
// Logger with single sink // Logger with single sink
logger(std::string name, sink_ptr single_sink) logger(std::string name, sink_ptr single_sink)
: logger(std::move(name), {std::move(single_sink)}) : logger(std::move(name), {std::move(single_sink)}) {}
{}
// Logger with sinks init list // Logger with sinks init list
logger(std::string name, sinks_init_list sinks) logger(std::string name, sinks_init_list sinks)
: logger(std::move(name), sinks.begin(), sinks.end()) : logger(std::move(name), sinks.begin(), sinks.end()) {}
{}
virtual ~logger() = default; virtual ~logger() = default;
@ -84,37 +75,36 @@ public:
logger &operator=(logger other) SPDLOG_NOEXCEPT; logger &operator=(logger other) SPDLOG_NOEXCEPT;
void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; void swap(spdlog::logger &other) SPDLOG_NOEXCEPT;
template<typename... Args> template <typename... Args>
void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) {
{
log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...); log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) {
{
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename T> template <typename T>
void log(level::level_enum lvl, const T &msg) void log(level::level_enum lvl, const T &msg) {
{
log(source_loc{}, lvl, msg); log(source_loc{}, lvl, msg);
} }
// T cannot be statically converted to format string (including string_view/wstring_view) // T cannot be statically converted to format string (including string_view/wstring_view)
template<class T, typename std::enable_if<!is_convertible_to_any_format_string<const T &>::value, int>::type = 0> template <class T,
void log(source_loc loc, level::level_enum lvl, const T &msg) typename std::enable_if<!is_convertible_to_any_format_string<const T &>::value,
{ int>::type = 0>
void log(source_loc loc, level::level_enum lvl, const T &msg) {
log(loc, lvl, "{}", msg); log(loc, lvl, "{}", msg);
} }
void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg) void log(log_clock::time_point log_time,
{ source_loc loc,
level::level_enum lvl,
string_view_t msg) {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) if (!log_enabled && !traceback_enabled) {
{
return; return;
} }
@ -122,12 +112,10 @@ public:
log_it_(log_msg, log_enabled, traceback_enabled); log_it_(log_msg, log_enabled, traceback_enabled);
} }
void log(source_loc loc, level::level_enum lvl, string_view_t msg) void log(source_loc loc, level::level_enum lvl, string_view_t msg) {
{
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) if (!log_enabled && !traceback_enabled) {
{
return; return;
} }
@ -135,66 +123,56 @@ public:
log_it_(log_msg, log_enabled, traceback_enabled); log_it_(log_msg, log_enabled, traceback_enabled);
} }
void log(level::level_enum lvl, string_view_t msg) void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); }
{
log(source_loc{}, lvl, msg);
}
template<typename... Args> template <typename... Args>
void trace(format_string_t<Args...> fmt, Args &&...args) void trace(format_string_t<Args...> fmt, Args &&...args) {
{
log(level::trace, fmt, std::forward<Args>(args)...); log(level::trace, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void debug(format_string_t<Args...> fmt, Args &&...args) void debug(format_string_t<Args...> fmt, Args &&...args) {
{
log(level::debug, fmt, std::forward<Args>(args)...); log(level::debug, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void info(format_string_t<Args...> fmt, Args &&...args) void info(format_string_t<Args...> fmt, Args &&...args) {
{
log(level::info, fmt, std::forward<Args>(args)...); log(level::info, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void warn(format_string_t<Args...> fmt, Args &&...args) void warn(format_string_t<Args...> fmt, Args &&...args) {
{
log(level::warn, fmt, std::forward<Args>(args)...); log(level::warn, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void error(format_string_t<Args...> fmt, Args &&...args) void error(format_string_t<Args...> fmt, Args &&...args) {
{
log(level::err, fmt, std::forward<Args>(args)...); log(level::err, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void critical(format_string_t<Args...> fmt, Args &&...args) void critical(format_string_t<Args...> fmt, Args &&...args) {
{
log(level::critical, fmt, std::forward<Args>(args)...); log(level::critical, fmt, std::forward<Args>(args)...);
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template <typename... Args>
void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) {
{
log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...); log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) {
{
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, wstring_view_t msg) void log(log_clock::time_point log_time,
{ source_loc loc,
level::level_enum lvl,
wstring_view_t msg) {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) if (!log_enabled && !traceback_enabled) {
{
return; return;
} }
@ -204,12 +182,10 @@ public:
log_it_(log_msg, log_enabled, traceback_enabled); log_it_(log_msg, log_enabled, traceback_enabled);
} }
void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) {
{
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) if (!log_enabled && !traceback_enabled) {
{
return; return;
} }
@ -219,95 +195,76 @@ public:
log_it_(log_msg, log_enabled, traceback_enabled); log_it_(log_msg, log_enabled, traceback_enabled);
} }
void log(level::level_enum lvl, wstring_view_t msg) void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); }
{
log(source_loc{}, lvl, msg);
}
template<typename... Args> template <typename... Args>
void trace(wformat_string_t<Args...> fmt, Args &&...args) void trace(wformat_string_t<Args...> fmt, Args &&...args) {
{
log(level::trace, fmt, std::forward<Args>(args)...); log(level::trace, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void debug(wformat_string_t<Args...> fmt, Args &&...args) void debug(wformat_string_t<Args...> fmt, Args &&...args) {
{
log(level::debug, fmt, std::forward<Args>(args)...); log(level::debug, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void info(wformat_string_t<Args...> fmt, Args &&...args) void info(wformat_string_t<Args...> fmt, Args &&...args) {
{
log(level::info, fmt, std::forward<Args>(args)...); log(level::info, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void warn(wformat_string_t<Args...> fmt, Args &&...args) void warn(wformat_string_t<Args...> fmt, Args &&...args) {
{
log(level::warn, fmt, std::forward<Args>(args)...); log(level::warn, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void error(wformat_string_t<Args...> fmt, Args &&...args) void error(wformat_string_t<Args...> fmt, Args &&...args) {
{
log(level::err, fmt, std::forward<Args>(args)...); log(level::err, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template <typename... Args>
void critical(wformat_string_t<Args...> fmt, Args &&...args) void critical(wformat_string_t<Args...> fmt, Args &&...args) {
{
log(level::critical, fmt, std::forward<Args>(args)...); log(level::critical, fmt, std::forward<Args>(args)...);
} }
#endif #endif
template<typename T> template <typename T>
void trace(const T &msg) void trace(const T &msg) {
{
log(level::trace, msg); log(level::trace, msg);
} }
template<typename T> template <typename T>
void debug(const T &msg) void debug(const T &msg) {
{
log(level::debug, msg); log(level::debug, msg);
} }
template<typename T> template <typename T>
void info(const T &msg) void info(const T &msg) {
{
log(level::info, msg); log(level::info, msg);
} }
template<typename T> template <typename T>
void warn(const T &msg) void warn(const T &msg) {
{
log(level::warn, msg); log(level::warn, msg);
} }
template<typename T> template <typename T>
void error(const T &msg) void error(const T &msg) {
{
log(level::err, msg); log(level::err, msg);
} }
template<typename T> template <typename T>
void critical(const T &msg) void critical(const T &msg) {
{
log(level::critical, msg); log(level::critical, msg);
} }
// return true logging is enabled for the given level. // return true logging is enabled for the given level.
bool should_log(level::level_enum msg_level) const bool should_log(level::level_enum msg_level) const {
{
return msg_level >= level_.load(std::memory_order_relaxed); return msg_level >= level_.load(std::memory_order_relaxed);
} }
// return true if backtrace logging is enabled. // return true if backtrace logging is enabled.
bool should_backtrace() const bool should_backtrace() const { return tracer_.enabled(); }
{
return tracer_.enabled();
}
void set_level(level::level_enum log_level); void set_level(level::level_enum log_level);
@ -356,17 +313,14 @@ protected:
details::backtracer tracer_; details::backtracer tracer_;
// common implementation for after templated public api has been resolved // common implementation for after templated public api has been resolved
template<typename... Args> template <typename... Args>
void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) {
{
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) if (!log_enabled && !traceback_enabled) {
{
return; return;
} }
SPDLOG_TRY SPDLOG_TRY {
{
memory_buf_t buf; memory_buf_t buf;
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...)); fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...));
@ -381,20 +335,18 @@ protected:
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template <typename... Args>
void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) {
{
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) if (!log_enabled && !traceback_enabled) {
{
return; return;
} }
SPDLOG_TRY SPDLOG_TRY {
{
// format to wmemory_buffer and convert to utf8 // format to wmemory_buffer and convert to utf8
wmemory_buf_t wbuf; wmemory_buf_t wbuf;
fmt_lib::vformat_to(std::back_inserter(wbuf), fmt, fmt_lib::make_format_args<fmt_lib::wformat_context>(args...)); fmt_lib::vformat_to(std::back_inserter(wbuf), fmt,
fmt_lib::make_format_args<fmt_lib::wformat_context>(args...));
memory_buf_t buf; memory_buf_t buf;
details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf);
@ -403,7 +355,7 @@ protected:
} }
SPDLOG_LOGGER_CATCH(loc) SPDLOG_LOGGER_CATCH(loc)
} }
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
// log the given message (if the given log level is high enough), // log the given message (if the given log level is high enough),
// and save backtrace (if backtrace is enabled). // and save backtrace (if backtrace is enabled).
@ -420,8 +372,8 @@ protected:
void swap(logger &a, logger &b); void swap(logger &a, logger &b);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "logger-inl.h" #include "logger-inl.h"
#endif #endif

50
Tool/spdlog/include/spdlog/mdc.h Normal file
View File

@ -0,0 +1,50 @@
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#if defined(SPDLOG_NO_TLS)
#error "This header requires thread local storage support, but SPDLOG_NO_TLS is defined."
#endif
#include <map>
#include <string>
#include <spdlog/common.h>
// MDC is a simple map of key->string values stored in thread local storage whose content will be printed by the loggers.
// Note: Not supported in async mode (thread local storage - so the async thread pool have different copy).
//
// Usage example:
// spdlog::mdc::put("mdc_key_1", "mdc_value_1");
// spdlog::info("Hello, {}", "World!"); // => [2024-04-26 02:08:05.040] [info] [mdc_key_1:mdc_value_1] Hello, World!
namespace spdlog {
class SPDLOG_API mdc {
public:
using mdc_map_t = std::map<std::string, std::string>;
static void put(const std::string &key, const std::string &value) {
get_context()[key] = value;
}
static std::string get(const std::string &key) {
auto &context = get_context();
auto it = context.find(key);
if (it != context.end()) {
return it->second;
}
return "";
}
static void remove(const std::string &key) { get_context().erase(key); }
static void clear() { get_context().clear(); }
static mdc_map_t &get_context() {
static thread_local mdc_map_t context;
return context;
}
};
} // namespace spdlog

1180
Tool/spdlog/include/spdlog/pattern_formatter-inl.h
View File

File diff suppressed because it is too large Load Diff

70
Tool/spdlog/include/spdlog/pattern_formatter.h
View File

@ -13,77 +13,67 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector>
#include <unordered_map> #include <unordered_map>
#include <vector>
namespace spdlog { namespace spdlog {
namespace details { namespace details {
// padding information. // padding information.
struct padding_info struct padding_info {
{ enum class pad_side { left, right, center };
enum class pad_side
{
left,
right,
center
};
padding_info() = default; padding_info() = default;
padding_info(size_t width, padding_info::pad_side side, bool truncate) padding_info(size_t width, padding_info::pad_side side, bool truncate)
: width_(width) : width_(width),
, side_(side) side_(side),
, truncate_(truncate) truncate_(truncate),
, enabled_(true) enabled_(true) {}
{}
bool enabled() const bool enabled() const { return enabled_; }
{
return enabled_;
}
size_t width_ = 0; size_t width_ = 0;
pad_side side_ = pad_side::left; pad_side side_ = pad_side::left;
bool truncate_ = false; bool truncate_ = false;
bool enabled_ = false; bool enabled_ = false;
}; };
class SPDLOG_API flag_formatter class SPDLOG_API flag_formatter {
{
public: public:
explicit flag_formatter(padding_info padinfo) explicit flag_formatter(padding_info padinfo)
: padinfo_(padinfo) : padinfo_(padinfo) {}
{}
flag_formatter() = default; flag_formatter() = default;
virtual ~flag_formatter() = default; virtual ~flag_formatter() = default;
virtual void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) = 0; virtual void format(const details::log_msg &msg,
const std::tm &tm_time,
memory_buf_t &dest) = 0;
protected: protected:
padding_info padinfo_; padding_info padinfo_;
}; };
} // namespace details } // namespace details
class SPDLOG_API custom_flag_formatter : public details::flag_formatter class SPDLOG_API custom_flag_formatter : public details::flag_formatter {
{
public: public:
virtual std::unique_ptr<custom_flag_formatter> clone() const = 0; virtual std::unique_ptr<custom_flag_formatter> clone() const = 0;
void set_padding_info(const details::padding_info &padding) void set_padding_info(const details::padding_info &padding) {
{
flag_formatter::padinfo_ = padding; flag_formatter::padinfo_ = padding;
} }
}; };
class SPDLOG_API pattern_formatter final : public formatter class SPDLOG_API pattern_formatter final : public formatter {
{
public: public:
using custom_flags = std::unordered_map<char, std::unique_ptr<custom_flag_formatter>>; using custom_flags = std::unordered_map<char, std::unique_ptr<custom_flag_formatter>>;
explicit pattern_formatter(std::string pattern, pattern_time_type time_type = pattern_time_type::local, explicit pattern_formatter(std::string pattern,
std::string eol = spdlog::details::os::default_eol, custom_flags custom_user_flags = custom_flags()); pattern_time_type time_type = pattern_time_type::local,
std::string eol = spdlog::details::os::default_eol,
custom_flags custom_user_flags = custom_flags());
// use default pattern is not given // use default pattern is not given
explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol); explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local,
std::string eol = spdlog::details::os::default_eol);
pattern_formatter(const pattern_formatter &other) = delete; pattern_formatter(const pattern_formatter &other) = delete;
pattern_formatter &operator=(const pattern_formatter &other) = delete; pattern_formatter &operator=(const pattern_formatter &other) = delete;
@ -91,9 +81,8 @@ public:
std::unique_ptr<formatter> clone() const override; std::unique_ptr<formatter> clone() const override;
void format(const details::log_msg &msg, memory_buf_t &dest) override; void format(const details::log_msg &msg, memory_buf_t &dest) override;
template<typename T, typename... Args> template <typename T, typename... Args>
pattern_formatter &add_flag(char flag, Args &&...args) pattern_formatter &add_flag(char flag, Args &&...args) {
{
custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...); custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...);
return *this; return *this;
} }
@ -111,18 +100,19 @@ private:
custom_flags custom_handlers_; custom_flags custom_handlers_;
std::tm get_time_(const details::log_msg &msg); std::tm get_time_(const details::log_msg &msg);
template<typename Padder> template <typename Padder>
void handle_flag_(char flag, details::padding_info padding); void handle_flag_(char flag, details::padding_info padding);
// Extract given pad spec (e.g. %8X) // Extract given pad spec (e.g. %8X)
// Advance the given it pass the end of the padding spec found (if any) // Advance the given it pass the end of the padding spec found (if any)
// Return padding. // Return padding.
static details::padding_info handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end); static details::padding_info handle_padspec_(std::string::const_iterator &it,
std::string::const_iterator end);
void compile_pattern_(const std::string &pattern); void compile_pattern_(const std::string &pattern);
}; };
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "pattern_formatter-inl.h" #include "pattern_formatter-inl.h"
#endif #endif

137
Tool/spdlog/include/spdlog/sinks/android_sink.h
View File

@ -5,50 +5,45 @@
#ifdef __ANDROID__ #ifdef __ANDROID__
# include <spdlog/details/fmt_helper.h> #include <spdlog/details/fmt_helper.h>
# include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
# include <spdlog/details/os.h> #include <spdlog/details/os.h>
# include <spdlog/sinks/base_sink.h> #include <spdlog/details/synchronous_factory.h>
# include <spdlog/details/synchronous_factory.h> #include <spdlog/sinks/base_sink.h>
# include <android/log.h> #include <android/log.h>
# include <chrono> #include <chrono>
# include <mutex> #include <mutex>
# include <string> #include <string>
# include <thread> #include <thread>
# include <type_traits> #include <type_traits>
# if !defined(SPDLOG_ANDROID_RETRIES) #if !defined(SPDLOG_ANDROID_RETRIES)
# define SPDLOG_ANDROID_RETRIES 2 #define SPDLOG_ANDROID_RETRIES 2
# endif #endif
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
/* /*
* Android sink * Android sink
* (logging using __android_log_write or __android_log_buf_write depending on the specified BufferID) * (logging using __android_log_write or __android_log_buf_write depending on the specified
* BufferID)
*/ */
template<typename Mutex, int BufferID = log_id::LOG_ID_MAIN> template <typename Mutex, int BufferID = log_id::LOG_ID_MAIN>
class android_sink final : public base_sink<Mutex> class android_sink final : public base_sink<Mutex> {
{
public: public:
explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false) explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
: tag_(std::move(tag)) : tag_(std::move(tag)),
, use_raw_msg_(use_raw_msg) use_raw_msg_(use_raw_msg) {}
{}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
const android_LogPriority priority = convert_to_android_(msg.level); const android_LogPriority priority = convert_to_android_(msg.level);
memory_buf_t formatted; memory_buf_t formatted;
if (use_raw_msg_) if (use_raw_msg_) {
{
details::fmt_helper::append_string_view(msg.payload, formatted); details::fmt_helper::append_string_view(msg.payload, formatted);
} } else {
else
{
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
} }
formatted.push_back('\0'); formatted.push_back('\0');
@ -56,20 +51,17 @@ protected:
// See system/core/liblog/logger_write.c for explanation of return value // See system/core/liblog/logger_write.c for explanation of return value
int ret = android_log(priority, tag_.c_str(), msg_output); int ret = android_log(priority, tag_.c_str(), msg_output);
if (ret == -EPERM) if (ret == -EPERM) {
{ return; // !__android_log_is_loggable
return; // !__android_log_is_loggable
} }
int retry_count = 0; int retry_count = 0;
while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) {
{
details::os::sleep_for_millis(5); details::os::sleep_for_millis(5);
ret = android_log(priority, tag_.c_str(), msg_output); ret = android_log(priority, tag_.c_str(), msg_output);
retry_count++; retry_count++;
} }
if (ret < 0) if (ret < 0) {
{
throw_spdlog_ex("logging to Android failed", ret); throw_spdlog_ex("logging to Android failed", ret);
} }
} }
@ -77,39 +69,38 @@ protected:
void flush_() override {} void flush_() override {}
private: private:
// There might be liblog versions used, that do not support __android_log_buf_write. So we only compile and link against // There might be liblog versions used, that do not support __android_log_buf_write. So we only
// __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise, when using the default log buffer, always // compile and link against
// log via __android_log_write. // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise,
template<int ID = BufferID> // when using the default log buffer, always log via __android_log_write.
typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char *tag, const char *text) template <int ID = BufferID>
{ typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
int prio, const char *tag, const char *text) {
return __android_log_write(prio, tag, text); return __android_log_write(prio, tag, text);
} }
template<int ID = BufferID> template <int ID = BufferID>
typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char *tag, const char *text) typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
{ int prio, const char *tag, const char *text) {
return __android_log_buf_write(ID, prio, tag, text); return __android_log_buf_write(ID, prio, tag, text);
} }
static android_LogPriority convert_to_android_(spdlog::level::level_enum level) static android_LogPriority convert_to_android_(spdlog::level::level_enum level) {
{ switch (level) {
switch (level) case spdlog::level::trace:
{ return ANDROID_LOG_VERBOSE;
case spdlog::level::trace: case spdlog::level::debug:
return ANDROID_LOG_VERBOSE; return ANDROID_LOG_DEBUG;
case spdlog::level::debug: case spdlog::level::info:
return ANDROID_LOG_DEBUG; return ANDROID_LOG_INFO;
case spdlog::level::info: case spdlog::level::warn:
return ANDROID_LOG_INFO; return ANDROID_LOG_WARN;
case spdlog::level::warn: case spdlog::level::err:
return ANDROID_LOG_WARN; return ANDROID_LOG_ERROR;
case spdlog::level::err: case spdlog::level::critical:
return ANDROID_LOG_ERROR; return ANDROID_LOG_FATAL;
case spdlog::level::critical: default:
return ANDROID_LOG_FATAL; return ANDROID_LOG_DEFAULT;
default:
return ANDROID_LOG_DEFAULT;
} }
} }
@ -120,27 +111,27 @@ private:
using android_sink_mt = android_sink<std::mutex>; using android_sink_mt = android_sink<std::mutex>;
using android_sink_st = android_sink<details::null_mutex>; using android_sink_st = android_sink<details::null_mutex>;
template<int BufferId = log_id::LOG_ID_MAIN> template <int BufferId = log_id::LOG_ID_MAIN>
using android_sink_buf_mt = android_sink<std::mutex, BufferId>; using android_sink_buf_mt = android_sink<std::mutex, BufferId>;
template<int BufferId = log_id::LOG_ID_MAIN> template <int BufferId = log_id::LOG_ID_MAIN>
using android_sink_buf_st = android_sink<details::null_mutex, BufferId>; using android_sink_buf_st = android_sink<details::null_mutex, BufferId>;
} // namespace sinks } // namespace sinks
// Create and register android syslog logger // Create and register android syslog logger
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog") inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name,
{ const std::string &tag = "spdlog") {
return Factory::template create<sinks::android_sink_mt>(logger_name, tag); return Factory::template create<sinks::android_sink_mt>(logger_name, tag);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog") inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name,
{ const std::string &tag = "spdlog") {
return Factory::template create<sinks::android_sink_st>(logger_name, tag); return Factory::template create<sinks::android_sink_st>(logger_name, tag);
} }
} // namespace spdlog } // namespace spdlog
#endif // __ANDROID__ #endif // __ANDROID__

116
Tool/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h
View File

@ -4,20 +4,20 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/sinks/ansicolor_sink.h> #include <spdlog/sinks/ansicolor_sink.h>
#endif #endif
#include <spdlog/pattern_formatter.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <spdlog/pattern_formatter.h>
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode) SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
: target_file_(target_file) : target_file_(target_file),
, mutex_(ConsoleMutex::mutex()) mutex_(ConsoleMutex::mutex()),
, formatter_(details::make_unique<spdlog::pattern_formatter>()) formatter_(details::make_unique<spdlog::pattern_formatter>())
{ {
set_color_mode(mode); set_color_mode(mode);
@ -30,16 +30,15 @@ SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, co
colors_.at(level::off) = to_string_(reset); colors_.at(level::off) = to_string_(reset);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, string_view_t color) SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level,
{ string_view_t color) {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
colors_.at(static_cast<size_t>(color_level)) = to_string_(color); colors_.at(static_cast<size_t>(color_level)) = to_string_(color);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg) SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg) {
{
// Wrap the originally formatted message in color codes. // Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead. // If color is not supported in the terminal, log as is instead.
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
@ -47,8 +46,7 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg
msg.color_range_end = 0; msg.color_range_end = 0;
memory_buf_t formatted; memory_buf_t formatted;
formatter_->format(msg, formatted); formatter_->format(msg, formatted);
if (should_do_colors_ && msg.color_range_end > msg.color_range_start) if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {
{
// before color range // before color range
print_range_(formatted, 0, msg.color_range_start); print_range_(formatted, 0, msg.color_range_start);
// in color range // in color range
@ -57,89 +55,81 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg
print_ccode_(reset); print_ccode_(reset);
// after color range // after color range
print_range_(formatted, msg.color_range_end, formatted.size()); print_range_(formatted, msg.color_range_end, formatted.size());
} } else // no color
else // no color
{ {
print_range_(formatted, 0, formatted.size()); print_range_(formatted, 0, formatted.size());
} }
fflush(target_file_); fflush(target_file_);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush() SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush() {
{
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
fflush(target_file_); fflush(target_file_);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) {
{
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(
{ std::unique_ptr<spdlog::formatter> sink_formatter) {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() {
{
return should_do_colors_; return should_do_colors_;
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
{ switch (mode) {
switch (mode) case color_mode::always:
{ should_do_colors_ = true;
case color_mode::always: return;
should_do_colors_ = true; case color_mode::automatic:
return; should_do_colors_ =
case color_mode::automatic: details::os::in_terminal(target_file_) && details::os::is_color_terminal();
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal(); return;
return; case color_mode::never:
case color_mode::never: should_do_colors_ = false;
should_do_colors_ = false; return;
return; default:
default: should_do_colors_ = false;
should_do_colors_ = false;
} }
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) {
{ details::os::fwrite_bytes(color_code.data(), color_code.size(), target_file_);
fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end) SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted,
{ size_t start,
fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); size_t end) {
details::os::fwrite_bytes(formatted.data() + start, end - start, target_file_);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) {
{
return std::string(sv.data(), sv.size()); return std::string(sv.data(), sv.size());
} }
// ansicolor_stdout_sink // ansicolor_stdout_sink
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode) SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode)
: ansicolor_sink<ConsoleMutex>(stdout, mode) : ansicolor_sink<ConsoleMutex>(stdout, mode) {}
{}
// ansicolor_stderr_sink // ansicolor_stderr_sink
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode) SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
: ansicolor_sink<ConsoleMutex>(stderr, mode) : ansicolor_sink<ConsoleMutex>(stderr, mode) {}
{}
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

29
Tool/spdlog/include/spdlog/sinks/ansicolor_sink.h
View File

@ -3,13 +3,13 @@
#pragma once #pragma once
#include <array>
#include <memory>
#include <mutex>
#include <spdlog/details/console_globals.h> #include <spdlog/details/console_globals.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/sink.h> #include <spdlog/sinks/sink.h>
#include <memory>
#include <mutex>
#include <string> #include <string>
#include <array>
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
@ -21,9 +21,8 @@ namespace sinks {
* If no color terminal detected, omit the escape codes. * If no color terminal detected, omit the escape codes.
*/ */
template<typename ConsoleMutex> template <typename ConsoleMutex>
class ansicolor_sink : public sink class ansicolor_sink : public sink {
{
public: public:
using mutex_t = typename ConsoleMutex::mutex_t; using mutex_t = typename ConsoleMutex::mutex_t;
ansicolor_sink(FILE *target_file, color_mode mode); ansicolor_sink(FILE *target_file, color_mode mode);
@ -41,7 +40,7 @@ public:
void log(const details::log_msg &msg) override; void log(const details::log_msg &msg) override;
void flush() override; void flush() override;
void set_pattern(const std::string &pattern) final; void set_pattern(const std::string &pattern) final override;
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override; void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
// Formatting codes // Formatting codes
@ -90,16 +89,14 @@ private:
static std::string to_string_(const string_view_t &sv); static std::string to_string_(const string_view_t &sv);
}; };
template<typename ConsoleMutex> template <typename ConsoleMutex>
class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex> class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex> {
{
public: public:
explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic); explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic);
}; };
template<typename ConsoleMutex> template <typename ConsoleMutex>
class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex> class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex> {
{
public: public:
explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic); explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic);
}; };
@ -110,9 +107,9 @@ using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::console_nullmute
using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>; using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>;
using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>; using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "ansicolor_sink-inl.h" #include "ansicolor_sink-inl.h"
#endif #endif

48
Tool/spdlog/include/spdlog/sinks/base_sink-inl.h
View File

@ -4,60 +4,56 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
#endif #endif
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/pattern_formatter.h> #include <spdlog/pattern_formatter.h>
#include <memory> #include <memory>
#include <mutex>
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink() SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink()
: formatter_{details::make_unique<spdlog::pattern_formatter>()} : formatter_{details::make_unique<spdlog::pattern_formatter>()} {}
{}
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog::formatter> formatter) SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(
: formatter_{std::move(formatter)} std::unique_ptr<spdlog::formatter> formatter)
{} : formatter_{std::move(formatter)} {}
template<typename Mutex> template <typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg) void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg) {
{
std::lock_guard<Mutex> lock(mutex_); std::lock_guard<Mutex> lock(mutex_);
sink_it_(msg); sink_it_(msg);
} }
template<typename Mutex> template <typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush() void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush() {
{
std::lock_guard<Mutex> lock(mutex_); std::lock_guard<Mutex> lock(mutex_);
flush_(); flush_();
} }
template<typename Mutex> template <typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern) void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern) {
{
std::lock_guard<Mutex> lock(mutex_); std::lock_guard<Mutex> lock(mutex_);
set_pattern_(pattern); set_pattern_(pattern);
} }
template<typename Mutex> template <typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) void SPDLOG_INLINE
{ spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) {
std::lock_guard<Mutex> lock(mutex_); std::lock_guard<Mutex> lock(mutex_);
set_formatter_(std::move(sink_formatter)); set_formatter_(std::move(sink_formatter));
} }
template<typename Mutex> template <typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern) void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern) {
{
set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern)); set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
} }
template<typename Mutex> template <typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) void SPDLOG_INLINE
{ spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) {
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }

19
Tool/spdlog/include/spdlog/sinks/base_sink.h
View File

@ -15,9 +15,8 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class SPDLOG_API base_sink : public sink class SPDLOG_API base_sink : public sink {
{
public: public:
base_sink(); base_sink();
explicit base_sink(std::unique_ptr<spdlog::formatter> formatter); explicit base_sink(std::unique_ptr<spdlog::formatter> formatter);
@ -29,10 +28,10 @@ public:
base_sink &operator=(const base_sink &) = delete; base_sink &operator=(const base_sink &) = delete;
base_sink &operator=(base_sink &&) = delete; base_sink &operator=(base_sink &&) = delete;
void log(const details::log_msg &msg) final; void log(const details::log_msg &msg) final override;
void flush() final; void flush() final override;
void set_pattern(const std::string &pattern) final; void set_pattern(const std::string &pattern) final override;
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final; void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final override;
protected: protected:
// sink formatter // sink formatter
@ -44,9 +43,9 @@ protected:
virtual void set_pattern_(const std::string &pattern); virtual void set_pattern_(const std::string &pattern);
virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter); virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);
}; };
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "base_sink-inl.h" #include "base_sink-inl.h"
#endif #endif

36
Tool/spdlog/include/spdlog/sinks/basic_file_sink-inl.h
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/sinks/basic_file_sink.h> #include <spdlog/sinks/basic_file_sink.h>
#endif #endif
#include <spdlog/common.h> #include <spdlog/common.h>
@ -13,32 +13,36 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers) SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename,
: file_helper_{event_handlers} bool truncate,
{ const file_event_handlers &event_handlers)
: file_helper_{event_handlers} {
file_helper_.open(filename, truncate); file_helper_.open(filename, truncate);
} }
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const {
{
return file_helper_.filename(); return file_helper_.filename();
} }
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) SPDLOG_INLINE void basic_file_sink<Mutex>::truncate() {
{ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
file_helper_.reopen(true);
}
template <typename Mutex>
SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
file_helper_.write(formatted); file_helper_.write(formatted);
} }
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE void basic_file_sink<Mutex>::flush_() SPDLOG_INLINE void basic_file_sink<Mutex>::flush_() {
{
file_helper_.flush(); file_helper_.flush();
} }
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

42
Tool/spdlog/include/spdlog/sinks/basic_file_sink.h
View File

@ -5,8 +5,8 @@
#include <spdlog/details/file_helper.h> #include <spdlog/details/file_helper.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h>
#include <mutex> #include <mutex>
#include <string> #include <string>
@ -16,12 +16,14 @@ namespace sinks {
/* /*
* Trivial file sink with single file as target * Trivial file sink with single file as target
*/ */
template<typename Mutex> template <typename Mutex>
class basic_file_sink final : public base_sink<Mutex> class basic_file_sink final : public base_sink<Mutex> {
{
public: public:
explicit basic_file_sink(const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}); explicit basic_file_sink(const filename_t &filename,
bool truncate = false,
const file_event_handlers &event_handlers = {});
const filename_t &filename() const; const filename_t &filename() const;
void truncate();
protected: protected:
void sink_it_(const details::log_msg &msg) override; void sink_it_(const details::log_msg &msg) override;
@ -34,27 +36,31 @@ private:
using basic_file_sink_mt = basic_file_sink<std::mutex>; using basic_file_sink_mt = basic_file_sink<std::mutex>;
using basic_file_sink_st = basic_file_sink<details::null_mutex>; using basic_file_sink_st = basic_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> basic_logger_mt( inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name,
const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}) const filename_t &filename,
{ bool truncate = false,
return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate, event_handlers); const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate,
event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> basic_logger_st( inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}) const filename_t &filename,
{ bool truncate = false,
return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate, event_handlers); const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate,
event_handlers);
} }
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "basic_file_sink-inl.h" #include "basic_file_sink-inl.h"
#endif #endif

33
Tool/spdlog/include/spdlog/sinks/callback_sink.h
View File

@ -4,8 +4,8 @@
#pragma once #pragma once
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h>
#include <mutex> #include <mutex>
#include <string> #include <string>
@ -19,20 +19,15 @@ namespace sinks {
/* /*
* Trivial callback sink, gets a callback function and calls it on each log * Trivial callback sink, gets a callback function and calls it on each log
*/ */
template<typename Mutex> template <typename Mutex>
class callback_sink final : public base_sink<Mutex> class callback_sink final : public base_sink<Mutex> {
{
public: public:
explicit callback_sink(const custom_log_callback &callback) explicit callback_sink(const custom_log_callback &callback)
: callback_{callback} : callback_{callback} {}
{}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override { callback_(msg); }
{ void flush_() override{}
callback_(msg);
}
void flush_() override{};
private: private:
custom_log_callback callback_; custom_log_callback callback_;
@ -41,21 +36,21 @@ private:
using callback_sink_mt = callback_sink<std::mutex>; using callback_sink_mt = callback_sink<std::mutex>;
using callback_sink_st = callback_sink<details::null_mutex>; using callback_sink_st = callback_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name, const custom_log_callback &callback) inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name,
{ const custom_log_callback &callback) {
return Factory::template create<sinks::callback_sink_mt>(logger_name, callback); return Factory::template create<sinks::callback_sink_mt>(logger_name, callback);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name, const custom_log_callback &callback) inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name,
{ const custom_log_callback &callback) {
return Factory::template create<sinks::callback_sink_st>(logger_name, callback); return Factory::template create<sinks::callback_sink_st>(logger_name, callback);
} }
} // namespace spdlog } // namespace spdlog

185
Tool/spdlog/include/spdlog/sinks/daily_file_sink.h
View File

@ -4,20 +4,20 @@
#pragma once #pragma once
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/circular_q.h>
#include <spdlog/details/file_helper.h> #include <spdlog/details/file_helper.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/fmt/fmt.h>
#include <spdlog/fmt/chrono.h>
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <spdlog/details/circular_q.h>
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
#include <spdlog/fmt/chrono.h>
#include <spdlog/fmt/fmt.h>
#include <spdlog/sinks/base_sink.h>
#include <sstream>
#include <iomanip>
#include <chrono> #include <chrono>
#include <cstdio> #include <cstdio>
#include <iomanip>
#include <mutex> #include <mutex>
#include <sstream>
#include <string> #include <string>
namespace spdlog { namespace spdlog {
@ -26,29 +26,28 @@ namespace sinks {
/* /*
* Generator of daily log file names in format basename.YYYY-MM-DD.ext * Generator of daily log file names in format basename.YYYY-MM-DD.ext
*/ */
struct daily_filename_calculator struct daily_filename_calculator {
{
// Create filename for the form basename.YYYY-MM-DD // Create filename for the form basename.YYYY-MM-DD
static filename_t calc_filename(const filename_t &filename, const tm &now_tm) static filename_t calc_filename(const filename_t &filename, const tm &now_tm) {
{
filename_t basename, ext; filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename); std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), basename, now_tm.tm_year + 1900, return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")),
now_tm.tm_mon + 1, now_tm.tm_mday, ext); basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
ext);
} }
}; };
/* /*
* Generator of daily log file names with strftime format. * Generator of daily log file names with strftime format.
* Usages: * Usages:
* auto sink = std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour, minute);" * auto sink =
* auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", hour, minute)" * std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour,
* minute);" auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log",
* hour, minute)"
* *
*/ */
struct daily_filename_format_calculator struct daily_filename_format_calculator {
{ static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) {
static filename_t calc_filename(const filename_t &file_path, const tm &now_tm)
{
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
std::wstringstream stream; std::wstringstream stream;
#else #else
@ -63,24 +62,28 @@ struct daily_filename_format_calculator
* Rotating file sink based on date. * Rotating file sink based on date.
* If truncate != false , the created file will be truncated. * If truncate != false , the created file will be truncated.
* If max_files > 0, retain only the last max_files and delete previous. * If max_files > 0, retain only the last max_files and delete previous.
* Note that old log files from previous executions will not be deleted by this class,
* rotation and deletion is only applied while the program is running.
*/ */
template<typename Mutex, typename FileNameCalc = daily_filename_calculator> template <typename Mutex, typename FileNameCalc = daily_filename_calculator>
class daily_file_sink final : public base_sink<Mutex> class daily_file_sink final : public base_sink<Mutex> {
{
public: public:
// create daily file sink which rotates on given time // 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, uint16_t max_files = 0, daily_file_sink(filename_t base_filename,
const file_event_handlers &event_handlers = {}) int rotation_hour,
: base_filename_(std::move(base_filename)) int rotation_minute,
, rotation_h_(rotation_hour) bool truncate = false,
, rotation_m_(rotation_minute) uint16_t max_files = 0,
, file_helper_{event_handlers} const file_event_handlers &event_handlers = {})
, truncate_(truncate) : base_filename_(std::move(base_filename)),
, max_files_(max_files) rotation_h_(rotation_hour),
, filenames_q_() rotation_m_(rotation_minute),
{ file_helper_{event_handlers},
if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) truncate_(truncate),
{ max_files_(max_files),
filenames_q_() {
if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 ||
rotation_minute > 59) {
throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
} }
@ -89,25 +92,21 @@ public:
file_helper_.open(filename, truncate_); file_helper_.open(filename, truncate_);
rotation_tp_ = next_rotation_tp_(); rotation_tp_ = next_rotation_tp_();
if (max_files_ > 0) if (max_files_ > 0) {
{
init_filenames_q_(); init_filenames_q_();
} }
} }
filename_t filename() filename_t filename() {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return file_helper_.filename(); return file_helper_.filename();
} }
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
auto time = msg.time; auto time = msg.time;
bool should_rotate = time >= rotation_tp_; bool should_rotate = time >= rotation_tp_;
if (should_rotate) if (should_rotate) {
{
auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
file_helper_.open(filename, truncate_); file_helper_.open(filename, truncate_);
rotation_tp_ = next_rotation_tp_(); rotation_tp_ = next_rotation_tp_();
@ -117,57 +116,46 @@ protected:
file_helper_.write(formatted); file_helper_.write(formatted);
// Do the cleaning only at the end because it might throw on failure. // Do the cleaning only at the end because it might throw on failure.
if (should_rotate && max_files_ > 0) if (should_rotate && max_files_ > 0) {
{
delete_old_(); delete_old_();
} }
} }
void flush_() override void flush_() override { file_helper_.flush(); }
{
file_helper_.flush();
}
private: private:
void init_filenames_q_() void init_filenames_q_() {
{
using details::os::path_exists; using details::os::path_exists;
filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_)); filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_));
std::vector<filename_t> filenames; std::vector<filename_t> filenames;
auto now = log_clock::now(); auto now = log_clock::now();
while (filenames.size() < max_files_) while (filenames.size() < max_files_) {
{
auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
if (!path_exists(filename)) if (!path_exists(filename)) {
{
break; break;
} }
filenames.emplace_back(filename); filenames.emplace_back(filename);
now -= std::chrono::hours(24); now -= std::chrono::hours(24);
} }
for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {
{
filenames_q_.push_back(std::move(*iter)); filenames_q_.push_back(std::move(*iter));
} }
} }
tm now_tm(log_clock::time_point tp) tm now_tm(log_clock::time_point tp) {
{
time_t tnow = log_clock::to_time_t(tp); time_t tnow = log_clock::to_time_t(tp);
return spdlog::details::os::localtime(tnow); return spdlog::details::os::localtime(tnow);
} }
log_clock::time_point next_rotation_tp_() log_clock::time_point next_rotation_tp_() {
{
auto now = log_clock::now(); auto now = log_clock::now();
tm date = now_tm(now); tm date = now_tm(now);
date.tm_hour = rotation_h_; date.tm_hour = rotation_h_;
date.tm_min = rotation_m_; date.tm_min = rotation_m_;
date.tm_sec = 0; date.tm_sec = 0;
auto rotation_time = log_clock::from_time_t(std::mktime(&date)); auto rotation_time = log_clock::from_time_t(std::mktime(&date));
if (rotation_time > now) if (rotation_time > now) {
{
return rotation_time; return rotation_time;
} }
return {rotation_time + std::chrono::hours(24)}; return {rotation_time + std::chrono::hours(24)};
@ -175,21 +163,19 @@ private:
// Delete the file N rotations ago. // Delete the file N rotations ago.
// Throw spdlog_ex on failure to delete the old file. // Throw spdlog_ex on failure to delete the old file.
void delete_old_() void delete_old_() {
{
using details::os::filename_to_str; using details::os::filename_to_str;
using details::os::remove_if_exists; using details::os::remove_if_exists;
filename_t current_file = file_helper_.filename(); filename_t current_file = file_helper_.filename();
if (filenames_q_.full()) if (filenames_q_.full()) {
{
auto old_filename = std::move(filenames_q_.front()); auto old_filename = std::move(filenames_q_.front());
filenames_q_.pop_front(); filenames_q_.pop_front();
bool ok = remove_if_exists(old_filename) == 0; bool ok = remove_if_exists(old_filename) == 0;
if (!ok) if (!ok) {
{
filenames_q_.push_back(std::move(current_file)); filenames_q_.push_back(std::move(current_file));
throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename), errno); throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename),
errno);
} }
} }
filenames_q_.push_back(std::move(current_file)); filenames_q_.push_back(std::move(current_file));
@ -208,40 +194,61 @@ private:
using daily_file_sink_mt = daily_file_sink<std::mutex>; using daily_file_sink_mt = daily_file_sink<std::mutex>;
using daily_file_sink_st = daily_file_sink<details::null_mutex>; using daily_file_sink_st = daily_file_sink<details::null_mutex>;
using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_format_calculator>; using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_format_calculator>;
using daily_file_format_sink_st = daily_file_sink<details::null_mutex, daily_filename_format_calculator>; using daily_file_format_sink_st =
daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) const filename_t &filename,
{ int hour = 0,
return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate, max_files, event_handlers); int minute = 0,
bool truncate = false,
uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute,
truncate, max_files, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> daily_logger_format_mt(const std::string &logger_name, const filename_t &filename, int hour = 0, inline std::shared_ptr<logger> daily_logger_format_mt(
int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) const std::string &logger_name,
{ const filename_t &filename,
int hour = 0,
int minute = 0,
bool truncate = false,
uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::daily_file_format_sink_mt>( return Factory::template create<sinks::daily_file_format_sink_mt>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers); logger_name, filename, hour, minute, truncate, max_files, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) const filename_t &filename,
{ int hour = 0,
return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate, max_files, event_handlers); int minute = 0,
bool truncate = false,
uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute,
truncate, max_files, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> daily_logger_format_st(const std::string &logger_name, const filename_t &filename, int hour = 0, inline std::shared_ptr<logger> daily_logger_format_st(
int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) const std::string &logger_name,
{ const filename_t &filename,
int hour = 0,
int minute = 0,
bool truncate = false,
uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::daily_file_format_sink_st>( return Factory::template create<sinks::daily_file_format_sink_st>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers); logger_name, filename, hour, minute, truncate, max_files, event_handlers);
} }
} // namespace spdlog } // namespace spdlog

50
Tool/spdlog/include/spdlog/sinks/dist_sink.h
View File

@ -19,71 +19,55 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class dist_sink : public base_sink<Mutex> class dist_sink : public base_sink<Mutex> {
{
public: public:
dist_sink() = default; dist_sink() = default;
explicit dist_sink(std::vector<std::shared_ptr<sink>> sinks) explicit dist_sink(std::vector<std::shared_ptr<sink>> sinks)
: sinks_(sinks) : sinks_(sinks) {}
{}
dist_sink(const dist_sink &) = delete; dist_sink(const dist_sink &) = delete;
dist_sink &operator=(const dist_sink &) = delete; dist_sink &operator=(const dist_sink &) = delete;
void add_sink(std::shared_ptr<sink> sub_sink) void add_sink(std::shared_ptr<sink> sub_sink) {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
sinks_.push_back(sub_sink); sinks_.push_back(sub_sink);
} }
void remove_sink(std::shared_ptr<sink> sub_sink) void remove_sink(std::shared_ptr<sink> sub_sink) {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end()); sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end());
} }
void set_sinks(std::vector<std::shared_ptr<sink>> sinks) void set_sinks(std::vector<std::shared_ptr<sink>> sinks) {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
sinks_ = std::move(sinks); sinks_ = std::move(sinks);
} }
std::vector<std::shared_ptr<sink>> &sinks() std::vector<std::shared_ptr<sink>> &sinks() { return sinks_; }
{
return sinks_;
}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{ for (auto &sub_sink : sinks_) {
for (auto &sub_sink : sinks_) if (sub_sink->should_log(msg.level)) {
{
if (sub_sink->should_log(msg.level))
{
sub_sink->log(msg); sub_sink->log(msg);
} }
} }
} }
void flush_() override void flush_() override {
{ for (auto &sub_sink : sinks_) {
for (auto &sub_sink : sinks_)
{
sub_sink->flush(); sub_sink->flush();
} }
} }
void set_pattern_(const std::string &pattern) override void set_pattern_(const std::string &pattern) override {
{
set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern)); set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
} }
void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override {
{
base_sink<Mutex>::formatter_ = std::move(sink_formatter); base_sink<Mutex>::formatter_ = std::move(sink_formatter);
for (auto &sub_sink : sinks_) for (auto &sub_sink : sinks_) {
{
sub_sink->set_formatter(base_sink<Mutex>::formatter_->clone()); sub_sink->set_formatter(base_sink<Mutex>::formatter_->clone());
} }
} }
@ -93,5 +77,5 @@ protected:
using dist_sink_mt = dist_sink<std::mutex>; using dist_sink_mt = dist_sink<std::mutex>;
using dist_sink_st = dist_sink<details::null_mutex>; using dist_sink_st = dist_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

48
Tool/spdlog/include/spdlog/sinks/dup_filter_sink.h
View File

@ -4,13 +4,13 @@
#pragma once #pragma once
#include "dist_sink.h" #include "dist_sink.h"
#include <spdlog/details/null_mutex.h>
#include <spdlog/details/log_msg.h> #include <spdlog/details/log_msg.h>
#include <spdlog/details/null_mutex.h>
#include <chrono>
#include <cstdio> #include <cstdio>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <chrono>
// Duplicate message removal sink. // Duplicate message removal sink.
// Skip the message if previous one is identical and less than "max_skip_duration" have passed // Skip the message if previous one is identical and less than "max_skip_duration" have passed
@ -20,8 +20,8 @@
// #include <spdlog/sinks/dup_filter_sink.h> // #include <spdlog/sinks/dup_filter_sink.h>
// //
// int main() { // int main() {
// auto dup_filter = std::make_shared<dup_filter_sink_st>(std::chrono::seconds(5), level::info); // auto dup_filter = std::make_shared<dup_filter_sink_st>(std::chrono::seconds(5),
// dup_filter->add_sink(std::make_shared<stdout_color_sink_mt>()); // level::info); dup_filter->add_sink(std::make_shared<stdout_color_sink_mt>());
// spdlog::logger l("logger", dup_filter); // spdlog::logger l("logger", dup_filter);
// l.info("Hello"); // l.info("Hello");
// l.info("Hello"); // l.info("Hello");
@ -36,15 +36,14 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class dup_filter_sink : public dist_sink<Mutex> class dup_filter_sink : public dist_sink<Mutex> {
{
public: public:
template<class Rep, class Period> template <class Rep, class Period>
explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration, level::level_enum notification_level = level::info) explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration,
: max_skip_duration_{max_skip_duration} level::level_enum notification_level = level::info)
, log_level_{notification_level} : max_skip_duration_{max_skip_duration},
{} log_level_{notification_level} {}
protected: protected:
std::chrono::microseconds max_skip_duration_; std::chrono::microseconds max_skip_duration_;
@ -53,23 +52,21 @@ protected:
size_t skip_counter_ = 0; size_t skip_counter_ = 0;
level::level_enum log_level_; level::level_enum log_level_;
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
bool filtered = filter_(msg); bool filtered = filter_(msg);
if (!filtered) if (!filtered) {
{
skip_counter_ += 1; skip_counter_ += 1;
return; return;
} }
// log the "skipped.." message // log the "skipped.." message
if (skip_counter_ > 0) if (skip_counter_ > 0) {
{
char buf[64]; char buf[64];
auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..", static_cast<unsigned>(skip_counter_)); auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..",
if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf)) static_cast<unsigned>(skip_counter_));
{ if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf)) {
details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_, string_view_t{buf, static_cast<size_t>(msg_size)}}; details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_,
string_view_t{buf, static_cast<size_t>(msg_size)}};
dist_sink<Mutex>::sink_it_(skipped_msg); dist_sink<Mutex>::sink_it_(skipped_msg);
} }
} }
@ -82,8 +79,7 @@ protected:
} }
// return whether the log msg should be displayed (true) or skipped (false) // return whether the log msg should be displayed (true) or skipped (false)
bool filter_(const details::log_msg &msg) bool filter_(const details::log_msg &msg) {
{
auto filter_duration = msg.time - last_msg_time_; auto filter_duration = msg.time - last_msg_time_;
return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_); return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_);
} }
@ -92,5 +88,5 @@ protected:
using dup_filter_sink_mt = dup_filter_sink<std::mutex>; using dup_filter_sink_mt = dup_filter_sink<std::mutex>;
using dup_filter_sink_st = dup_filter_sink<details::null_mutex>; using dup_filter_sink_st = dup_filter_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

127
Tool/spdlog/include/spdlog/sinks/hourly_file_sink.h
View File

@ -4,13 +4,13 @@
#pragma once #pragma once
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/circular_q.h>
#include <spdlog/details/file_helper.h> #include <spdlog/details/file_helper.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/os.h>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/fmt/fmt.h> #include <spdlog/fmt/fmt.h>
#include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
#include <spdlog/details/os.h>
#include <spdlog/details/circular_q.h>
#include <spdlog/details/synchronous_factory.h>
#include <chrono> #include <chrono>
#include <cstdio> #include <cstdio>
@ -24,15 +24,14 @@ namespace sinks {
/* /*
* Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext
*/ */
struct hourly_filename_calculator struct hourly_filename_calculator {
{
// Create filename for the form basename.YYYY-MM-DD-H // Create filename for the form basename.YYYY-MM-DD-H
static filename_t calc_filename(const filename_t &filename, const tm &now_tm) static filename_t calc_filename(const filename_t &filename, const tm &now_tm) {
{
filename_t basename, ext; filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename); std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename,
now_tm.tm_mday, now_tm.tm_hour, ext); now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
now_tm.tm_hour, ext);
} }
}; };
@ -40,47 +39,44 @@ struct hourly_filename_calculator
* Rotating file sink based on time. * Rotating file sink based on time.
* If truncate != false , the created file will be truncated. * If truncate != false , the created file will be truncated.
* If max_files > 0, retain only the last max_files and delete previous. * If max_files > 0, retain only the last max_files and delete previous.
* Note that old log files from previous executions will not be deleted by this class,
* rotation and deletion is only applied while the program is running.
*/ */
template<typename Mutex, typename FileNameCalc = hourly_filename_calculator> template <typename Mutex, typename FileNameCalc = hourly_filename_calculator>
class hourly_file_sink final : public base_sink<Mutex> class hourly_file_sink final : public base_sink<Mutex> {
{
public: public:
// create hourly file sink which rotates on given time // create hourly file sink which rotates on given time
hourly_file_sink( hourly_file_sink(filename_t base_filename,
filename_t base_filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) bool truncate = false,
: base_filename_(std::move(base_filename)) uint16_t max_files = 0,
, file_helper_{event_handlers} const file_event_handlers &event_handlers = {})
, truncate_(truncate) : base_filename_(std::move(base_filename)),
, max_files_(max_files) file_helper_{event_handlers},
, filenames_q_() truncate_(truncate),
{ max_files_(max_files),
filenames_q_() {
auto now = log_clock::now(); auto now = log_clock::now();
auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
file_helper_.open(filename, truncate_); file_helper_.open(filename, truncate_);
remove_init_file_ = file_helper_.size() == 0; remove_init_file_ = file_helper_.size() == 0;
rotation_tp_ = next_rotation_tp_(); rotation_tp_ = next_rotation_tp_();
if (max_files_ > 0) if (max_files_ > 0) {
{
init_filenames_q_(); init_filenames_q_();
} }
} }
filename_t filename() filename_t filename() {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return file_helper_.filename(); return file_helper_.filename();
} }
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
auto time = msg.time; auto time = msg.time;
bool should_rotate = time >= rotation_tp_; bool should_rotate = time >= rotation_tp_;
if (should_rotate) if (should_rotate) {
{ if (remove_init_file_) {
if (remove_init_file_)
{
file_helper_.close(); file_helper_.close();
details::os::remove(file_helper_.filename()); details::os::remove(file_helper_.filename());
} }
@ -94,56 +90,45 @@ protected:
file_helper_.write(formatted); file_helper_.write(formatted);
// Do the cleaning only at the end because it might throw on failure. // Do the cleaning only at the end because it might throw on failure.
if (should_rotate && max_files_ > 0) if (should_rotate && max_files_ > 0) {
{
delete_old_(); delete_old_();
} }
} }
void flush_() override void flush_() override { file_helper_.flush(); }
{
file_helper_.flush();
}
private: private:
void init_filenames_q_() void init_filenames_q_() {
{
using details::os::path_exists; using details::os::path_exists;
filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_)); filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_));
std::vector<filename_t> filenames; std::vector<filename_t> filenames;
auto now = log_clock::now(); auto now = log_clock::now();
while (filenames.size() < max_files_) while (filenames.size() < max_files_) {
{
auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
if (!path_exists(filename)) if (!path_exists(filename)) {
{
break; break;
} }
filenames.emplace_back(filename); filenames.emplace_back(filename);
now -= std::chrono::hours(1); now -= std::chrono::hours(1);
} }
for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {
{
filenames_q_.push_back(std::move(*iter)); filenames_q_.push_back(std::move(*iter));
} }
} }
tm now_tm(log_clock::time_point tp) tm now_tm(log_clock::time_point tp) {
{
time_t tnow = log_clock::to_time_t(tp); time_t tnow = log_clock::to_time_t(tp);
return spdlog::details::os::localtime(tnow); return spdlog::details::os::localtime(tnow);
} }
log_clock::time_point next_rotation_tp_() log_clock::time_point next_rotation_tp_() {
{
auto now = log_clock::now(); auto now = log_clock::now();
tm date = now_tm(now); tm date = now_tm(now);
date.tm_min = 0; date.tm_min = 0;
date.tm_sec = 0; date.tm_sec = 0;
auto rotation_time = log_clock::from_time_t(std::mktime(&date)); auto rotation_time = log_clock::from_time_t(std::mktime(&date));
if (rotation_time > now) if (rotation_time > now) {
{
return rotation_time; return rotation_time;
} }
return {rotation_time + std::chrono::hours(1)}; return {rotation_time + std::chrono::hours(1)};
@ -151,21 +136,19 @@ private:
// Delete the file N rotations ago. // Delete the file N rotations ago.
// Throw spdlog_ex on failure to delete the old file. // Throw spdlog_ex on failure to delete the old file.
void delete_old_() void delete_old_() {
{
using details::os::filename_to_str; using details::os::filename_to_str;
using details::os::remove_if_exists; using details::os::remove_if_exists;
filename_t current_file = file_helper_.filename(); filename_t current_file = file_helper_.filename();
if (filenames_q_.full()) if (filenames_q_.full()) {
{
auto old_filename = std::move(filenames_q_.front()); auto old_filename = std::move(filenames_q_.front());
filenames_q_.pop_front(); filenames_q_.pop_front();
bool ok = remove_if_exists(old_filename) == 0; bool ok = remove_if_exists(old_filename) == 0;
if (!ok) if (!ok) {
{
filenames_q_.push_back(std::move(current_file)); filenames_q_.push_back(std::move(current_file));
SPDLOG_THROW(spdlog_ex("Failed removing hourly file " + filename_to_str(old_filename), errno)); SPDLOG_THROW(spdlog_ex(
"Failed removing hourly file " + filename_to_str(old_filename), errno));
} }
} }
filenames_q_.push_back(std::move(current_file)); filenames_q_.push_back(std::move(current_file));
@ -183,22 +166,28 @@ private:
using hourly_file_sink_mt = hourly_file_sink<std::mutex>; using hourly_file_sink_mt = hourly_file_sink<std::mutex>;
using hourly_file_sink_st = hourly_file_sink<details::null_mutex>; using hourly_file_sink_st = hourly_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> hourly_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false, inline std::shared_ptr<logger> hourly_logger_mt(const std::string &logger_name,
uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) const filename_t &filename,
{ bool truncate = false,
return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate, max_files, event_handlers); uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate,
max_files, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false, inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name,
uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) const filename_t &filename,
{ bool truncate = false,
return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate, max_files, event_handlers); uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate,
max_files, event_handlers);
} }
} // namespace spdlog } // namespace spdlog

100
Tool/spdlog/include/spdlog/sinks/kafka_sink.h
View File

@ -10,13 +10,13 @@
// https://github.com/confluentinc/librdkafka // https://github.com/confluentinc/librdkafka
// //
#include <spdlog/common.h>
#include "spdlog/details/log_msg.h"
#include "spdlog/sinks/base_sink.h"
#include "spdlog/details/synchronous_factory.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/async.h" #include "spdlog/async.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/null_mutex.h"
#include "spdlog/details/synchronous_factory.h"
#include "spdlog/sinks/base_sink.h"
#include <mutex> #include <mutex>
#include <spdlog/common.h>
// kafka header // kafka header
#include <librdkafka/rdkafkacpp.h> #include <librdkafka/rdkafkacpp.h>
@ -24,74 +24,60 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
struct kafka_sink_config struct kafka_sink_config {
{
std::string server_addr; std::string server_addr;
std::string produce_topic; std::string produce_topic;
int32_t flush_timeout_ms = 1000; int32_t flush_timeout_ms = 1000;
kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000) kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000)
: server_addr{std::move(addr)} : server_addr{std::move(addr)},
, produce_topic{std::move(topic)} produce_topic{std::move(topic)},
, flush_timeout_ms(flush_timeout_ms) flush_timeout_ms(flush_timeout_ms) {}
{}
}; };
template<typename Mutex> template <typename Mutex>
class kafka_sink : public base_sink<Mutex> class kafka_sink : public base_sink<Mutex> {
{
public: public:
kafka_sink(kafka_sink_config config) kafka_sink(kafka_sink_config config)
: config_{std::move(config)} : config_{std::move(config)} {
{ try {
try
{
std::string errstr; std::string errstr;
conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL)); conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL));
RdKafka::Conf::ConfResult confRes = conf_->set("bootstrap.servers", config_.server_addr, errstr); RdKafka::Conf::ConfResult confRes =
if (confRes != RdKafka::Conf::CONF_OK) conf_->set("bootstrap.servers", config_.server_addr, errstr);
{ if (confRes != RdKafka::Conf::CONF_OK) {
throw_spdlog_ex(fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr)); throw_spdlog_ex(
fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr));
} }
tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC)); tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC));
if (tconf_ == nullptr) if (tconf_ == nullptr) {
{
throw_spdlog_ex(fmt_lib::format("create topic config failed")); throw_spdlog_ex(fmt_lib::format("create topic config failed"));
} }
producer_.reset(RdKafka::Producer::create(conf_.get(), errstr)); producer_.reset(RdKafka::Producer::create(conf_.get(), errstr));
if (producer_ == nullptr) if (producer_ == nullptr) {
{
throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr)); throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr));
} }
topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic, tconf_.get(), errstr)); topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic,
if (topic_ == nullptr) tconf_.get(), errstr));
{ if (topic_ == nullptr) {
throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr)); throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr));
} }
} } catch (const std::exception &e) {
catch (const std::exception &e)
{
throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what())); throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what()));
} }
} }
~kafka_sink() ~kafka_sink() { producer_->flush(config_.flush_timeout_ms); }
{
producer_->flush(config_.flush_timeout_ms);
}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{ producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY,
producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY, (void *)msg.payload.data(), msg.payload.size(), NULL, NULL); (void *)msg.payload.data(), msg.payload.size(), NULL, NULL);
} }
void flush_() override void flush_() override { producer_->flush(config_.flush_timeout_ms); }
{
producer_->flush(config_.flush_timeout_ms);
}
private: private:
kafka_sink_config config_; kafka_sink_config config_;
@ -104,30 +90,30 @@ private:
using kafka_sink_mt = kafka_sink<std::mutex>; using kafka_sink_mt = kafka_sink<std::mutex>;
using kafka_sink_st = kafka_sink<spdlog::details::null_mutex>; using kafka_sink_st = kafka_sink<spdlog::details::null_mutex>;
} // namespace sinks } // namespace sinks
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> kafka_logger_mt(const std::string &logger_name, spdlog::sinks::kafka_sink_config config) inline std::shared_ptr<logger> kafka_logger_mt(const std::string &logger_name,
{ spdlog::sinks::kafka_sink_config config) {
return Factory::template create<sinks::kafka_sink_mt>(logger_name, config); return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> kafka_logger_st(const std::string &logger_name, spdlog::sinks::kafka_sink_config config) inline std::shared_ptr<logger> kafka_logger_st(const std::string &logger_name,
{ spdlog::sinks::kafka_sink_config config) {
return Factory::template create<sinks::kafka_sink_st>(logger_name, config); return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
} }
template<typename Factory = spdlog::async_factory> template <typename Factory = spdlog::async_factory>
inline std::shared_ptr<spdlog::logger> kafka_logger_async_mt(std::string logger_name, spdlog::sinks::kafka_sink_config config) inline std::shared_ptr<spdlog::logger> kafka_logger_async_mt(
{ std::string logger_name, spdlog::sinks::kafka_sink_config config) {
return Factory::template create<sinks::kafka_sink_mt>(logger_name, config); return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
} }
template<typename Factory = spdlog::async_factory> template <typename Factory = spdlog::async_factory>
inline std::shared_ptr<spdlog::logger> kafka_logger_async_st(std::string logger_name, spdlog::sinks::kafka_sink_config config) inline std::shared_ptr<spdlog::logger> kafka_logger_async_st(
{ std::string logger_name, spdlog::sinks::kafka_sink_config config) {
return Factory::template create<sinks::kafka_sink_st>(logger_name, config); return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
} }
} // namespace spdlog } // namespace spdlog

87
Tool/spdlog/include/spdlog/sinks/mongo_sink.h
View File

@ -25,51 +25,46 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class mongo_sink : public base_sink<Mutex> class mongo_sink : public base_sink<Mutex> {
{
public: public:
mongo_sink(const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017") mongo_sink(const std::string &db_name,
try : mongo_sink(std::make_shared<mongocxx::instance>(), db_name, collection_name, uri) const std::string &collection_name,
{} const std::string &uri = "mongodb://localhost:27017") try
catch (const std::exception &e) : mongo_sink(std::make_shared<mongocxx::instance>(), db_name, collection_name, uri) {
{ } catch (const std::exception &e) {
throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
} }
mongo_sink(std::shared_ptr<mongocxx::instance> instance, const std::string &db_name, const std::string &collection_name, mongo_sink(std::shared_ptr<mongocxx::instance> instance,
const std::string &uri = "mongodb://localhost:27017") const std::string &db_name,
: instance_(std::move(instance)) const std::string &collection_name,
, db_name_(db_name) const std::string &uri = "mongodb://localhost:27017")
, coll_name_(collection_name) : instance_(std::move(instance)),
{ db_name_(db_name),
try coll_name_(collection_name) {
{ try {
client_ = spdlog::details::make_unique<mongocxx::client>(mongocxx::uri{uri}); client_ = spdlog::details::make_unique<mongocxx::client>(mongocxx::uri{uri});
} } catch (const std::exception &e) {
catch (const std::exception &e)
{
throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
} }
} }
~mongo_sink() ~mongo_sink() { flush_(); }
{
flush_();
}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
using bsoncxx::builder::stream::document; using bsoncxx::builder::stream::document;
using bsoncxx::builder::stream::finalize; using bsoncxx::builder::stream::finalize;
if (client_ != nullptr) if (client_ != nullptr) {
{ auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level"
auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" << level::to_string_view(msg.level).data() << level::to_string_view(msg.level).data() << "level_num"
<< "level_num" << msg.level << "message" << std::string(msg.payload.begin(), msg.payload.end()) << msg.level << "message"
<< "logger_name" << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id" << std::string(msg.payload.begin(), msg.payload.end())
<< static_cast<int>(msg.thread_id) << finalize; << "logger_name"
<< std::string(msg.logger_name.begin(), msg.logger_name.end())
<< "thread_id" << static_cast<int>(msg.thread_id) << finalize;
client_->database(db_name_).collection(coll_name_).insert_one(doc.view()); client_->database(db_name_).collection(coll_name_).insert_one(doc.view());
} }
} }
@ -88,20 +83,26 @@ private:
using mongo_sink_mt = mongo_sink<std::mutex>; using mongo_sink_mt = mongo_sink<std::mutex>;
using mongo_sink_st = mongo_sink<spdlog::details::null_mutex>; using mongo_sink_st = mongo_sink<spdlog::details::null_mutex>;
} // namespace sinks } // namespace sinks
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> mongo_logger_mt(const std::string &logger_name, const std::string &db_name, inline std::shared_ptr<logger> mongo_logger_mt(
const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017") const std::string &logger_name,
{ const std::string &db_name,
return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name, uri); const std::string &collection_name,
const std::string &uri = "mongodb://localhost:27017") {
return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name,
uri);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> mongo_logger_st(const std::string &logger_name, const std::string &db_name, inline std::shared_ptr<logger> mongo_logger_st(
const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017") const std::string &logger_name,
{ const std::string &db_name,
return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name, uri); const std::string &collection_name,
const std::string &uri = "mongodb://localhost:27017") {
return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name,
uri);
} }
} // namespace spdlog } // namespace spdlog

47
Tool/spdlog/include/spdlog/sinks/msvc_sink.h
View File

@ -5,21 +5,21 @@
#if defined(_WIN32) #if defined(_WIN32)
# include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
# if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
# include <spdlog/details/os.h> #include <spdlog/details/os.h>
# endif #endif
# include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
# include <mutex> #include <mutex>
# include <string> #include <string>
// Avoid including windows.h (https://stackoverflow.com/a/30741042) // Avoid including windows.h (https://stackoverflow.com/a/30741042)
# if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString); extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString);
# else #else
extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString); extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString);
# endif #endif
extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
namespace spdlog { namespace spdlog {
@ -27,31 +27,28 @@ namespace sinks {
/* /*
* MSVC sink (logging using OutputDebugStringA) * MSVC sink (logging using OutputDebugStringA)
*/ */
template<typename Mutex> template <typename Mutex>
class msvc_sink : public base_sink<Mutex> class msvc_sink : public base_sink<Mutex> {
{
public: public:
msvc_sink() = default; msvc_sink() = default;
msvc_sink(bool check_debugger_present) msvc_sink(bool check_debugger_present)
: check_debugger_present_{check_debugger_present} {}; : check_debugger_present_{check_debugger_present} {}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{ if (check_debugger_present_ && !IsDebuggerPresent()) {
if (check_debugger_present_ && !IsDebuggerPresent())
{
return; return;
} }
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
formatted.push_back('\0'); // add a null terminator for OutputDebugString formatted.push_back('\0'); // add a null terminator for OutputDebugString
# if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
wmemory_buf_t wformatted; wmemory_buf_t wformatted;
details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted); details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted);
OutputDebugStringW(wformatted.data()); OutputDebugStringW(wformatted.data());
# else #else
OutputDebugStringA(formatted.data()); OutputDebugStringA(formatted.data());
# endif #endif
} }
void flush_() override {} void flush_() override {}
@ -65,7 +62,7 @@ using msvc_sink_st = msvc_sink<details::null_mutex>;
using windebug_sink_mt = msvc_sink_mt; using windebug_sink_mt = msvc_sink_mt;
using windebug_sink_st = msvc_sink_st; using windebug_sink_st = msvc_sink_st;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#endif #endif

21
Tool/spdlog/include/spdlog/sinks/null_sink.h
View File

@ -4,17 +4,16 @@
#pragma once #pragma once
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h>
#include <mutex> #include <mutex>
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class null_sink : public base_sink<Mutex> class null_sink final : public base_sink<Mutex> {
{
protected: protected:
void sink_it_(const details::log_msg &) override {} void sink_it_(const details::log_msg &) override {}
void flush_() override {} void flush_() override {}
@ -23,22 +22,20 @@ protected:
using null_sink_mt = null_sink<details::null_mutex>; using null_sink_mt = null_sink<details::null_mutex>;
using null_sink_st = null_sink<details::null_mutex>; using null_sink_st = null_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) {
{
auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name); auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name);
null_logger->set_level(level::off); null_logger->set_level(level::off);
return null_logger; return null_logger;
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) {
{
auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name); auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name);
null_logger->set_level(level::off); null_logger->set_level(level::off);
return null_logger; return null_logger;
} }
} // namespace spdlog } // namespace spdlog

25
Tool/spdlog/include/spdlog/sinks/ostream_sink.h
View File

@ -11,33 +11,26 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class ostream_sink final : public base_sink<Mutex> class ostream_sink final : public base_sink<Mutex> {
{
public: public:
explicit ostream_sink(std::ostream &os, bool force_flush = false) explicit ostream_sink(std::ostream &os, bool force_flush = false)
: ostream_(os) : ostream_(os),
, force_flush_(force_flush) force_flush_(force_flush) {}
{}
ostream_sink(const ostream_sink &) = delete; ostream_sink(const ostream_sink &) = delete;
ostream_sink &operator=(const ostream_sink &) = delete; ostream_sink &operator=(const ostream_sink &) = delete;
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
ostream_.write(formatted.data(), static_cast<std::streamsize>(formatted.size())); ostream_.write(formatted.data(), static_cast<std::streamsize>(formatted.size()));
if (force_flush_) if (force_flush_) {
{
ostream_.flush(); ostream_.flush();
} }
} }
void flush_() override void flush_() override { ostream_.flush(); }
{
ostream_.flush();
}
std::ostream &ostream_; std::ostream &ostream_;
bool force_flush_; bool force_flush_;
@ -46,5 +39,5 @@ protected:
using ostream_sink_mt = ostream_sink<std::mutex>; using ostream_sink_mt = ostream_sink<std::mutex>;
using ostream_sink_st = ostream_sink<details::null_mutex>; using ostream_sink_st = ostream_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

230
Tool/spdlog/include/spdlog/sinks/qt_sinks.h
View File

@ -4,12 +4,12 @@
#pragma once #pragma once
// //
// Custom sink for QPlainTextEdit or QTextEdit and its childs(QTextBrowser... // Custom sink for QPlainTextEdit or QTextEdit and its children (QTextBrowser...
// etc) Building and using requires Qt library. // etc) Building and using requires Qt library.
// //
// Warning: the qt_sink won't be notified if the target widget is destroyed. // Warning: the qt_sink won't be notified if the target widget is destroyed.
// If the widget's lifetime can be shorter than the logger's one, you should provide some permanent QObject, // If the widget's lifetime can be shorter than the logger's one, you should provide some permanent
// and then use a standard signal/slot. // QObject, and then use a standard signal/slot.
// //
#include "spdlog/common.h" #include "spdlog/common.h"
@ -18,40 +18,34 @@
#include "spdlog/sinks/base_sink.h" #include "spdlog/sinks/base_sink.h"
#include <array> #include <array>
#include <QTextEdit>
#include <QPlainTextEdit> #include <QPlainTextEdit>
#include <QTextEdit>
// //
// qt_sink class // qt_sink class
// //
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
class qt_sink : public base_sink<Mutex> class qt_sink : public base_sink<Mutex> {
{
public: public:
qt_sink(QObject *qt_object, std::string meta_method) qt_sink(QObject *qt_object, std::string meta_method)
: qt_object_(qt_object) : qt_object_(qt_object),
, meta_method_(std::move(meta_method)) meta_method_(std::move(meta_method)) {
{ if (!qt_object_) {
if (!qt_object_)
{
throw_spdlog_ex("qt_sink: qt_object is null"); throw_spdlog_ex("qt_sink: qt_object is null");
} }
} }
~qt_sink() ~qt_sink() { flush_(); }
{
flush_();
}
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
const string_view_t str = string_view_t(formatted.data(), formatted.size()); const string_view_t str = string_view_t(formatted.data(), formatted.size());
QMetaObject::invokeMethod(qt_object_, meta_method_.c_str(), Qt::AutoConnection, QMetaObject::invokeMethod(
qt_object_, meta_method_.c_str(), Qt::AutoConnection,
Q_ARG(QString, QString::fromUtf8(str.data(), static_cast<int>(str.size())).trimmed())); Q_ARG(QString, QString::fromUtf8(str.data(), static_cast<int>(str.size())).trimmed()));
} }
@ -62,21 +56,23 @@ private:
std::string meta_method_; std::string meta_method_;
}; };
// QT color sink to QTextEdit. // Qt color sink to QTextEdit.
// Color location is determined by the sink log pattern like in the rest of spdlog sinks. // Color location is determined by the sink log pattern like in the rest of spdlog sinks.
// Colors can be modified if needed using sink->set_color(level, qtTextCharFormat). // Colors can be modified if needed using sink->set_color(level, qtTextCharFormat).
// max_lines is the maximum number of lines that the sink will hold before removing the oldest lines. // max_lines is the maximum number of lines that the sink will hold before removing the oldest
// Note: Only ascii (latin1) is supported by this sink. // lines. By default, only ascii (latin1) is supported by this sink. Set is_utf8 to true if utf8
template<typename Mutex> // support is needed.
class qt_color_sink : public base_sink<Mutex> template <typename Mutex>
{ class qt_color_sink : public base_sink<Mutex> {
public: public:
qt_color_sink(QTextEdit *qt_text_edit, int max_lines) qt_color_sink(QTextEdit *qt_text_edit,
: qt_text_edit_(qt_text_edit) int max_lines,
, max_lines_(max_lines) bool dark_colors = false,
{ bool is_utf8 = false)
if (!qt_text_edit_) : qt_text_edit_(qt_text_edit),
{ max_lines_(max_lines),
is_utf8_(is_utf8) {
if (!qt_text_edit_) {
throw_spdlog_ex("qt_color_text_sink: text_edit is null"); throw_spdlog_ex("qt_color_text_sink: text_edit is null");
} }
@ -84,16 +80,16 @@ public:
// set colors // set colors
QTextCharFormat format; QTextCharFormat format;
// trace // trace
format.setForeground(Qt::gray); format.setForeground(dark_colors ? Qt::darkGray : Qt::gray);
colors_.at(level::trace) = format; colors_.at(level::trace) = format;
// debug // debug
format.setForeground(Qt::cyan); format.setForeground(dark_colors ? Qt::darkCyan : Qt::cyan);
colors_.at(level::debug) = format; colors_.at(level::debug) = format;
// info // info
format.setForeground(Qt::green); format.setForeground(dark_colors ? Qt::darkGreen : Qt::green);
colors_.at(level::info) = format; colors_.at(level::info) = format;
// warn // warn
format.setForeground(Qt::yellow); format.setForeground(dark_colors ? Qt::darkYellow : Qt::yellow);
colors_.at(level::warn) = format; colors_.at(level::warn) = format;
// err // err
format.setForeground(Qt::red); format.setForeground(Qt::red);
@ -104,48 +100,44 @@ public:
colors_.at(level::critical) = format; colors_.at(level::critical) = format;
} }
~qt_color_sink() ~qt_color_sink() { flush_(); }
{
flush_();
}
void set_default_color(QTextCharFormat format) void set_default_color(QTextCharFormat format) {
{
// std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); // std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
default_color_ = format; default_color_ = format;
} }
void set_level_color(level::level_enum color_level, QTextCharFormat format) void set_level_color(level::level_enum color_level, QTextCharFormat format) {
{
// std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); // std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
colors_.at(static_cast<size_t>(color_level)) = format; colors_.at(static_cast<size_t>(color_level)) = format;
} }
QTextCharFormat &get_level_color(level::level_enum color_level) QTextCharFormat &get_level_color(level::level_enum color_level) {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return colors_.at(static_cast<size_t>(color_level)); return colors_.at(static_cast<size_t>(color_level));
} }
QTextCharFormat &get_default_color() QTextCharFormat &get_default_color() {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return default_color_; return default_color_;
} }
protected: protected:
struct invoke_params struct invoke_params {
{ invoke_params(int max_lines,
invoke_params(int max_lines, QTextEdit *q_text_edit, QString payload, QTextCharFormat default_color, QTextCharFormat level_color, QTextEdit *q_text_edit,
int color_range_start, int color_range_end) QString payload,
: max_lines(max_lines) QTextCharFormat default_color,
, q_text_edit(q_text_edit) QTextCharFormat level_color,
, payload(std::move(payload)) int color_range_start,
, default_color(default_color) int color_range_end)
, level_color(level_color) : max_lines(max_lines),
, color_range_start(color_range_start) q_text_edit(q_text_edit),
, color_range_end(color_range_end) payload(std::move(payload)),
{} default_color(default_color),
level_color(level_color),
color_range_start(color_range_start),
color_range_end(color_range_end) {}
int max_lines; int max_lines;
QTextEdit *q_text_edit; QTextEdit *q_text_edit;
QString payload; QString payload;
@ -155,22 +147,33 @@ protected:
int color_range_end; int color_range_end;
}; };
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
const string_view_t str = string_view_t(formatted.data(), formatted.size()); const string_view_t str = string_view_t(formatted.data(), formatted.size());
// apply the color to the color range in the formatted message. // apply the color to the color range in the formatted message.
auto payload = QString::fromLatin1(str.data(), static_cast<int>(str.size())); QString payload;
int color_range_start = static_cast<int>(msg.color_range_start);
int color_range_end = static_cast<int>(msg.color_range_end);
if (is_utf8_) {
payload = QString::fromUtf8(str.data(), static_cast<int>(str.size()));
// convert color ranges from byte index to character index.
if (msg.color_range_start < msg.color_range_end) {
color_range_start = QString::fromUtf8(str.data(), msg.color_range_start).size();
color_range_end = QString::fromUtf8(str.data(), msg.color_range_end).size();
}
} else {
payload = QString::fromLatin1(str.data(), static_cast<int>(str.size()));
}
invoke_params params{max_lines_, // max lines invoke_params params{max_lines_, // max lines
qt_text_edit_, // text edit to append to qt_text_edit_, // text edit to append to
std::move(payload), // text to append std::move(payload), // text to append
default_color_, // default color default_color_, // default color
colors_.at(msg.level), // color to apply colors_.at(msg.level), // color to apply
static_cast<int>(msg.color_range_start), // color range start color_range_start, // color range start
static_cast<int>(msg.color_range_end)}; // color range end color_range_end}; // color range end
QMetaObject::invokeMethod( QMetaObject::invokeMethod(
qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection); qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection);
@ -179,28 +182,25 @@ protected:
void flush_() override {} void flush_() override {}
// Add colored text to the text edit widget. This method is invoked in the GUI thread. // Add colored text to the text edit widget. This method is invoked in the GUI thread.
// It is a static method to ensure that it is handled correctly even if the sink is destroyed prematurely // It is a static method to ensure that it is handled correctly even if the sink is destroyed
// before it is invoked. // prematurely before it is invoked.
static void invoke_method_(invoke_params params) static void invoke_method_(invoke_params params) {
{
auto *document = params.q_text_edit->document(); auto *document = params.q_text_edit->document();
QTextCursor cursor(document); QTextCursor cursor(document);
// remove first blocks if number of blocks exceeds max_lines // remove first blocks if number of blocks exceeds max_lines
while (document->blockCount() > params.max_lines) while (document->blockCount() > params.max_lines) {
{
cursor.select(QTextCursor::BlockUnderCursor); cursor.select(QTextCursor::BlockUnderCursor);
cursor.removeSelectedText(); cursor.removeSelectedText();
cursor.deleteChar(); // delete the newline after the block cursor.deleteChar(); // delete the newline after the block
} }
cursor.movePosition(QTextCursor::End); cursor.movePosition(QTextCursor::End);
cursor.setCharFormat(params.default_color); cursor.setCharFormat(params.default_color);
// if color range not specified or not not valid, just append the text with default color // if color range not specified or not not valid, just append the text with default color
if (params.color_range_end <= params.color_range_start) if (params.color_range_end <= params.color_range_start) {
{
cursor.insertText(params.payload); cursor.insertText(params.payload);
return; return;
} }
@ -210,7 +210,8 @@ protected:
// insert the colorized text // insert the colorized text
cursor.setCharFormat(params.level_color); cursor.setCharFormat(params.level_color);
cursor.insertText(params.payload.mid(params.color_range_start, params.color_range_end - params.color_range_start)); cursor.insertText(params.payload.mid(params.color_range_start,
params.color_range_end - params.color_range_start));
// insert the text after the color range with default format // insert the text after the color range with default format
cursor.setCharFormat(params.default_color); cursor.setCharFormat(params.default_color);
@ -219,6 +220,7 @@ protected:
QTextEdit *qt_text_edit_; QTextEdit *qt_text_edit_;
int max_lines_; int max_lines_;
bool is_utf8_;
QTextCharFormat default_color_; QTextCharFormat default_color_;
std::array<QTextCharFormat, level::n_levels> colors_; std::array<QTextCharFormat, level::n_levels> colors_;
}; };
@ -230,63 +232,73 @@ using qt_sink_mt = qt_sink<std::mutex>;
using qt_sink_st = qt_sink<details::null_mutex>; using qt_sink_st = qt_sink<details::null_mutex>;
using qt_color_sink_mt = qt_color_sink<std::mutex>; using qt_color_sink_mt = qt_color_sink<std::mutex>;
using qt_color_sink_st = qt_color_sink<details::null_mutex>; using qt_color_sink_st = qt_color_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// Factory functions // Factory functions
// //
// log to QTextEdit // log to QTextEdit
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append") inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name,
{ QTextEdit *qt_object,
const std::string &meta_method = "append") {
return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append") inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
{ QTextEdit *qt_object,
const std::string &meta_method = "append") {
return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
} }
// log to QPlainTextEdit // log to QPlainTextEdit
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_logger_mt( inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name,
const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText") QPlainTextEdit *qt_object,
{ const std::string &meta_method = "appendPlainText") {
return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_logger_st( inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText") QPlainTextEdit *qt_object,
{ const std::string &meta_method = "appendPlainText") {
return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
} }
// log to QObject // log to QObject
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name,
{ QObject *qt_object,
const std::string &meta_method) {
return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
{ QObject *qt_object,
const std::string &meta_method) {
return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
} }
// log to QTextEdit with colorize output // log to QTextEdit with colorized output
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_color_logger_mt(const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines) inline std::shared_ptr<logger> qt_color_logger_mt(const std::string &logger_name,
{ QTextEdit *qt_text_edit,
return Factory::template create<sinks::qt_color_sink_mt>(logger_name, qt_text_edit, max_lines); int max_lines,
bool is_utf8 = false) {
return Factory::template create<sinks::qt_color_sink_mt>(logger_name, qt_text_edit, max_lines,
false, is_utf8);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_color_logger_st(const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines) inline std::shared_ptr<logger> qt_color_logger_st(const std::string &logger_name,
{ QTextEdit *qt_text_edit,
return Factory::template create<sinks::qt_color_sink_st>(logger_name, qt_text_edit, max_lines); int max_lines,
bool is_utf8 = false) {
return Factory::template create<sinks::qt_color_sink_st>(logger_name, qt_text_edit, max_lines,
false, is_utf8);
} }
} // namespace spdlog } // namespace spdlog

29
Tool/spdlog/include/spdlog/sinks/ringbuffer_sink.h
View File

@ -3,10 +3,10 @@
#pragma once #pragma once
#include "spdlog/sinks/base_sink.h"
#include "spdlog/details/circular_q.h" #include "spdlog/details/circular_q.h"
#include "spdlog/details/log_msg_buffer.h" #include "spdlog/details/log_msg_buffer.h"
#include "spdlog/details/null_mutex.h" #include "spdlog/details/null_mutex.h"
#include "spdlog/sinks/base_sink.h"
#include <mutex> #include <mutex>
#include <string> #include <string>
@ -17,37 +17,31 @@ namespace sinks {
/* /*
* Ring buffer sink * Ring buffer sink
*/ */
template<typename Mutex> template <typename Mutex>
class ringbuffer_sink final : public base_sink<Mutex> class ringbuffer_sink final : public base_sink<Mutex> {
{
public: public:
explicit ringbuffer_sink(size_t n_items) explicit ringbuffer_sink(size_t n_items)
: q_{n_items} : q_{n_items} {}
{}
std::vector<details::log_msg_buffer> last_raw(size_t lim = 0) std::vector<details::log_msg_buffer> last_raw(size_t lim = 0) {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
auto items_available = q_.size(); auto items_available = q_.size();
auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;
std::vector<details::log_msg_buffer> ret; std::vector<details::log_msg_buffer> ret;
ret.reserve(n_items); ret.reserve(n_items);
for (size_t i = (items_available - n_items); i < items_available; i++) for (size_t i = (items_available - n_items); i < items_available; i++) {
{
ret.push_back(q_.at(i)); ret.push_back(q_.at(i));
} }
return ret; return ret;
} }
std::vector<std::string> last_formatted(size_t lim = 0) std::vector<std::string> last_formatted(size_t lim = 0) {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
auto items_available = q_.size(); auto items_available = q_.size();
auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;
std::vector<std::string> ret; std::vector<std::string> ret;
ret.reserve(n_items); ret.reserve(n_items);
for (size_t i = (items_available - n_items); i < items_available; i++) for (size_t i = (items_available - n_items); i < items_available; i++) {
{
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(q_.at(i), formatted); base_sink<Mutex>::formatter_->format(q_.at(i), formatted);
ret.push_back(SPDLOG_BUF_TO_STRING(formatted)); ret.push_back(SPDLOG_BUF_TO_STRING(formatted));
@ -56,8 +50,7 @@ public:
} }
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
q_.push_back(details::log_msg_buffer{msg}); q_.push_back(details::log_msg_buffer{msg});
} }
void flush_() override {} void flush_() override {}
@ -69,6 +62,6 @@ private:
using ringbuffer_sink_mt = ringbuffer_sink<std::mutex>; using ringbuffer_sink_mt = ringbuffer_sink<std::mutex>;
using ringbuffer_sink_st = ringbuffer_sink<details::null_mutex>; using ringbuffer_sink_st = ringbuffer_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

102
Tool/spdlog/include/spdlog/sinks/rotating_file_sink-inl.h
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/sinks/rotating_file_sink.h> #include <spdlog/sinks/rotating_file_sink.h>
#endif #endif
#include <spdlog/common.h> #include <spdlog/common.h>
@ -23,27 +23,27 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink( SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open, const file_event_handlers &event_handlers) filename_t base_filename,
: base_filename_(std::move(base_filename)) std::size_t max_size,
, max_size_(max_size) std::size_t max_files,
, max_files_(max_files) bool rotate_on_open,
, file_helper_{event_handlers} const file_event_handlers &event_handlers)
{ : base_filename_(std::move(base_filename)),
if (max_size == 0) max_size_(max_size),
{ max_files_(max_files),
file_helper_{event_handlers} {
if (max_size == 0) {
throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero"); throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero");
} }
if (max_files > 200000) if (max_files > 200000) {
{
throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000"); throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000");
} }
file_helper_.open(calc_filename(base_filename_, 0)); file_helper_.open(calc_filename(base_filename_, 0));
current_size_ = file_helper_.size(); // expensive. called only once current_size_ = file_helper_.size(); // expensive. called only once
if (rotate_on_open && current_size_ > 0) if (rotate_on_open && current_size_ > 0) {
{
rotate_(); rotate_();
current_size_ = 0; current_size_ = 0;
} }
@ -51,29 +51,32 @@ SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
// calc filename according to index and file extension if exists. // calc filename according to index and file extension if exists.
// e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt".
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename, std::size_t index) SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename,
{ std::size_t index) {
if (index == 0u) if (index == 0u) {
{
return filename; return filename;
} }
filename_t basename, ext; filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename); std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
return fmt_lib::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext); return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}.{}{}")), basename, index, ext);
} }
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename() SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename() {
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return file_helper_.filename(); return file_helper_.filename();
} }
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg) SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_now() {
{ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
rotate_();
}
template <typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
auto new_size = current_size_ + formatted.size(); auto new_size = current_size_ + formatted.size();
@ -81,11 +84,9 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &m
// rotate if the new estimated file size exceeds max size. // rotate if the new estimated file size exceeds max size.
// rotate only if the real size > 0 to better deal with full disk (see issue #2261). // rotate only if the real size > 0 to better deal with full disk (see issue #2261).
// we only check the real size when new_size > max_size_ because it is relatively expensive. // we only check the real size when new_size > max_size_ because it is relatively expensive.
if (new_size > max_size_) if (new_size > max_size_) {
{
file_helper_.flush(); file_helper_.flush();
if (file_helper_.size() > 0) if (file_helper_.size() > 0) {
{
rotate_(); rotate_();
new_size = formatted.size(); new_size = formatted.size();
} }
@ -94,9 +95,8 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &m
current_size_ = new_size; current_size_ = new_size;
} }
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_() SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_() {
{
file_helper_.flush(); file_helper_.flush();
} }
@ -105,33 +105,31 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_()
// log.1.txt -> log.2.txt // log.1.txt -> log.2.txt
// log.2.txt -> log.3.txt // log.2.txt -> log.3.txt
// log.3.txt -> delete // log.3.txt -> delete
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_() SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_() {
{
using details::os::filename_to_str; using details::os::filename_to_str;
using details::os::path_exists; using details::os::path_exists;
file_helper_.close(); file_helper_.close();
for (auto i = max_files_; i > 0; --i) for (auto i = max_files_; i > 0; --i) {
{
filename_t src = calc_filename(base_filename_, i - 1); filename_t src = calc_filename(base_filename_, i - 1);
if (!path_exists(src)) if (!path_exists(src)) {
{
continue; continue;
} }
filename_t target = calc_filename(base_filename_, i); filename_t target = calc_filename(base_filename_, i);
if (!rename_file_(src, target)) if (!rename_file_(src, target)) {
{
// if failed try again after a small delay. // if failed try again after a small delay.
// this is a workaround to a windows issue, where very high rotation // this is a workaround to a windows issue, where very high rotation
// rates can cause the rename to fail with permission denied (because of antivirus?). // rates can cause the rename to fail with permission denied (because of antivirus?).
details::os::sleep_for_millis(100); details::os::sleep_for_millis(100);
if (!rename_file_(src, target)) if (!rename_file_(src, target)) {
{ file_helper_.reopen(
file_helper_.reopen(true); // truncate the log file anyway to prevent it to grow beyond its limit! true); // truncate the log file anyway to prevent it to grow beyond its limit!
current_size_ = 0; current_size_ = 0;
throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno); throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) +
" to " + filename_to_str(target),
errno);
} }
} }
} }
@ -140,13 +138,13 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_()
// delete the target if exists, and rename the src file to target // delete the target if exists, and rename the src file to target
// return true on success, false otherwise. // return true on success, false otherwise.
template<typename Mutex> template <typename Mutex>
SPDLOG_INLINE bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src_filename, const filename_t &target_filename) SPDLOG_INLINE bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src_filename,
{ const filename_t &target_filename) {
// try to delete the target file in case it already exists. // try to delete the target file in case it already exists.
(void)details::os::remove(target_filename); (void)details::os::remove(target_filename);
return details::os::rename(src_filename, target_filename) == 0; return details::os::rename(src_filename, target_filename) == 0;
} }
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

43
Tool/spdlog/include/spdlog/sinks/rotating_file_sink.h
View File

@ -3,10 +3,10 @@
#pragma once #pragma once
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/file_helper.h> #include <spdlog/details/file_helper.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h>
#include <chrono> #include <chrono>
#include <mutex> #include <mutex>
@ -18,14 +18,17 @@ namespace sinks {
// //
// Rotating file sink based on size // Rotating file sink based on size
// //
template<typename Mutex> template <typename Mutex>
class rotating_file_sink final : public base_sink<Mutex> class rotating_file_sink final : public base_sink<Mutex> {
{
public: public:
rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false, rotating_file_sink(filename_t base_filename,
const file_event_handlers &event_handlers = {}); std::size_t max_size,
std::size_t max_files,
bool rotate_on_open = false,
const file_event_handlers &event_handlers = {});
static filename_t calc_filename(const filename_t &filename, std::size_t index); static filename_t calc_filename(const filename_t &filename, std::size_t index);
filename_t filename(); filename_t filename();
void rotate_now();
protected: protected:
void sink_it_(const details::log_msg &msg) override; void sink_it_(const details::log_msg &msg) override;
@ -53,29 +56,35 @@ private:
using rotating_file_sink_mt = rotating_file_sink<std::mutex>; using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
using rotating_file_sink_st = rotating_file_sink<details::null_mutex>; using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> rotating_logger_mt(const std::string &logger_name, const filename_t &filename, size_t max_file_size, inline std::shared_ptr<logger> rotating_logger_mt(const std::string &logger_name,
size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {}) const filename_t &filename,
{ size_t max_file_size,
size_t max_files,
bool rotate_on_open = false,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::rotating_file_sink_mt>( return Factory::template create<sinks::rotating_file_sink_mt>(
logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name, const filename_t &filename, size_t max_file_size, inline std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name,
size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {}) const filename_t &filename,
{ size_t max_file_size,
size_t max_files,
bool rotate_on_open = false,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::rotating_file_sink_st>( return Factory::template create<sinks::rotating_file_sink_st>(
logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
} }
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "rotating_file_sink-inl.h" #include "rotating_file_sink-inl.h"
#endif #endif

11
Tool/spdlog/include/spdlog/sinks/sink-inl.h
View File

@ -4,22 +4,19 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/sinks/sink.h> #include <spdlog/sinks/sink.h>
#endif #endif
#include <spdlog/common.h> #include <spdlog/common.h>
SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const {
{
return msg_level >= level_.load(std::memory_order_relaxed); return msg_level >= level_.load(std::memory_order_relaxed);
} }
SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) {
{
level_.store(log_level, std::memory_order_relaxed); level_.store(log_level, std::memory_order_relaxed);
} }
SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const {
{
return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed)); return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
} }

9
Tool/spdlog/include/spdlog/sinks/sink.h
View File

@ -9,8 +9,7 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
class SPDLOG_API sink class SPDLOG_API sink {
{
public: public:
virtual ~sink() = default; virtual ~sink() = default;
virtual void log(const details::log_msg &msg) = 0; virtual void log(const details::log_msg &msg) = 0;
@ -27,9 +26,9 @@ protected:
level_t level_{level::trace}; level_t level_{level::trace};
}; };
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "sink-inl.h" #include "sink-inl.h"
#endif #endif

30
Tool/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h
View File

@ -4,35 +4,35 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/sinks/stdout_color_sinks.h> #include <spdlog/sinks/stdout_color_sinks.h>
#endif #endif
#include <spdlog/logger.h>
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/logger.h>
namespace spdlog { namespace spdlog {
template<typename Factory> template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode) SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name,
{ color_mode mode) {
return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode); return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode);
} }
template<typename Factory> template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode) SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name,
{ color_mode mode) {
return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode); return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode);
} }
template<typename Factory> template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode) SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name,
{ color_mode mode) {
return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode); return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode);
} }
template<typename Factory> template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode) SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
{ color_mode mode) {
return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode); return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
} }
} // namespace spdlog } // namespace spdlog

30
Tool/spdlog/include/spdlog/sinks/stdout_color_sinks.h
View File

@ -4,9 +4,9 @@
#pragma once #pragma once
#ifdef _WIN32 #ifdef _WIN32
# include <spdlog/sinks/wincolor_sink.h> #include <spdlog/sinks/wincolor_sink.h>
#else #else
# include <spdlog/sinks/ansicolor_sink.h> #include <spdlog/sinks/ansicolor_sink.h>
#endif #endif
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
@ -24,22 +24,26 @@ using stdout_color_sink_st = ansicolor_stdout_sink_st;
using stderr_color_sink_mt = ansicolor_stderr_sink_mt; using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
using stderr_color_sink_st = ansicolor_stderr_sink_st; using stderr_color_sink_st = ansicolor_stderr_sink_st;
#endif #endif
} // namespace sinks } // namespace sinks
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode = color_mode::automatic); std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name,
color_mode mode = color_mode::automatic);
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic); std::shared_ptr<logger> stdout_color_st(const std::string &logger_name,
color_mode mode = color_mode::automatic);
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode = color_mode::automatic); std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name,
color_mode mode = color_mode::automatic);
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic); std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
color_mode mode = color_mode::automatic);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "stdout_color_sinks-inl.h" #include "stdout_color_sinks-inl.h"
#endif #endif

107
Tool/spdlog/include/spdlog/sinks/stdout_sinks-inl.h
View File

@ -4,36 +4,36 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/sinks/stdout_sinks.h> #include <spdlog/sinks/stdout_sinks.h>
#endif #endif
#include <memory>
#include <spdlog/details/console_globals.h> #include <spdlog/details/console_globals.h>
#include <spdlog/pattern_formatter.h> #include <spdlog/pattern_formatter.h>
#include <memory> #include <spdlog/details/os.h>
#ifdef _WIN32 #ifdef _WIN32
// under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675) // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675)
// so instead we use ::FileWrite // so instead we use ::FileWrite
# include <spdlog/details/windows_include.h> #include <spdlog/details/windows_include.h>
# ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp
# include <fileapi.h> // WriteFile (..) #include <fileapi.h> // WriteFile (..)
# endif #endif
# include <io.h> // _get_osfhandle(..) #include <io.h> // _get_osfhandle(..)
# include <stdio.h> // _fileno(..) #include <stdio.h> // _fileno(..)
#endif // WIN32 #endif // _WIN32
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file) SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
: mutex_(ConsoleMutex::mutex()) : mutex_(ConsoleMutex::mutex()),
, file_(file) file_(file),
, formatter_(details::make_unique<spdlog::pattern_formatter>()) formatter_(details::make_unique<spdlog::pattern_formatter>()) {
{
#ifdef _WIN32 #ifdef _WIN32
// get windows handle from the FILE* object // get windows handle from the FILE* object
@ -42,19 +42,16 @@ SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
// don't throw to support cases where no console is attached, // don't throw to support cases where no console is attached,
// and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE). // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE).
// throw only if non stdout/stderr target is requested (probably regular file and not console). // throw only if non stdout/stderr target is requested (probably regular file and not console).
if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) {
{
throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno);
} }
#endif // WIN32 #endif // _WIN32
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg) SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg) {
{
#ifdef _WIN32 #ifdef _WIN32
if (handle_ == INVALID_HANDLE_VALUE) if (handle_ == INVALID_HANDLE_VALUE) {
{
return; return;
} }
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
@ -63,76 +60,68 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &m
auto size = static_cast<DWORD>(formatted.size()); auto size = static_cast<DWORD>(formatted.size());
DWORD bytes_written = 0; DWORD bytes_written = 0;
bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0; bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0;
if (!ok) if (!ok) {
{ throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " +
throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " + std::to_string(::GetLastError())); std::to_string(::GetLastError()));
} }
#else #else
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
memory_buf_t formatted; memory_buf_t formatted;
formatter_->format(msg, formatted); formatter_->format(msg, formatted);
::fwrite(formatted.data(), sizeof(char), formatted.size(), file_); details::os::fwrite_bytes(formatted.data(), formatted.size(), file_);
#endif // WIN32 #endif // _WIN32
::fflush(file_); // flush every line to terminal ::fflush(file_); // flush every line to terminal
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush() SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush() {
{
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
fflush(file_); fflush(file_);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern) SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern) {
{
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(
{ std::unique_ptr<spdlog::formatter> sink_formatter) {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
// stdout sink // stdout sink
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink() SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink()
: stdout_sink_base<ConsoleMutex>(stdout) : stdout_sink_base<ConsoleMutex>(stdout) {}
{}
// stderr sink // stderr sink
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink() SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
: stdout_sink_base<ConsoleMutex>(stderr) : stdout_sink_base<ConsoleMutex>(stderr) {}
{}
} // namespace sinks } // namespace sinks
// factory methods // factory methods
template<typename Factory> template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name) SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name) {
{
return Factory::template create<sinks::stdout_sink_mt>(logger_name); return Factory::template create<sinks::stdout_sink_mt>(logger_name);
} }
template<typename Factory> template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name) SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name) {
{
return Factory::template create<sinks::stdout_sink_st>(logger_name); return Factory::template create<sinks::stdout_sink_st>(logger_name);
} }
template<typename Factory> template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name) SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name) {
{
return Factory::template create<sinks::stderr_sink_mt>(logger_name); return Factory::template create<sinks::stderr_sink_mt>(logger_name);
} }
template<typename Factory> template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) {
{
return Factory::template create<sinks::stderr_sink_st>(logger_name); return Factory::template create<sinks::stderr_sink_st>(logger_name);
} }
} // namespace spdlog } // namespace spdlog

35
Tool/spdlog/include/spdlog/sinks/stdout_sinks.h
View File

@ -3,22 +3,21 @@
#pragma once #pragma once
#include <cstdio>
#include <spdlog/details/console_globals.h> #include <spdlog/details/console_globals.h>
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/sink.h> #include <spdlog/sinks/sink.h>
#include <cstdio>
#ifdef _WIN32 #ifdef _WIN32
# include <spdlog/details/windows_include.h> #include <spdlog/details/windows_include.h>
#endif #endif
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename ConsoleMutex> template <typename ConsoleMutex>
class stdout_sink_base : public sink class stdout_sink_base : public sink {
{
public: public:
using mutex_t = typename ConsoleMutex::mutex_t; using mutex_t = typename ConsoleMutex::mutex_t;
explicit stdout_sink_base(FILE *file); explicit stdout_sink_base(FILE *file);
@ -42,19 +41,17 @@ protected:
std::unique_ptr<spdlog::formatter> formatter_; std::unique_ptr<spdlog::formatter> formatter_;
#ifdef _WIN32 #ifdef _WIN32
HANDLE handle_; HANDLE handle_;
#endif // WIN32 #endif // WIN32
}; };
template<typename ConsoleMutex> template <typename ConsoleMutex>
class stdout_sink : public stdout_sink_base<ConsoleMutex> class stdout_sink : public stdout_sink_base<ConsoleMutex> {
{
public: public:
stdout_sink(); stdout_sink();
}; };
template<typename ConsoleMutex> template <typename ConsoleMutex>
class stderr_sink : public stdout_sink_base<ConsoleMutex> class stderr_sink : public stdout_sink_base<ConsoleMutex> {
{
public: public:
stderr_sink(); stderr_sink();
}; };
@ -65,23 +62,23 @@ using stdout_sink_st = stdout_sink<details::console_nullmutex>;
using stderr_sink_mt = stderr_sink<details::console_mutex>; using stderr_sink_mt = stderr_sink<details::console_mutex>;
using stderr_sink_st = stderr_sink<details::console_nullmutex>; using stderr_sink_st = stderr_sink<details::console_nullmutex>;
} // namespace sinks } // namespace sinks
// factory methods // factory methods
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name); std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name);
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name); std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name);
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name); std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name);
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name); std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "stdout_sinks-inl.h" #include "stdout_sinks-inl.h"
#endif #endif

93
Tool/spdlog/include/spdlog/sinks/syslog_sink.h
View File

@ -3,9 +3,9 @@
#pragma once #pragma once
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h>
#include <array> #include <array>
#include <string> #include <string>
@ -16,53 +16,42 @@ namespace sinks {
/** /**
* Sink that write to syslog using the `syscall()` library call. * Sink that write to syslog using the `syscall()` library call.
*/ */
template<typename Mutex> template <typename Mutex>
class syslog_sink : public base_sink<Mutex> class syslog_sink : public base_sink<Mutex> {
{
public: public:
syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting) syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting)
: enable_formatting_{enable_formatting} : enable_formatting_{enable_formatting},
, syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG,
/* spdlog::level::debug */ LOG_DEBUG, /* spdlog::level::debug */ LOG_DEBUG,
/* spdlog::level::info */ LOG_INFO, /* spdlog::level::info */ LOG_INFO,
/* spdlog::level::warn */ LOG_WARNING, /* spdlog::level::warn */ LOG_WARNING,
/* spdlog::level::err */ LOG_ERR, /* spdlog::level::err */ LOG_ERR,
/* spdlog::level::critical */ LOG_CRIT, /* spdlog::level::critical */ LOG_CRIT,
/* spdlog::level::off */ LOG_INFO}} /* spdlog::level::off */ LOG_INFO}},
, ident_{std::move(ident)} ident_{std::move(ident)} {
{
// set ident to be program name if empty // set ident to be program name if empty
::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility); ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility);
} }
~syslog_sink() override ~syslog_sink() override { ::closelog(); }
{
::closelog();
}
syslog_sink(const syslog_sink &) = delete; syslog_sink(const syslog_sink &) = delete;
syslog_sink &operator=(const syslog_sink &) = delete; syslog_sink &operator=(const syslog_sink &) = delete;
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
string_view_t payload; string_view_t payload;
memory_buf_t formatted; memory_buf_t formatted;
if (enable_formatting_) if (enable_formatting_) {
{
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
payload = string_view_t(formatted.data(), formatted.size()); payload = string_view_t(formatted.data(), formatted.size());
} } else {
else
{
payload = msg.payload; payload = msg.payload;
} }
size_t length = payload.size(); size_t length = payload.size();
// limit to max int // limit to max int
if (length > static_cast<size_t>(std::numeric_limits<int>::max())) if (length > static_cast<size_t>(std::numeric_limits<int>::max())) {
{
length = static_cast<size_t>(std::numeric_limits<int>::max()); length = static_cast<size_t>(std::numeric_limits<int>::max());
} }
@ -72,38 +61,44 @@ protected:
void flush_() override {} void flush_() override {}
bool enable_formatting_ = false; bool enable_formatting_ = false;
private:
using levels_array = std::array<int, 7>;
levels_array syslog_levels_;
// 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. // Simply maps spdlog's log level to syslog priority level.
// //
int syslog_prio_from_level(const details::log_msg &msg) const virtual int syslog_prio_from_level(const details::log_msg &msg) const {
{
return syslog_levels_.at(static_cast<levels_array::size_type>(msg.level)); return syslog_levels_.at(static_cast<levels_array::size_type>(msg.level));
} }
using levels_array = std::array<int, 7>;
levels_array syslog_levels_;
private:
// must store the ident because the man says openlog might use the pointer as
// is and not a string copy
const std::string ident_;
}; };
using syslog_sink_mt = syslog_sink<std::mutex>; using syslog_sink_mt = syslog_sink<std::mutex>;
using syslog_sink_st = syslog_sink<details::null_mutex>; using syslog_sink_st = syslog_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// Create and register a syslog logger // Create and register a syslog logger
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> syslog_logger_mt(const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, inline std::shared_ptr<logger> syslog_logger_mt(const std::string &logger_name,
int syslog_facility = LOG_USER, bool enable_formatting = false) const std::string &syslog_ident = "",
{ int syslog_option = 0,
return Factory::template create<sinks::syslog_sink_mt>(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); int syslog_facility = LOG_USER,
bool enable_formatting = false) {
return Factory::template create<sinks::syslog_sink_mt>(logger_name, syslog_ident, syslog_option,
syslog_facility, enable_formatting);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> syslog_logger_st(const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, inline std::shared_ptr<logger> syslog_logger_st(const std::string &logger_name,
int syslog_facility = LOG_USER, bool enable_formatting = false) const std::string &syslog_ident = "",
{ int syslog_option = 0,
return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); int syslog_facility = LOG_USER,
bool enable_formatting = false) {
return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option,
syslog_facility, enable_formatting);
} }
} // namespace spdlog } // namespace spdlog

97
Tool/spdlog/include/spdlog/sinks/systemd_sink.h
View File

@ -3,14 +3,14 @@
#pragma once #pragma once
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/os.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/os.h>
#include <spdlog/details/synchronous_factory.h> #include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h>
#include <array> #include <array>
#ifndef SD_JOURNAL_SUPPRESS_LOCATION #ifndef SD_JOURNAL_SUPPRESS_LOCATION
# define SD_JOURNAL_SUPPRESS_LOCATION #define SD_JOURNAL_SUPPRESS_LOCATION
#endif #endif
#include <systemd/sd-journal.h> #include <systemd/sd-journal.h>
@ -20,21 +20,19 @@ namespace sinks {
/** /**
* Sink that write to systemd journal using the `sd_journal_send()` library call. * Sink that write to systemd journal using the `sd_journal_send()` library call.
*/ */
template<typename Mutex> template <typename Mutex>
class systemd_sink : public base_sink<Mutex> class systemd_sink : public base_sink<Mutex> {
{
public: public:
systemd_sink(std::string ident = "", bool enable_formatting = false) systemd_sink(std::string ident = "", bool enable_formatting = false)
: ident_{std::move(ident)} : ident_{std::move(ident)},
, enable_formatting_{enable_formatting} enable_formatting_{enable_formatting},
, syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG,
/* spdlog::level::debug */ LOG_DEBUG, /* spdlog::level::debug */ LOG_DEBUG,
/* spdlog::level::info */ LOG_INFO, /* spdlog::level::info */ LOG_INFO,
/* spdlog::level::warn */ LOG_WARNING, /* spdlog::level::warn */ LOG_WARNING,
/* spdlog::level::err */ LOG_ERR, /* spdlog::level::err */ LOG_ERR,
/* spdlog::level::critical */ LOG_CRIT, /* spdlog::level::critical */ LOG_CRIT,
/* spdlog::level::off */ LOG_INFO}} /* spdlog::level::off */ LOG_INFO}} {}
{}
~systemd_sink() override {} ~systemd_sink() override {}
@ -47,58 +45,55 @@ protected:
using levels_array = std::array<int, 7>; using levels_array = std::array<int, 7>;
levels_array syslog_levels_; levels_array syslog_levels_;
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
int err; int err;
string_view_t payload; string_view_t payload;
memory_buf_t formatted; memory_buf_t formatted;
if (enable_formatting_) if (enable_formatting_) {
{
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
payload = string_view_t(formatted.data(), formatted.size()); payload = string_view_t(formatted.data(), formatted.size());
} } else {
else
{
payload = msg.payload; payload = msg.payload;
} }
size_t length = payload.size(); size_t length = payload.size();
// limit to max int // limit to max int
if (length > static_cast<size_t>(std::numeric_limits<int>::max())) if (length > static_cast<size_t>(std::numeric_limits<int>::max())) {
{
length = static_cast<size_t>(std::numeric_limits<int>::max()); length = static_cast<size_t>(std::numeric_limits<int>::max());
} }
const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_; const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_;
// Do not send source location if not available // Do not send source location if not available
if (msg.source.empty()) if (msg.source.empty()) {
{
// Note: function call inside '()' to avoid macro expansion // Note: function call inside '()' to avoid macro expansion
err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level), err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(),
"PRIORITY=%d", syslog_level(msg.level),
#ifndef SPDLOG_NO_THREAD_ID #ifndef SPDLOG_NO_THREAD_ID
"TID=%zu", details::os::thread_id(), "TID=%zu", msg.thread_id,
#endif #endif
"SYSLOG_IDENTIFIER=%.*s", static_cast<int>(syslog_identifier.size()), syslog_identifier.data(), nullptr); "SYSLOG_IDENTIFIER=%.*s",
} static_cast<int>(syslog_identifier.size()),
else syslog_identifier.data(), nullptr);
{ } else {
err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level), err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(),
"PRIORITY=%d", syslog_level(msg.level),
#ifndef SPDLOG_NO_THREAD_ID #ifndef SPDLOG_NO_THREAD_ID
"TID=%zu", details::os::thread_id(), "TID=%zu", msg.thread_id,
#endif #endif
"SYSLOG_IDENTIFIER=%.*s", static_cast<int>(syslog_identifier.size()), syslog_identifier.data(), "CODE_FILE=%s", "SYSLOG_IDENTIFIER=%.*s",
msg.source.filename, "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s", msg.source.funcname, nullptr); static_cast<int>(syslog_identifier.size()),
syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename,
"CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s",
msg.source.funcname, nullptr);
} }
if (err) if (err) {
{
throw_spdlog_ex("Failed writing to systemd", errno); throw_spdlog_ex("Failed writing to systemd", errno);
} }
} }
int syslog_level(level::level_enum l) int syslog_level(level::level_enum l) {
{
return syslog_levels_.at(static_cast<levels_array::size_type>(l)); return syslog_levels_.at(static_cast<levels_array::size_type>(l));
} }
@ -107,20 +102,20 @@ protected:
using systemd_sink_mt = systemd_sink<std::mutex>; using systemd_sink_mt = systemd_sink<std::mutex>;
using systemd_sink_st = systemd_sink<details::null_mutex>; using systemd_sink_st = systemd_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// Create and register a syslog logger // Create and register a syslog logger
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> systemd_logger_mt( inline std::shared_ptr<logger> systemd_logger_mt(const std::string &logger_name,
const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false) const std::string &ident = "",
{ bool enable_formatting = false) {
return Factory::template create<sinks::systemd_sink_mt>(logger_name, ident, enable_formatting); return Factory::template create<sinks::systemd_sink_mt>(logger_name, ident, enable_formatting);
} }
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> systemd_logger_st( inline std::shared_ptr<logger> systemd_logger_st(const std::string &logger_name,
const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false) const std::string &ident = "",
{ bool enable_formatting = false) {
return Factory::template create<sinks::systemd_sink_st>(logger_name, ident, enable_formatting); return Factory::template create<sinks::systemd_sink_st>(logger_name, ident, enable_formatting);
} }
} // namespace spdlog } // namespace spdlog

44
Tool/spdlog/include/spdlog/sinks/tcp_sink.h
View File

@ -4,53 +4,49 @@
#pragma once #pragma once
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/base_sink.h>
#ifdef _WIN32 #ifdef _WIN32
# include <spdlog/details/tcp_client-windows.h> #include <spdlog/details/tcp_client-windows.h>
#else #else
# include <spdlog/details/tcp_client.h> #include <spdlog/details/tcp_client.h>
#endif #endif
#include <mutex>
#include <string>
#include <chrono> #include <chrono>
#include <functional> #include <functional>
#include <mutex>
#include <string>
#pragma once #pragma once
// Simple tcp client sink // Simple tcp client sink
// Connects to remote address and send the formatted log. // Connects to remote address and send the formatted log.
// Will attempt to reconnect if connection drops. // Will attempt to reconnect if connection drops.
// If more complicated behaviour is needed (i.e get responses), you can inherit it and override the sink_it_ method. // If more complicated behaviour is needed (i.e get responses), you can inherit it and override the
// sink_it_ method.
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
struct tcp_sink_config struct tcp_sink_config {
{
std::string server_host; std::string server_host;
int server_port; int server_port;
bool lazy_connect = false; // if true connect on first log call instead of on construction bool lazy_connect = false; // if true connect on first log call instead of on construction
tcp_sink_config(std::string host, int port) tcp_sink_config(std::string host, int port)
: server_host{std::move(host)} : server_host{std::move(host)},
, server_port{port} server_port{port} {}
{}
}; };
template<typename Mutex> template <typename Mutex>
class tcp_sink : public spdlog::sinks::base_sink<Mutex> class tcp_sink : public spdlog::sinks::base_sink<Mutex> {
{
public: public:
// connect to tcp host/port or throw if failed // connect to tcp host/port or throw if failed
// host can be hostname or ip address // host can be hostname or ip address
explicit tcp_sink(tcp_sink_config sink_config) explicit tcp_sink(tcp_sink_config sink_config)
: config_{std::move(sink_config)} : config_{std::move(sink_config)} {
{ if (!config_.lazy_connect) {
if (!config_.lazy_connect)
{
this->client_.connect(config_.server_host, config_.server_port); this->client_.connect(config_.server_host, config_.server_port);
} }
} }
@ -58,12 +54,10 @@ public:
~tcp_sink() override = default; ~tcp_sink() override = default;
protected: protected:
void sink_it_(const spdlog::details::log_msg &msg) override void sink_it_(const spdlog::details::log_msg &msg) override {
{
spdlog::memory_buf_t formatted; spdlog::memory_buf_t formatted;
spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted); spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
if (!client_.is_connected()) if (!client_.is_connected()) {
{
client_.connect(config_.server_host, config_.server_port); client_.connect(config_.server_host, config_.server_port);
} }
client_.send(formatted.data(), formatted.size()); client_.send(formatted.data(), formatted.size());
@ -77,5 +71,5 @@ protected:
using tcp_sink_mt = tcp_sink<std::mutex>; using tcp_sink_mt = tcp_sink<std::mutex>;
using tcp_sink_st = tcp_sink<spdlog::details::null_mutex>; using tcp_sink_st = tcp_sink<spdlog::details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

39
Tool/spdlog/include/spdlog/sinks/udp_sink.h
View File

@ -4,18 +4,18 @@
#pragma once #pragma once
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/sinks/base_sink.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/base_sink.h>
#ifdef _WIN32 #ifdef _WIN32
# include <spdlog/details/udp_client-windows.h> #include <spdlog/details/udp_client-windows.h>
#else #else
# include <spdlog/details/udp_client.h> #include <spdlog/details/udp_client.h>
#endif #endif
#include <mutex>
#include <string>
#include <chrono> #include <chrono>
#include <functional> #include <functional>
#include <mutex>
#include <string>
// Simple udp client sink // Simple udp client sink
// Sends formatted log via udp // Sends formatted log via udp
@ -23,31 +23,26 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
struct udp_sink_config struct udp_sink_config {
{
std::string server_host; std::string server_host;
uint16_t server_port; uint16_t server_port;
udp_sink_config(std::string host, uint16_t port) udp_sink_config(std::string host, uint16_t port)
: server_host{std::move(host)} : server_host{std::move(host)},
, server_port{port} server_port{port} {}
{}
}; };
template<typename Mutex> template <typename Mutex>
class udp_sink : public spdlog::sinks::base_sink<Mutex> class udp_sink : public spdlog::sinks::base_sink<Mutex> {
{
public: public:
// host can be hostname or ip address // host can be hostname or ip address
explicit udp_sink(udp_sink_config sink_config) explicit udp_sink(udp_sink_config sink_config)
: client_{sink_config.server_host, sink_config.server_port} : client_{sink_config.server_host, sink_config.server_port} {}
{}
~udp_sink() override = default; ~udp_sink() override = default;
protected: protected:
void sink_it_(const spdlog::details::log_msg &msg) override void sink_it_(const spdlog::details::log_msg &msg) override {
{
spdlog::memory_buf_t formatted; spdlog::memory_buf_t formatted;
spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted); spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
client_.send(formatted.data(), formatted.size()); client_.send(formatted.data(), formatted.size());
@ -60,15 +55,15 @@ protected:
using udp_sink_mt = udp_sink<std::mutex>; using udp_sink_mt = udp_sink<std::mutex>;
using udp_sink_st = udp_sink<spdlog::details::null_mutex>; using udp_sink_st = udp_sink<spdlog::details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> udp_logger_mt(const std::string &logger_name, sinks::udp_sink_config skin_config) inline std::shared_ptr<logger> udp_logger_mt(const std::string &logger_name,
{ sinks::udp_sink_config skin_config) {
return Factory::template create<sinks::udp_sink_mt>(logger_name, skin_config); return Factory::template create<sinks::udp_sink_mt>(logger_name, skin_config);
} }
} // namespace spdlog } // namespace spdlog

189
Tool/spdlog/include/spdlog/sinks/win_eventlog_sink.h
View File

@ -1,17 +1,20 @@
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT) // Distributed under the MIT License (http://opensource.org/licenses/MIT)
// Writing to Windows Event Log requires the registry entries below to be present, with the following modifications: // Writing to Windows Event Log requires the registry entries below to be present, with the
// following modifications:
// 1. <log_name> should be replaced with your log name (e.g. your application name) // 1. <log_name> should be replaced with your log name (e.g. your application name)
// 2. <source_name> should be replaced with the specific source name and the key should be duplicated for // 2. <source_name> should be replaced with the specific source name and the key should be
// duplicated for
// each source used in the application // each source used in the application
// //
// Since typically modifications of this kind require elevation, it's better to do it as a part of setup procedure. // Since typically modifications of this kind require elevation, it's better to do it as a part of
// The snippet below uses mscoree.dll as the message file as it exists on most of the Windows systems anyway and // setup procedure. The snippet below uses mscoree.dll as the message file as it exists on most of
// happens to contain the needed resource. // the Windows systems anyway and happens to contain the needed resource.
// //
// You can also specify a custom message file if needed. // You can also specify a custom message file if needed.
// Please refer to Event Log functions descriptions in MSDN for more details on custom message files. // Please refer to Event Log functions descriptions in MSDN for more details on custom message
// files.
/*--------------------------------------------------------------------------------------- /*---------------------------------------------------------------------------------------
@ -47,8 +50,7 @@ namespace win_eventlog {
namespace internal { namespace internal {
struct local_alloc_t struct local_alloc_t {
{
HLOCAL hlocal_; HLOCAL hlocal_;
SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {} SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {}
@ -56,30 +58,27 @@ struct local_alloc_t
local_alloc_t(local_alloc_t const &) = delete; local_alloc_t(local_alloc_t const &) = delete;
local_alloc_t &operator=(local_alloc_t const &) = delete; local_alloc_t &operator=(local_alloc_t const &) = delete;
~local_alloc_t() SPDLOG_NOEXCEPT ~local_alloc_t() SPDLOG_NOEXCEPT {
{ if (hlocal_) {
if (hlocal_)
{
LocalFree(hlocal_); LocalFree(hlocal_);
} }
} }
}; };
/** Windows error */ /** Windows error */
struct win32_error : public spdlog_ex struct win32_error : public spdlog_ex {
{
/** Formats an error report line: "user-message: error-code (system message)" */ /** Formats an error report line: "user-message: error-code (system message)" */
static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) {
{
std::string system_message; std::string system_message;
local_alloc_t format_message_result{}; local_alloc_t format_message_result{};
auto format_message_succeeded = auto format_message_succeeded =
::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&format_message_result.hlocal_, 0, nullptr); FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR)&format_message_result.hlocal_, 0, nullptr);
if (format_message_succeeded && format_message_result.hlocal_) if (format_message_succeeded && format_message_result.hlocal_) {
{
system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_); system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_);
} }
@ -87,23 +86,19 @@ struct win32_error : public spdlog_ex
} }
explicit win32_error(std::string const &func_name, DWORD error = GetLastError()) explicit win32_error(std::string const &func_name, DWORD error = GetLastError())
: spdlog_ex(format(func_name, error)) : spdlog_ex(format(func_name, error)) {}
{}
}; };
/** Wrapper for security identifiers (SID) on Windows */ /** Wrapper for security identifiers (SID) on Windows */
struct sid_t struct sid_t {
{
std::vector<char> buffer_; std::vector<char> buffer_;
public: public:
sid_t() {} sid_t() {}
/** creates a wrapped SID copy */ /** creates a wrapped SID copy */
static sid_t duplicate_sid(PSID psid) static sid_t duplicate_sid(PSID psid) {
{ if (!::IsValidSid(psid)) {
if (!::IsValidSid(psid))
{
throw_spdlog_ex("sid_t::sid_t(): invalid SID received"); throw_spdlog_ex("sid_t::sid_t(): invalid SID received");
} }
@ -111,8 +106,7 @@ public:
sid_t result; sid_t result;
result.buffer_.resize(sid_length); result.buffer_.resize(sid_length);
if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) {
{
SPDLOG_THROW(win32_error("CopySid")); SPDLOG_THROW(win32_error("CopySid"));
} }
@ -120,44 +114,36 @@ public:
} }
/** Retrieves pointer to the internal buffer contents as SID* */ /** Retrieves pointer to the internal buffer contents as SID* */
SID *as_sid() const SID *as_sid() const { return buffer_.empty() ? nullptr : (SID *)buffer_.data(); }
{
return buffer_.empty() ? nullptr : (SID *)buffer_.data();
}
/** Get SID for the current user */ /** Get SID for the current user */
static sid_t get_current_user_sid() static sid_t get_current_user_sid() {
{
/* create and init RAII holder for process token */ /* create and init RAII holder for process token */
struct process_token_t struct process_token_t {
{
HANDLE token_handle_ = INVALID_HANDLE_VALUE; HANDLE token_handle_ = INVALID_HANDLE_VALUE;
explicit process_token_t(HANDLE process) explicit process_token_t(HANDLE process) {
{ if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) {
if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_))
{
SPDLOG_THROW(win32_error("OpenProcessToken")); SPDLOG_THROW(win32_error("OpenProcessToken"));
} }
} }
~process_token_t() ~process_token_t() { ::CloseHandle(token_handle_); }
{
::CloseHandle(token_handle_);
}
} current_process_token(::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here! } current_process_token(
::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here!
// Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return the token size // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return
// the token size
DWORD tusize = 0; DWORD tusize = 0;
if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, &tusize)) if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0,
{ &tusize)) {
SPDLOG_THROW(win32_error("GetTokenInformation should fail")); SPDLOG_THROW(win32_error("GetTokenInformation should fail"));
} }
// get user token // get user token
std::vector<unsigned char> buffer(static_cast<size_t>(tusize)); std::vector<unsigned char> buffer(static_cast<size_t>(tusize));
if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser, (LPVOID)buffer.data(), tusize, &tusize)) if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser,
{ (LPVOID)buffer.data(), tusize, &tusize)) {
SPDLOG_THROW(win32_error("GetTokenInformation")); SPDLOG_THROW(win32_error("GetTokenInformation"));
} }
@ -166,59 +152,49 @@ public:
} }
}; };
struct eventlog struct eventlog {
{ static WORD get_event_type(details::log_msg const &msg) {
static WORD get_event_type(details::log_msg const &msg) switch (msg.level) {
{ case level::trace:
switch (msg.level) case level::debug:
{ return EVENTLOG_SUCCESS;
case level::trace:
case level::debug:
return EVENTLOG_SUCCESS;
case level::info: case level::info:
return EVENTLOG_INFORMATION_TYPE; return EVENTLOG_INFORMATION_TYPE;
case level::warn: case level::warn:
return EVENTLOG_WARNING_TYPE; return EVENTLOG_WARNING_TYPE;
case level::err: case level::err:
case level::critical: case level::critical:
case level::off: case level::off:
return EVENTLOG_ERROR_TYPE; return EVENTLOG_ERROR_TYPE;
default: default:
return EVENTLOG_INFORMATION_TYPE; return EVENTLOG_INFORMATION_TYPE;
} }
} }
static WORD get_event_category(details::log_msg const &msg) static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; }
{
return (WORD)msg.level;
}
}; };
} // namespace internal } // namespace internal
/* /*
* Windows Event Log sink * Windows Event Log sink
*/ */
template<typename Mutex> template <typename Mutex>
class win_eventlog_sink : public base_sink<Mutex> class win_eventlog_sink : public base_sink<Mutex> {
{
private: private:
HANDLE hEventLog_{NULL}; HANDLE hEventLog_{NULL};
internal::sid_t current_user_sid_; internal::sid_t current_user_sid_;
std::string source_; std::string source_;
DWORD event_id_; DWORD event_id_;
HANDLE event_log_handle() HANDLE event_log_handle() {
{ if (!hEventLog_) {
if (!hEventLog_)
{
hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str()); hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str());
if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) {
{
SPDLOG_THROW(internal::win32_error("RegisterEventSource")); SPDLOG_THROW(internal::win32_error("RegisterEventSource"));
} }
} }
@ -227,8 +203,7 @@ private:
} }
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override {
{
using namespace internal; using namespace internal;
bool succeeded; bool succeeded;
@ -241,16 +216,17 @@ protected:
details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf); details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf);
LPCWSTR lp_wstr = buf.data(); LPCWSTR lp_wstr = buf.data();
succeeded = static_cast<bool>(::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), succeeded = static_cast<bool>(::ReportEventW(
event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),
event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr)); event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr));
#else #else
LPCSTR lp_str = formatted.data(); LPCSTR lp_str = formatted.data();
succeeded = static_cast<bool>(::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), succeeded = static_cast<bool>(::ReportEventA(
event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),
event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr)); event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr));
#endif #endif
if (!succeeded) if (!succeeded) {
{
SPDLOG_THROW(win32_error("ReportEvent")); SPDLOG_THROW(win32_error("ReportEvent"));
} }
} }
@ -258,32 +234,27 @@ protected:
void flush_() override {} void flush_() override {}
public: public:
win_eventlog_sink(std::string const &source, DWORD event_id = 1000 /* according to mscoree.dll */) win_eventlog_sink(std::string const &source,
: source_(source) DWORD event_id = 1000 /* according to mscoree.dll */)
, event_id_(event_id) : source_(source),
{ event_id_(event_id) {
try try {
{
current_user_sid_ = internal::sid_t::get_current_user_sid(); current_user_sid_ = internal::sid_t::get_current_user_sid();
} } catch (...) {
catch (...) // get_current_user_sid() is unlikely to fail and if it does, we can still proceed
{ // without current_user_sid but in the event log the record will have no user name
// get_current_user_sid() is unlikely to fail and if it does, we can still proceed without
// current_user_sid but in the event log the record will have no user name
} }
} }
~win_eventlog_sink() ~win_eventlog_sink() {
{ if (hEventLog_) DeregisterEventSource(hEventLog_);
if (hEventLog_)
DeregisterEventSource(hEventLog_);
} }
}; };
} // namespace win_eventlog } // namespace win_eventlog
using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink<std::mutex>; using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink<std::mutex>;
using win_eventlog_sink_st = win_eventlog::win_eventlog_sink<details::null_mutex>; using win_eventlog_sink_st = win_eventlog::win_eventlog_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

147
Tool/spdlog/include/spdlog/sinks/wincolor_sink-inl.h
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#ifndef SPDLOG_HEADER_ONLY #ifndef SPDLOG_HEADER_ONLY
# include <spdlog/sinks/wincolor_sink.h> #include <spdlog/sinks/wincolor_sink.h>
#endif #endif
#include <spdlog/details/windows_include.h> #include <spdlog/details/windows_include.h>
@ -15,44 +15,41 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color_mode mode) SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color_mode mode)
: out_handle_(out_handle) : out_handle_(out_handle),
, mutex_(ConsoleMutex::mutex()) mutex_(ConsoleMutex::mutex()),
, formatter_(details::make_unique<spdlog::pattern_formatter>()) formatter_(details::make_unique<spdlog::pattern_formatter>()) {
{
set_color_mode_impl(mode); set_color_mode_impl(mode);
// set level colors // set level colors
colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white
colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan
colors_[level::info] = FOREGROUND_GREEN; // green colors_[level::info] = FOREGROUND_GREEN; // green
colors_[level::warn] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow colors_[level::warn] =
colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow
colors_[level::critical] = colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red
BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY; // intense white on red background colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN |
FOREGROUND_BLUE |
FOREGROUND_INTENSITY; // intense white on red background
colors_[level::off] = 0; colors_[level::off] = 0;
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE wincolor_sink<ConsoleMutex>::~wincolor_sink() SPDLOG_INLINE wincolor_sink<ConsoleMutex>::~wincolor_sink() {
{
this->flush(); this->flush();
} }
// change the color for the given level // change the color for the given level
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color(level::level_enum level, std::uint16_t color) void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color(level::level_enum level,
{ std::uint16_t color) {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
colors_[static_cast<size_t>(level)] = color; colors_[static_cast<size_t>(level)] = color;
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg) void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg) {
{ if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) {
if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE)
{
return; return;
} }
@ -61,115 +58,115 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
msg.color_range_end = 0; msg.color_range_end = 0;
memory_buf_t formatted; memory_buf_t formatted;
formatter_->format(msg, formatted); formatter_->format(msg, formatted);
if (should_do_colors_ && msg.color_range_end > msg.color_range_start) if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {
{
// before color range // before color range
print_range_(formatted, 0, msg.color_range_start); print_range_(formatted, 0, msg.color_range_start);
// in color range // in color range
auto orig_attribs = static_cast<WORD>(set_foreground_color_(colors_[static_cast<size_t>(msg.level)])); auto orig_attribs =
static_cast<WORD>(set_foreground_color_(colors_[static_cast<size_t>(msg.level)]));
print_range_(formatted, msg.color_range_start, msg.color_range_end); print_range_(formatted, msg.color_range_start, msg.color_range_end);
// reset to orig colors // reset to orig colors
::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), orig_attribs); ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), orig_attribs);
print_range_(formatted, msg.color_range_end, formatted.size()); print_range_(formatted, msg.color_range_end, formatted.size());
} } else // print without colors if color range is invalid (or color is disabled)
else // print without colors if color range is invalid (or color is disabled)
{ {
write_to_file_(formatted); write_to_file_(formatted);
} }
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::flush() void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::flush() {
{
// windows console always flushed? // windows console always flushed?
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) {
{
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) void SPDLOG_INLINE
{ wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
{
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
set_color_mode_impl(mode); set_color_mode_impl(mode);
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode_impl(color_mode mode) void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode_impl(color_mode mode) {
{ if (mode == color_mode::automatic) {
if (mode == color_mode::automatic)
{
// should do colors only if out_handle_ points to actual console. // should do colors only if out_handle_ points to actual console.
DWORD console_mode; DWORD console_mode;
bool in_console = ::GetConsoleMode(static_cast<HANDLE>(out_handle_), &console_mode) != 0; bool in_console = ::GetConsoleMode(static_cast<HANDLE>(out_handle_), &console_mode) != 0;
should_do_colors_ = in_console; should_do_colors_ = in_console;
} } else {
else
{
should_do_colors_ = mode == color_mode::always ? true : false; should_do_colors_ = mode == color_mode::always ? true : false;
} }
} }
// set foreground color and return the orig console attributes (for resetting later) // set foreground color and return the orig console attributes (for resetting later)
template<typename ConsoleMutex> template <typename ConsoleMutex>
std::uint16_t SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_foreground_color_(std::uint16_t attribs) std::uint16_t SPDLOG_INLINE
{ wincolor_sink<ConsoleMutex>::set_foreground_color_(std::uint16_t attribs) {
CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
if (!::GetConsoleScreenBufferInfo(static_cast<HANDLE>(out_handle_), &orig_buffer_info)) if (!::GetConsoleScreenBufferInfo(static_cast<HANDLE>(out_handle_), &orig_buffer_info)) {
{
// just return white if failed getting console info // just return white if failed getting console info
return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
} }
// change only the foreground bits (lowest 4 bits) // change only the foreground bits (lowest 4 bits)
auto new_attribs = static_cast<WORD>(attribs) | (orig_buffer_info.wAttributes & 0xfff0); auto new_attribs = static_cast<WORD>(attribs) | (orig_buffer_info.wAttributes & 0xfff0);
auto ignored = ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), static_cast<WORD>(new_attribs)); auto ignored =
::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), static_cast<WORD>(new_attribs));
(void)(ignored); (void)(ignored);
return static_cast<std::uint16_t>(orig_buffer_info.wAttributes); // return orig attribs return static_cast<std::uint16_t>(orig_buffer_info.wAttributes); // return orig attribs
} }
// print a range of formatted message to console // print a range of formatted message to console
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end) void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted,
{ size_t start,
if (end > start) size_t end) {
{ if (end > start) {
#if defined(SPDLOG_UTF8_TO_WCHAR_CONSOLE)
wmemory_buf_t wformatted;
details::os::utf8_to_wstrbuf(string_view_t(formatted.data() + start, end - start),
wformatted);
auto size = static_cast<DWORD>(wformatted.size());
auto ignored = ::WriteConsoleW(static_cast<HANDLE>(out_handle_), wformatted.data(), size,
nullptr, nullptr);
#else
auto size = static_cast<DWORD>(end - start); auto size = static_cast<DWORD>(end - start);
auto ignored = ::WriteConsoleA(static_cast<HANDLE>(out_handle_), formatted.data() + start, size, nullptr, nullptr); auto ignored = ::WriteConsoleA(static_cast<HANDLE>(out_handle_), formatted.data() + start,
size, nullptr, nullptr);
#endif
(void)(ignored); (void)(ignored);
} }
} }
template<typename ConsoleMutex> template <typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_t &formatted) void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_t &formatted) {
{
auto size = static_cast<DWORD>(formatted.size()); auto size = static_cast<DWORD>(formatted.size());
DWORD bytes_written = 0; DWORD bytes_written = 0;
auto ignored = ::WriteFile(static_cast<HANDLE>(out_handle_), formatted.data(), size, &bytes_written, nullptr); auto ignored = ::WriteFile(static_cast<HANDLE>(out_handle_), formatted.data(), size,
&bytes_written, nullptr);
(void)(ignored); (void)(ignored);
} }
// wincolor_stdout_sink // wincolor_stdout_sink
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE wincolor_stdout_sink<ConsoleMutex>::wincolor_stdout_sink(color_mode mode) SPDLOG_INLINE wincolor_stdout_sink<ConsoleMutex>::wincolor_stdout_sink(color_mode mode)
: wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_OUTPUT_HANDLE), mode) : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_OUTPUT_HANDLE), mode) {}
{}
// wincolor_stderr_sink // wincolor_stderr_sink
template<typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode) SPDLOG_INLINE wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode)
: wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode) : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode) {}
{} } // namespace sinks
} // namespace sinks } // namespace spdlog
} // namespace spdlog

25
Tool/spdlog/include/spdlog/sinks/wincolor_sink.h
View File

@ -8,11 +8,11 @@
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/sinks/sink.h> #include <spdlog/sinks/sink.h>
#include <array>
#include <cstdint>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <array>
#include <cstdint>
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
@ -20,9 +20,8 @@ namespace sinks {
* Windows color console sink. Uses WriteConsoleA to write to the console with * Windows color console sink. Uses WriteConsoleA to write to the console with
* colors * colors
*/ */
template<typename ConsoleMutex> template <typename ConsoleMutex>
class wincolor_sink : public sink class wincolor_sink : public sink {
{
public: public:
wincolor_sink(void *out_handle, color_mode mode); wincolor_sink(void *out_handle, color_mode mode);
~wincolor_sink() override; ~wincolor_sink() override;
@ -58,16 +57,14 @@ protected:
void set_color_mode_impl(color_mode mode); void set_color_mode_impl(color_mode mode);
}; };
template<typename ConsoleMutex> template <typename ConsoleMutex>
class wincolor_stdout_sink : public wincolor_sink<ConsoleMutex> class wincolor_stdout_sink : public wincolor_sink<ConsoleMutex> {
{
public: public:
explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic); explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic);
}; };
template<typename ConsoleMutex> template <typename ConsoleMutex>
class wincolor_stderr_sink : public wincolor_sink<ConsoleMutex> class wincolor_stderr_sink : public wincolor_sink<ConsoleMutex> {
{
public: public:
explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic); explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic);
}; };
@ -77,9 +74,9 @@ using wincolor_stdout_sink_st = wincolor_stdout_sink<details::console_nullmutex>
using wincolor_stderr_sink_mt = wincolor_stderr_sink<details::console_mutex>; using wincolor_stderr_sink_mt = wincolor_stderr_sink<details::console_mutex>;
using wincolor_stderr_sink_st = wincolor_stderr_sink<details::console_nullmutex>; using wincolor_stderr_sink_st = wincolor_stderr_sink<details::console_nullmutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
# include "wincolor_sink-inl.h" #include "wincolor_sink-inl.h"
#endif #endif

Some files were not shown because too many files have changed in this diff Show More