summaryrefslogtreecommitdiff
path: root/matching/include/spdlog/details
diff options
context:
space:
mode:
Diffstat (limited to 'matching/include/spdlog/details')
-rw-r--r--matching/include/spdlog/details/async_logger_impl.h110
-rw-r--r--matching/include/spdlog/details/circular_q.h72
-rw-r--r--matching/include/spdlog/details/console_globals.h74
-rw-r--r--matching/include/spdlog/details/file_helper.h152
-rw-r--r--matching/include/spdlog/details/fmt_helper.h122
-rw-r--r--matching/include/spdlog/details/log_msg.h55
-rw-r--r--matching/include/spdlog/details/logger_impl.h441
-rw-r--r--matching/include/spdlog/details/mpmc_blocking_q.h121
-rw-r--r--matching/include/spdlog/details/null_mutex.h45
-rw-r--r--matching/include/spdlog/details/os.h421
-rw-r--r--matching/include/spdlog/details/pattern_formatter.h1336
-rw-r--r--matching/include/spdlog/details/periodic_worker.h71
-rw-r--r--matching/include/spdlog/details/registry.h285
-rw-r--r--matching/include/spdlog/details/thread_pool.h238
14 files changed, 0 insertions, 3543 deletions
diff --git a/matching/include/spdlog/details/async_logger_impl.h b/matching/include/spdlog/details/async_logger_impl.h
deleted file mode 100644
index aafcae6..0000000
--- a/matching/include/spdlog/details/async_logger_impl.h
+++ /dev/null
@@ -1,110 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// async logger implementation
-// uses a thread pool to perform the actual logging
-
-#include "spdlog/details/thread_pool.h"
-
-#include <chrono>
-#include <memory>
-#include <string>
-
-template<typename It>
-inline spdlog::async_logger::async_logger(
- std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
- : logger(std::move(logger_name), begin, end)
- , thread_pool_(std::move(tp))
- , overflow_policy_(overflow_policy)
-{
-}
-
-inline spdlog::async_logger::async_logger(
- std::string logger_name, sinks_init_list sinks_list, 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)
-{
-}
-
-inline spdlog::async_logger::async_logger(
- std::string logger_name, sink_ptr single_sink, 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
-inline void spdlog::async_logger::sink_it_(details::log_msg &msg)
-{
-#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
- incr_msg_counter_(msg);
-#endif
- if (auto pool_ptr = thread_pool_.lock())
- {
- pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
- }
- else
- {
- throw spdlog_ex("async log: thread pool doesn't exist anymore");
- }
-}
-
-// send flush request to the thread pool
-inline void spdlog::async_logger::flush_()
-{
- if (auto pool_ptr = thread_pool_.lock())
- {
- pool_ptr->post_flush(shared_from_this(), overflow_policy_);
- }
- else
- {
- throw spdlog_ex("async flush: thread pool doesn't exist anymore");
- }
-}
-
-//
-// backend functions - called from the thread pool to do the actual job
-//
-inline void spdlog::async_logger::backend_log_(const details::log_msg &incoming_log_msg)
-{
- try
- {
- for (auto &s : sinks_)
- {
- if (s->should_log(incoming_log_msg.level))
- {
- s->log(incoming_log_msg);
- }
- }
- }
- SPDLOG_CATCH_AND_HANDLE
-
- if (should_flush_(incoming_log_msg))
- {
- backend_flush_();
- }
-}
-
-inline void spdlog::async_logger::backend_flush_()
-{
- try
- {
- for (auto &sink : sinks_)
- {
- sink->flush();
- }
- }
- SPDLOG_CATCH_AND_HANDLE
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
-{
- auto cloned = std::make_shared<spdlog::async_logger>(std::move(new_name), sinks_.begin(), sinks_.end(), thread_pool_, overflow_policy_);
-
- cloned->set_level(this->level());
- cloned->flush_on(this->flush_level());
- cloned->set_error_handler(this->error_handler());
- return std::move(cloned);
-}
diff --git a/matching/include/spdlog/details/circular_q.h b/matching/include/spdlog/details/circular_q.h
deleted file mode 100644
index b01325b..0000000
--- a/matching/include/spdlog/details/circular_q.h
+++ /dev/null
@@ -1,72 +0,0 @@
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-// cirucal q view of std::vector.
-#pragma once
-
-#include <vector>
-
-namespace spdlog {
-namespace details {
-template<typename T>
-class circular_q
-{
-public:
- using item_type = T;
-
- explicit circular_q(size_t max_items)
- : max_items_(max_items + 1) // one item is reserved as marker for full q
- , v_(max_items_)
- {
- }
-
- // push back, overrun (oldest) item if no room left
- void push_back(T &&item)
- {
- v_[tail_] = std::move(item);
- tail_ = (tail_ + 1) % max_items_;
-
- if (tail_ == head_) // overrun last item if full
- {
- head_ = (head_ + 1) % max_items_;
- ++overrun_counter_;
- }
- }
-
- // Pop item from front.
- // If there are no elements in the container, the behavior is undefined.
- void pop_front(T &popped_item)
- {
- popped_item = std::move(v_[head_]);
- head_ = (head_ + 1) % max_items_;
- }
-
- bool empty()
- {
- return tail_ == head_;
- }
-
- bool full()
- {
- // head is ahead of the tail by 1
- return ((tail_ + 1) % max_items_) == head_;
- }
-
- size_t overrun_counter() const
- {
- return overrun_counter_;
- }
-
-private:
- size_t max_items_;
- typename std::vector<T>::size_type head_ = 0;
- typename std::vector<T>::size_type tail_ = 0;
-
- std::vector<T> v_;
-
- size_t overrun_counter_ = 0;
-};
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/console_globals.h b/matching/include/spdlog/details/console_globals.h
deleted file mode 100644
index e2afb6b..0000000
--- a/matching/include/spdlog/details/console_globals.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#pragma once
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#include "spdlog/details/null_mutex.h"
-#include <cstdio>
-#include <mutex>
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX // prevent windows redefining min/max
-#endif
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-
-#include <windows.h>
-#endif
-
-namespace spdlog {
-namespace details {
-struct console_stdout
-{
- static std::FILE *stream()
- {
- return stdout;
- }
-#ifdef _WIN32
- static HANDLE handle()
- {
- return ::GetStdHandle(STD_OUTPUT_HANDLE);
- }
-#endif
-};
-
-struct console_stderr
-{
- static std::FILE *stream()
- {
- return stderr;
- }
-#ifdef _WIN32
- static HANDLE handle()
- {
- return ::GetStdHandle(STD_ERROR_HANDLE);
- }
-#endif
-};
-
-struct console_mutex
-{
- using mutex_t = std::mutex;
- static mutex_t &mutex()
- {
- static mutex_t s_mutex;
- return s_mutex;
- }
-};
-
-struct console_nullmutex
-{
- using mutex_t = null_mutex;
- static mutex_t &mutex()
- {
- static mutex_t s_mutex;
- return s_mutex;
- }
-};
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/file_helper.h b/matching/include/spdlog/details/file_helper.h
deleted file mode 100644
index 8c1132d..0000000
--- a/matching/include/spdlog/details/file_helper.h
+++ /dev/null
@@ -1,152 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Helper class for file sinks.
-// When failing to open a file, retry several times(5) with a delay interval(10 ms).
-// Throw spdlog_ex exception on errors.
-
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/os.h"
-
-#include <cerrno>
-#include <chrono>
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <tuple>
-
-namespace spdlog {
-namespace details {
-
-class file_helper
-{
-
-public:
- const int open_tries = 5;
- const int open_interval = 10;
-
- explicit file_helper() = default;
-
- file_helper(const file_helper &) = delete;
- file_helper &operator=(const file_helper &) = delete;
-
- ~file_helper()
- {
- close();
- }
-
- void open(const filename_t &fname, bool truncate = false)
- {
- close();
- auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
- _filename = fname;
- for (int tries = 0; tries < open_tries; ++tries)
- {
- if (!os::fopen_s(&fd_, fname, mode))
- {
- return;
- }
-
- details::os::sleep_for_millis(open_interval);
- }
-
- throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno);
- }
-
- void reopen(bool truncate)
- {
- if (_filename.empty())
- {
- throw spdlog_ex("Failed re opening file - was not opened before");
- }
- open(_filename, truncate);
- }
-
- void flush()
- {
- std::fflush(fd_);
- }
-
- void close()
- {
- if (fd_ != nullptr)
- {
- std::fclose(fd_);
- fd_ = nullptr;
- }
- }
-
- void write(const fmt::memory_buffer &buf)
- {
- size_t msg_size = buf.size();
- auto data = buf.data();
- if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
- {
- throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);
- }
- }
-
- size_t size() const
- {
- if (fd_ == nullptr)
- {
- throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
- }
- return os::filesize(fd_);
- }
-
- const filename_t &filename() const
- {
- return _filename;
- }
-
- static bool file_exists(const filename_t &fname)
- {
- return os::file_exists(fname);
- }
-
- //
- // return file path and its extension:
- //
- // "mylog.txt" => ("mylog", ".txt")
- // "mylog" => ("mylog", "")
- // "mylog." => ("mylog.", "")
- // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
- //
- // the starting dot in filenames is ignored (hidden files):
- //
- // ".mylog" => (".mylog". "")
- // "my_folder/.mylog" => ("my_folder/.mylog", "")
- // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
- static std::tuple<filename_t, filename_t> split_by_extension(const spdlog::filename_t &fname)
- {
- auto ext_index = fname.rfind('.');
-
- // no valid extension found - return whole path and empty string as
- // extension
- if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
- {
- return std::make_tuple(fname, spdlog::filename_t());
- }
-
- // treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
- auto folder_index = fname.rfind(details::os::folder_sep);
- if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
- {
- return std::make_tuple(fname, spdlog::filename_t());
- }
-
- // finally - return a valid base and extension tuple
- return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
- }
-
-private:
- std::FILE *fd_{nullptr};
- filename_t _filename;
-};
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/fmt_helper.h b/matching/include/spdlog/details/fmt_helper.h
deleted file mode 100644
index d76aac4..0000000
--- a/matching/include/spdlog/details/fmt_helper.h
+++ /dev/null
@@ -1,122 +0,0 @@
-//
-// Created by gabi on 6/15/18.
-//
-
-#pragma once
-
-#include <chrono>
-#include <type_traits>
-#include "spdlog/fmt/fmt.h"
-
-// Some fmt helpers to efficiently format and pad ints and strings
-namespace spdlog {
-namespace details {
-namespace fmt_helper {
-
-template<size_t Buffer_Size>
-inline spdlog::string_view_t to_string_view(const fmt::basic_memory_buffer<char, Buffer_Size> &buf) SPDLOG_NOEXCEPT
-{
- return spdlog::string_view_t(buf.data(), buf.size());
-}
-
-template<size_t Buffer_Size1, size_t Buffer_Size2>
-inline void append_buf(const fmt::basic_memory_buffer<char, Buffer_Size1> &buf, fmt::basic_memory_buffer<char, Buffer_Size2> &dest)
-{
- auto *buf_ptr = buf.data();
- dest.append(buf_ptr, buf_ptr + buf.size());
-}
-
-template<size_t Buffer_Size>
-inline void append_string_view(spdlog::string_view_t view, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
-{
- auto *buf_ptr = view.data();
- if (buf_ptr != nullptr)
- {
- dest.append(buf_ptr, buf_ptr + view.size());
- }
-}
-
-template<typename T, size_t Buffer_Size>
-inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
-{
- fmt::format_int i(n);
- dest.append(i.data(), i.data() + i.size());
-}
-
-template<typename T>
-inline unsigned count_digits(T n)
-{
- using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
- return static_cast<unsigned>(fmt::internal::count_digits(static_cast<count_type>(n)));
-}
-
-template<size_t Buffer_Size>
-inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
-{
- if (n > 99)
- {
- append_int(n, dest);
- }
- else if (n > 9) // 10-99
- {
- dest.push_back(static_cast<char>('0' + n / 10));
- dest.push_back(static_cast<char>('0' + n % 10));
- }
- else if (n >= 0) // 0-9
- {
- dest.push_back('0');
- dest.push_back(static_cast<char>('0' + n));
- }
- else // negatives (unlikely, but just in case, let fmt deal with it)
- {
- fmt::format_to(dest, "{:02}", n);
- }
-}
-
-template<typename T, size_t Buffer_Size>
-inline void pad_uint(T n, unsigned int width, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
-{
- static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
- auto digits = count_digits(n);
- if (width > digits)
- {
- const char *zeroes = "0000000000000000000";
- dest.append(zeroes, zeroes + width - digits);
- }
- append_int(n, dest);
-}
-
-template<typename T, size_t Buffer_Size>
-inline void pad3(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
-{
- pad_uint(n, 3, dest);
-}
-
-template<typename T, size_t Buffer_Size>
-inline void pad6(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
-{
- pad_uint(n, 6, dest);
-}
-
-template<typename T, size_t Buffer_Size>
-inline void pad9(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
-{
- pad_uint(n, 9, dest);
-}
-
-// return fraction of a second of the given time_point.
-// e.g.
-// fraction<std::milliseconds>(tp) -> will return the millis part of the second
-template<typename ToDuration>
-inline ToDuration time_fraction(const log_clock::time_point &tp)
-{
- using std::chrono::duration_cast;
- using std::chrono::seconds;
- auto duration = tp.time_since_epoch();
- auto secs = duration_cast<seconds>(duration);
- return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
-}
-
-} // namespace fmt_helper
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/log_msg.h b/matching/include/spdlog/details/log_msg.h
deleted file mode 100644
index 69422ba..0000000
--- a/matching/include/spdlog/details/log_msg.h
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/common.h"
-#include "spdlog/details/os.h"
-
-#include <string>
-#include <utility>
-
-namespace spdlog {
-namespace details {
-struct log_msg
-{
-
- log_msg(source_loc loc, const std::string *loggers_name, level::level_enum lvl, string_view_t view)
- : logger_name(loggers_name)
- , level(lvl)
-#ifndef SPDLOG_NO_DATETIME
- , time(os::now())
-#endif
-
-#ifndef SPDLOG_NO_THREAD_ID
- , thread_id(os::thread_id())
-#endif
- , source(loc)
- , payload(view)
- {
- }
-
- log_msg(const std::string *loggers_name, level::level_enum lvl, string_view_t view)
- : log_msg(source_loc{}, loggers_name, lvl, view)
- {
- }
-
- log_msg(const log_msg &other) = default;
-
- const std::string *logger_name{nullptr};
- level::level_enum level{level::off};
- log_clock::time_point time;
- size_t thread_id{0};
- size_t msg_id{0};
-
- // wrapping the formatted text with color (updated by pattern_formatter).
- mutable size_t color_range_start{0};
- mutable size_t color_range_end{0};
-
- source_loc source;
- const string_view_t payload;
-};
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/logger_impl.h b/matching/include/spdlog/details/logger_impl.h
deleted file mode 100644
index 0212ede..0000000
--- a/matching/include/spdlog/details/logger_impl.h
+++ /dev/null
@@ -1,441 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/details/fmt_helper.h"
-
-#include <memory>
-#include <string>
-
-#define SPDLOG_CATCH_AND_HANDLE \
- catch (const std::exception &ex) \
- { \
- err_handler_(ex.what()); \
- } \
- catch (...) \
- { \
- err_handler_("Unknown exception in logger"); \
- }
-
-// create logger with given name, sinks and the default pattern formatter
-// all other ctors will call this one
-template<typename It>
-inline spdlog::logger::logger(std::string logger_name, It begin, It end)
- : name_(std::move(logger_name))
- , sinks_(begin, end)
-{
-}
-
-// ctor with sinks as init list
-inline spdlog::logger::logger(std::string logger_name, sinks_init_list sinks_list)
- : logger(std::move(logger_name), sinks_list.begin(), sinks_list.end())
-{
-}
-
-// ctor with single sink
-inline spdlog::logger::logger(std::string logger_name, spdlog::sink_ptr single_sink)
- : logger(std::move(logger_name), {std::move(single_sink)})
-{
-}
-
-inline spdlog::logger::~logger() = default;
-
-inline void spdlog::logger::set_formatter(std::unique_ptr<spdlog::formatter> f)
-{
- for (auto &sink : sinks_)
- {
- sink->set_formatter(f->clone());
- }
-}
-
-inline void spdlog::logger::set_pattern(std::string pattern, pattern_time_type time_type)
-{
- auto new_formatter = details::make_unique<spdlog::pattern_formatter>(std::move(pattern), time_type);
- set_formatter(std::move(new_formatter));
-}
-
-template<typename... Args>
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *fmt, const Args &... args)
-{
- if (!should_log(lvl))
- {
- return;
- }
-
- try
- {
- using details::fmt_helper::to_string_view;
- fmt::memory_buffer buf;
- fmt::format_to(buf, fmt, args...);
- details::log_msg log_msg(source, &name_, lvl, to_string_view(buf));
- sink_it_(log_msg);
- }
- SPDLOG_CATCH_AND_HANDLE
-}
-
-template<typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const char *fmt, const Args &... args)
-{
- log(source_loc{}, lvl, fmt, args...);
-}
-
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *msg)
-{
- if (!should_log(lvl))
- {
- return;
- }
-
- try
- {
- details::log_msg log_msg(source, &name_, lvl, spdlog::string_view_t(msg));
- sink_it_(log_msg);
- }
- SPDLOG_CATCH_AND_HANDLE
-}
-
-inline void spdlog::logger::log(level::level_enum lvl, const char *msg)
-{
- log(source_loc{}, lvl, msg);
-}
-
-template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const T &msg)
-{
- if (!should_log(lvl))
- {
- return;
- }
- try
- {
- details::log_msg log_msg(source, &name_, lvl, msg);
- sink_it_(log_msg);
- }
- SPDLOG_CATCH_AND_HANDLE
-}
-
-template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
-inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
-{
- log(source_loc{}, lvl, msg);
-}
-
-template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const T &msg)
-{
- if (!should_log(lvl))
- {
- return;
- }
- try
- {
- using details::fmt_helper::to_string_view;
- fmt::memory_buffer buf;
- fmt::format_to(buf, "{}", msg);
- details::log_msg log_msg(source, &name_, lvl, to_string_view(buf));
- sink_it_(log_msg);
- }
- SPDLOG_CATCH_AND_HANDLE
-}
-
-template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
-inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
-{
- log(source_loc{}, lvl, msg);
-}
-
-template<typename... Args>
-inline void spdlog::logger::trace(const char *fmt, const Args &... args)
-{
- log(level::trace, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::debug(const char *fmt, const Args &... args)
-{
- log(level::debug, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::info(const char *fmt, const Args &... args)
-{
- log(level::info, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::warn(const char *fmt, const Args &... args)
-{
- log(level::warn, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::error(const char *fmt, const Args &... args)
-{
- log(level::err, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::critical(const char *fmt, const Args &... args)
-{
- log(level::critical, fmt, args...);
-}
-
-template<typename T>
-inline void spdlog::logger::trace(const T &msg)
-{
- log(level::trace, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::debug(const T &msg)
-{
- log(level::debug, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::info(const T &msg)
-{
- log(level::info, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::warn(const T &msg)
-{
- log(level::warn, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::error(const T &msg)
-{
- log(level::err, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::critical(const T &msg)
-{
- log(level::critical, msg);
-}
-
-#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-
-inline void wbuf_to_utf8buf(const fmt::wmemory_buffer &wbuf, fmt::memory_buffer &target)
-{
- int wbuf_size = static_cast<int>(wbuf.size());
- if (wbuf_size == 0)
- {
- return;
- }
-
- auto result_size = ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, NULL, 0, NULL, NULL);
-
- if (result_size > 0)
- {
- target.resize(result_size);
- ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0], result_size, NULL, NULL);
- }
- else
- {
- throw spdlog::spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
- }
-}
-
-template<typename... Args>
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args)
-{
- if (!should_log(lvl))
- {
- return;
- }
-
- try
- {
- // format to wmemory_buffer and convert to utf8
- using details::fmt_helper::to_string_view;
- fmt::wmemory_buffer wbuf;
- fmt::format_to(wbuf, fmt, args...);
- fmt::memory_buffer buf;
- wbuf_to_utf8buf(wbuf, buf);
- details::log_msg log_msg(source, &name_, lvl, to_string_view(buf));
- sink_it_(log_msg);
- }
- SPDLOG_CATCH_AND_HANDLE
-}
-
-template<typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
-{
- log(source_loc{}, lvl, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args)
-{
- log(level::trace, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args)
-{
- log(level::debug, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args)
-{
- log(level::info, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args)
-{
- log(level::warn, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args)
-{
- log(level::err, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args)
-{
- log(level::critical, fmt, args...);
-}
-
-#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
-
-//
-// name and level
-//
-inline const std::string &spdlog::logger::name() const
-{
- return name_;
-}
-
-inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
-{
- level_.store(log_level);
-}
-
-inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
-{
- err_handler_ = std::move(err_handler);
-}
-
-inline spdlog::log_err_handler spdlog::logger::error_handler() const
-{
- return err_handler_;
-}
-
-inline void spdlog::logger::flush()
-{
- try
- {
- flush_();
- }
- SPDLOG_CATCH_AND_HANDLE
-}
-
-inline void spdlog::logger::flush_on(level::level_enum log_level)
-{
- flush_level_.store(log_level);
-}
-
-inline spdlog::level::level_enum spdlog::logger::flush_level() const
-{
- return static_cast<spdlog::level::level_enum>(flush_level_.load(std::memory_order_relaxed));
-}
-
-inline bool spdlog::logger::should_flush_(const details::log_msg &msg)
-{
- auto flush_level = flush_level_.load(std::memory_order_relaxed);
- return (msg.level >= flush_level) && (msg.level != level::off);
-}
-
-inline spdlog::level::level_enum spdlog::logger::default_level()
-{
- return static_cast<spdlog::level::level_enum>(SPDLOG_ACTIVE_LEVEL);
-}
-
-inline spdlog::level::level_enum spdlog::logger::level() const
-{
- return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
-}
-
-inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
-{
- return msg_level >= level_.load(std::memory_order_relaxed);
-}
-
-//
-// protected virtual called at end of each user log call (if enabled) by the
-// line_logger
-//
-inline void spdlog::logger::sink_it_(details::log_msg &msg)
-{
-#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
- incr_msg_counter_(msg);
-#endif
- for (auto &sink : sinks_)
- {
- if (sink->should_log(msg.level))
- {
- sink->log(msg);
- }
- }
-
- if (should_flush_(msg))
- {
- flush_();
- }
-}
-
-inline void spdlog::logger::flush_()
-{
- for (auto &sink : sinks_)
- {
- sink->flush();
- }
-}
-
-inline void spdlog::logger::default_err_handler_(const std::string &msg)
-{
- auto now = time(nullptr);
- if (now - last_err_time_ < 60)
- {
- return;
- }
- last_err_time_ = now;
- auto tm_time = details::os::localtime(now);
- char date_buf[100];
- std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
- fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
-}
-
-inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg)
-{
- msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed);
-}
-
-inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const
-{
- return sinks_;
-}
-
-inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks()
-{
- return sinks_;
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::logger::clone(std::string logger_name)
-{
- auto cloned = std::make_shared<spdlog::logger>(std::move(logger_name), sinks_.begin(), sinks_.end());
- cloned->set_level(this->level());
- cloned->flush_on(this->flush_level());
- cloned->set_error_handler(this->error_handler());
- return cloned;
-}
diff --git a/matching/include/spdlog/details/mpmc_blocking_q.h b/matching/include/spdlog/details/mpmc_blocking_q.h
deleted file mode 100644
index ca789fc..0000000
--- a/matching/include/spdlog/details/mpmc_blocking_q.h
+++ /dev/null
@@ -1,121 +0,0 @@
-#pragma once
-
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-// multi producer-multi consumer blocking queue.
-// enqueue(..) - will block until room found to put the new message.
-// enqueue_nowait(..) - will return immediately with false if no room left in
-// the queue.
-// dequeue_for(..) - will block until the queue is not empty or timeout have
-// passed.
-
-#include "spdlog/details/circular_q.h"
-
-#include <condition_variable>
-#include <mutex>
-
-namespace spdlog {
-namespace details {
-
-template<typename T>
-class mpmc_blocking_queue
-{
-public:
- using item_type = T;
- explicit mpmc_blocking_queue(size_t max_items)
- : q_(max_items)
- {
- }
-
-#ifndef __MINGW32__
- // try to enqueue and block if no room left
- void enqueue(T &&item)
- {
- {
- std::unique_lock<std::mutex> lock(queue_mutex_);
- pop_cv_.wait(lock, [this] { return !this->q_.full(); });
- q_.push_back(std::move(item));
- }
- push_cv_.notify_one();
- }
-
- // enqueue immediately. overrun oldest message in the queue if no room left.
- void enqueue_nowait(T &&item)
- {
- {
- std::unique_lock<std::mutex> lock(queue_mutex_);
- q_.push_back(std::move(item));
- }
- push_cv_.notify_one();
- }
-
- // try to dequeue item. if no item found. wait upto timeout and try again
- // Return true, if succeeded dequeue item, false otherwise
- bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
- {
- {
- std::unique_lock<std::mutex> lock(queue_mutex_);
- if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
- {
- return false;
- }
- q_.pop_front(popped_item);
- }
- pop_cv_.notify_one();
- return true;
- }
-
-#else
- // apparently mingw deadlocks if the mutex is released before cv.notify_one(),
- // so release the mutex at the very end each function.
-
- // try to enqueue and block if no room left
- void enqueue(T &&item)
- {
- std::unique_lock<std::mutex> lock(queue_mutex_);
- pop_cv_.wait(lock, [this] { return !this->q_.full(); });
- q_.push_back(std::move(item));
- push_cv_.notify_one();
- }
-
- // enqueue immediately. overrun oldest message in the queue if no room left.
- void enqueue_nowait(T &&item)
- {
- std::unique_lock<std::mutex> lock(queue_mutex_);
- q_.push_back(std::move(item));
- push_cv_.notify_one();
- }
-
- // try to dequeue item. if no item found. wait upto timeout and try again
- // Return true, if succeeded dequeue item, false otherwise
- bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
- {
- std::unique_lock<std::mutex> lock(queue_mutex_);
- if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
- {
- return false;
- }
- q_.pop_front(popped_item);
- pop_cv_.notify_one();
- return true;
- }
-
-#endif
-
- size_t overrun_counter()
- {
- std::unique_lock<std::mutex> lock(queue_mutex_);
- return q_.overrun_counter();
- }
-
-private:
- std::mutex queue_mutex_;
- std::condition_variable push_cv_;
- std::condition_variable pop_cv_;
- spdlog::details::circular_q<T> q_;
-};
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/null_mutex.h b/matching/include/spdlog/details/null_mutex.h
deleted file mode 100644
index 3f495bd..0000000
--- a/matching/include/spdlog/details/null_mutex.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <atomic>
-// null, no cost dummy "mutex" and dummy "atomic" int
-
-namespace spdlog {
-namespace details {
-struct null_mutex
-{
- void lock() {}
- void unlock() {}
- bool try_lock()
- {
- return true;
- }
-};
-
-struct null_atomic_int
-{
- int value;
- null_atomic_int() = default;
-
- explicit null_atomic_int(int val)
- : value(val)
- {
- }
-
- int load(std::memory_order) const
- {
- return value;
- }
-
- void store(int val)
- {
- value = val;
- }
-};
-
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/os.h b/matching/include/spdlog/details/os.h
deleted file mode 100644
index 646805e..0000000
--- a/matching/include/spdlog/details/os.h
+++ /dev/null
@@ -1,421 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-#pragma once
-
-#include "../common.h"
-
-#include <algorithm>
-#include <chrono>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
-#include <functional>
-#include <string>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <thread>
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX // prevent windows redefining min/max
-#endif
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <io.h> // _get_osfhandle and _isatty support
-#include <process.h> // _get_pid support
-#include <windows.h>
-
-#ifdef __MINGW32__
-#include <share.h>
-#endif
-
-#else // unix
-
-#include <fcntl.h>
-#include <unistd.h>
-
-#ifdef __linux__
-#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
-
-#elif __FreeBSD__
-#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
-#endif
-
-#endif // unix
-
-#ifndef __has_feature // Clang - feature checking macros.
-#define __has_feature(x) 0 // Compatibility with non-clang compilers.
-#endif
-
-namespace spdlog {
-namespace details {
-namespace os {
-
-inline spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
-{
-
-#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
- timespec ts;
- ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
- return std::chrono::time_point<log_clock, typename log_clock::duration>(
- std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
-
-#else
- return log_clock::now();
-#endif
-}
-inline std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
-{
-
-#ifdef _WIN32
- std::tm tm;
- localtime_s(&tm, &time_tt);
-#else
- std::tm tm;
- localtime_r(&time_tt, &tm);
-#endif
- return tm;
-}
-
-inline std::tm localtime() SPDLOG_NOEXCEPT
-{
- std::time_t now_t = time(nullptr);
- return localtime(now_t);
-}
-
-inline std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
-{
-
-#ifdef _WIN32
- std::tm tm;
- gmtime_s(&tm, &time_tt);
-#else
- std::tm tm;
- gmtime_r(&time_tt, &tm);
-#endif
- return tm;
-}
-
-inline std::tm gmtime() SPDLOG_NOEXCEPT
-{
- std::time_t now_t = time(nullptr);
- return gmtime(now_t);
-}
-
-// eol definition
-#if !defined(SPDLOG_EOL)
-#ifdef _WIN32
-#define SPDLOG_EOL "\r\n"
-#else
-#define SPDLOG_EOL "\n"
-#endif
-#endif
-
-SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
-
-// folder separator
-#ifdef _WIN32
-SPDLOG_CONSTEXPR static const char folder_sep = '\\';
-#else
-SPDLOG_CONSTEXPR static const char folder_sep = '/';
-#endif
-
-inline void prevent_child_fd(FILE *f)
-{
-
-#ifdef _WIN32
-#if !defined(__cplusplus_winrt)
- auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
- if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
- throw spdlog_ex("SetHandleInformation failed", errno);
-#endif
-#else
- auto fd = fileno(f);
- if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
- {
- throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
- }
-#endif
-}
-
-// fopen_s on non windows for writing
-inline bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
- *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
-#else
- *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
-#endif
-#else // unix
- *fp = fopen((filename.c_str()), mode.c_str());
-#endif
-
-#ifdef SPDLOG_PREVENT_CHILD_FD
- if (*fp != nullptr)
- {
- prevent_child_fd(*fp);
- }
-#endif
- return *fp == nullptr;
-}
-
-inline int remove(const filename_t &filename) SPDLOG_NOEXCEPT
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
- return _wremove(filename.c_str());
-#else
- return std::remove(filename.c_str());
-#endif
-}
-
-inline int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
- return _wrename(filename1.c_str(), filename2.c_str());
-#else
- return std::rename(filename1.c_str(), filename2.c_str());
-#endif
-}
-
-// Return if file exists
-inline bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
- auto attribs = GetFileAttributesW(filename.c_str());
-#else
- auto attribs = GetFileAttributesA(filename.c_str());
-#endif
- return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
-#else // common linux/unix all have the stat system call
- struct stat buffer;
- return (stat(filename.c_str(), &buffer) == 0);
-#endif
-}
-
-// Return file size according to open FILE* object
-inline size_t filesize(FILE *f)
-{
- if (f == nullptr)
- {
- throw spdlog_ex("Failed getting file size. fd is null");
- }
-#if defined(_WIN32) && !defined(__CYGWIN__)
- int fd = _fileno(f);
-#if _WIN64 // 64 bits
- __int64 ret = _filelengthi64(fd);
- if (ret >= 0)
- {
- return static_cast<size_t>(ret);
- }
-
-#else // windows 32 bits
- long ret = _filelength(fd);
- if (ret >= 0)
- {
- return static_cast<size_t>(ret);
- }
-#endif
-
-#else // unix
- int fd = fileno(f);
-// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
-#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
- struct stat64 st;
- if (fstat64(fd, &st) == 0)
- {
- return static_cast<size_t>(st.st_size);
- }
-#else // unix 32 bits or cygwin
- struct stat st;
-
- if (fstat(fd, &st) == 0)
- {
- return static_cast<size_t>(st.st_size);
- }
-#endif
-#endif
- throw spdlog_ex("Failed getting file size from fd", errno);
-}
-
-// Return utc offset in minutes or throw spdlog_ex on failure
-inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
-{
-
-#ifdef _WIN32
-#if _WIN32_WINNT < _WIN32_WINNT_WS08
- TIME_ZONE_INFORMATION tzinfo;
- auto rv = GetTimeZoneInformation(&tzinfo);
-#else
- DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
- auto rv = GetDynamicTimeZoneInformation(&tzinfo);
-#endif
- if (rv == TIME_ZONE_ID_INVALID)
- throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
-
- int offset = -tzinfo.Bias;
- if (tm.tm_isdst)
- {
- offset -= tzinfo.DaylightBias;
- }
- else
- {
- offset -= tzinfo.StandardBias;
- }
- return offset;
-#else
-
-#if defined(sun) || defined(__sun) || defined(_AIX)
- // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
- struct helper
- {
- static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
- {
- int local_year = localtm.tm_year + (1900 - 1);
- int gmt_year = gmtm.tm_year + (1900 - 1);
-
- long int days = (
- // difference in day of year
- localtm.tm_yday -
- gmtm.tm_yday
-
- // + intervening leap days
- + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
- ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
-
- // + difference in years * 365 */
- + (long int)(local_year - gmt_year) * 365);
-
- long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
- long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
- long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
-
- return secs;
- }
- };
-
- auto offset_seconds = helper::calculate_gmt_offset(tm);
-#else
- auto offset_seconds = tm.tm_gmtoff;
-#endif
-
- return static_cast<int>(offset_seconds / 60);
-#endif
-}
-
-// Return current thread id as size_t
-// It exists because the std::this_thread::get_id() is much slower(especially
-// under VS 2013)
-inline size_t _thread_id() SPDLOG_NOEXCEPT
-{
-#ifdef _WIN32
- return static_cast<size_t>(::GetCurrentThreadId());
-#elif __linux__
-#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-#define SYS_gettid __NR_gettid
-#endif
- return static_cast<size_t>(syscall(SYS_gettid));
-#elif __FreeBSD__
- long tid;
- thr_self(&tid);
- return static_cast<size_t>(tid);
-#elif __APPLE__
- uint64_t tid;
- pthread_threadid_np(nullptr, &tid);
- return static_cast<size_t>(tid);
-#else // Default to standard C++11 (other Unix)
- return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
-#endif
-}
-
-// Return current thread id as size_t (from thread local storage)
-inline size_t thread_id() SPDLOG_NOEXCEPT
-{
-#if defined(SPDLOG_NO_TLS)
- return _thread_id();
-#else // cache thread id in tls
- static thread_local const size_t tid = _thread_id();
- return tid;
-#endif
-}
-
-// This is avoid msvc issue in sleep_for that happens if the clock changes.
-// See https://github.com/gabime/spdlog/issues/609
-inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
-{
-#if defined(_WIN32)
- ::Sleep(milliseconds);
-#else
- std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
-#endif
-}
-
-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-#define SPDLOG_FILENAME_T(s) L##s
-inline std::string filename_to_str(const filename_t &filename)
-{
- std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
- return c.to_bytes(filename);
-}
-#else
-#define SPDLOG_FILENAME_T(s) s
-inline std::string filename_to_str(const filename_t &filename)
-{
- return filename;
-}
-#endif
-
-inline int pid()
-{
-
-#ifdef _WIN32
- return static_cast<int>(::GetCurrentProcessId());
-#else
- return static_cast<int>(::getpid());
-#endif
-}
-
-// Determine if the terminal supports colors
-// Source: https://github.com/agauniyal/rang/
-inline bool is_color_terminal() SPDLOG_NOEXCEPT
-{
-#ifdef _WIN32
- return true;
-#else
- static constexpr const char *Terms[] = {
- "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"};
-
- const char *env_p = std::getenv("TERM");
- if (env_p == nullptr)
- {
- return false;
- }
-
- static const bool result =
- std::any_of(std::begin(Terms), std::end(Terms), [&](const char *term) { return std::strstr(env_p, term) != nullptr; });
- return result;
-#endif
-}
-
-// Detrmine if the terminal attached
-// Source: https://github.com/agauniyal/rang/
-inline bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
-{
-
-#ifdef _WIN32
- return _isatty(_fileno(file)) != 0;
-#else
- return isatty(fileno(file)) != 0;
-#endif
-}
-} // namespace os
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/pattern_formatter.h b/matching/include/spdlog/details/pattern_formatter.h
deleted file mode 100644
index c0ad86e..0000000
--- a/matching/include/spdlog/details/pattern_formatter.h
+++ /dev/null
@@ -1,1336 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/details/fmt_helper.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/os.h"
-#include "spdlog/fmt/fmt.h"
-#include "spdlog/formatter.h"
-
-#include <array>
-#include <chrono>
-#include <ctime>
-#include <cctype>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace spdlog {
-namespace details {
-
-// padding information.
-struct padding_info
-{
- enum pad_side
- {
- left,
- right,
- center
- };
-
- padding_info() = default;
- padding_info(size_t width, padding_info::pad_side side)
- : width_(width)
- , side_(side)
- {
- }
-
- bool enabled() const
- {
- return width_ != 0;
- }
- const size_t width_ = 0;
- const pad_side side_ = left;
-};
-
-class scoped_pad
-{
-public:
- scoped_pad(size_t wrapped_size, padding_info &padinfo, fmt::memory_buffer &dest)
- : padinfo_(padinfo)
- , dest_(dest)
- {
-
- if (padinfo_.width_ <= wrapped_size)
- {
- total_pad_ = 0;
- return;
- }
-
- total_pad_ = padinfo.width_ - wrapped_size;
- if (padinfo_.side_ == padding_info::left)
- {
- pad_it(total_pad_);
- total_pad_ = 0;
- }
- else if (padinfo_.side_ == padding_info::center)
- {
- auto half_pad = total_pad_ / 2;
- auto reminder = total_pad_ & 1;
- pad_it(half_pad);
- total_pad_ = half_pad + reminder; // for the right side
- }
- }
-
- scoped_pad(spdlog::string_view_t txt, padding_info &padinfo, fmt::memory_buffer &dest)
- : scoped_pad(txt.size(), padinfo, dest)
- {
- }
-
- ~scoped_pad()
- {
- if (total_pad_)
- {
- pad_it(total_pad_);
- }
- }
-
-private:
- void pad_it(size_t count)
- {
- // count = std::min(count, spaces_.size());
- assert(count <= spaces_.size());
- fmt_helper::append_string_view(string_view_t(spaces_.data(), count), dest_);
- }
-
- const padding_info &padinfo_;
- fmt::memory_buffer &dest_;
- size_t total_pad_;
- string_view_t spaces_{" "
- " ",
- 128};
-};
-
-class flag_formatter
-{
-public:
- explicit flag_formatter(padding_info padinfo)
- : padinfo_(padinfo)
- {
- }
- flag_formatter() = default;
- virtual ~flag_formatter() = default;
- virtual void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) = 0;
-
-protected:
- padding_info padinfo_;
-};
-
-///////////////////////////////////////////////////////////////////////
-// name & level pattern appender
-///////////////////////////////////////////////////////////////////////
-class name_formatter : public flag_formatter
-{
-public:
- explicit name_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- if (padinfo_.enabled())
- {
- scoped_pad p(*msg.logger_name, padinfo_, dest);
- fmt_helper::append_string_view(*msg.logger_name, dest);
- }
- else
- {
- fmt_helper::append_string_view(*msg.logger_name, dest);
- }
- }
-};
-
-// log level appender
-class level_formatter : public flag_formatter
-{
-public:
- explicit level_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- string_view_t &level_name = level::to_string_view(msg.level);
- if (padinfo_.enabled())
- {
- scoped_pad p(level_name, padinfo_, dest);
- fmt_helper::append_string_view(level_name, dest);
- }
- else
- {
- fmt_helper::append_string_view(level_name, dest);
- }
- }
-};
-
-// short log level appender
-class short_level_formatter : public flag_formatter
-{
-public:
- explicit short_level_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- string_view_t level_name{level::to_short_c_str(msg.level)};
- scoped_pad p(level_name, padinfo_, dest);
- fmt_helper::append_string_view(level_name, dest);
- }
-};
-
-///////////////////////////////////////////////////////////////////////
-// Date time pattern appenders
-///////////////////////////////////////////////////////////////////////
-
-static const char *ampm(const tm &t)
-{
- return t.tm_hour >= 12 ? "PM" : "AM";
-}
-
-static int to12h(const tm &t)
-{
- return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
-}
-
-// Abbreviated weekday name
-static const char *days[]{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-class a_formatter : public flag_formatter
-{
-public:
- explicit a_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- string_view_t field_value{days[tm_time.tm_wday]};
- scoped_pad p(field_value, padinfo_, dest);
- fmt_helper::append_string_view(field_value, dest);
- }
-};
-
-// Full weekday name
-static const char *full_days[]{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
-class A_formatter : public flag_formatter
-{
-public:
- explicit A_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- string_view_t field_value{full_days[tm_time.tm_wday]};
- scoped_pad p(field_value, padinfo_, dest);
- fmt_helper::append_string_view(field_value, dest);
- }
-};
-
-// Abbreviated month
-static const char *months[]{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"};
-class b_formatter : public flag_formatter
-{
-public:
- explicit b_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- string_view_t field_value{months[tm_time.tm_mon]};
- scoped_pad p(field_value, padinfo_, dest);
- fmt_helper::append_string_view(field_value, dest);
- }
-};
-
-// Full month name
-static const char *full_months[]{
- "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
-class B_formatter : public flag_formatter
-{
-public:
- explicit B_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- string_view_t field_value{full_months[tm_time.tm_mon]};
- scoped_pad p(field_value, padinfo_, dest);
- fmt_helper::append_string_view(field_value, dest);
- }
-};
-
-// Date and time representation (Thu Aug 23 15:35:46 2014)
-class c_formatter final : public flag_formatter
-{
-public:
- explicit c_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 24;
- scoped_pad p(field_size, padinfo_, dest);
-
- fmt_helper::append_string_view(days[tm_time.tm_wday], dest);
- dest.push_back(' ');
- fmt_helper::append_string_view(months[tm_time.tm_mon], dest);
- dest.push_back(' ');
- fmt_helper::append_int(tm_time.tm_mday, dest);
- dest.push_back(' ');
- // time
-
- fmt_helper::pad2(tm_time.tm_hour, dest);
- dest.push_back(':');
- fmt_helper::pad2(tm_time.tm_min, dest);
- dest.push_back(':');
- fmt_helper::pad2(tm_time.tm_sec, dest);
- dest.push_back(' ');
- fmt_helper::append_int(tm_time.tm_year + 1900, dest);
- }
-};
-
-// year - 2 digit
-class C_formatter final : public flag_formatter
-{
-public:
- explicit C_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 2;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad2(tm_time.tm_year % 100, dest);
- }
-};
-
-// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
-class D_formatter final : public flag_formatter
-{
-public:
- explicit D_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 10;
- scoped_pad p(field_size, padinfo_, dest);
-
- fmt_helper::pad2(tm_time.tm_mon + 1, dest);
- dest.push_back('/');
- fmt_helper::pad2(tm_time.tm_mday, dest);
- dest.push_back('/');
- fmt_helper::pad2(tm_time.tm_year % 100, dest);
- }
-};
-
-// year - 4 digit
-class Y_formatter final : public flag_formatter
-{
-public:
- explicit Y_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 4;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::append_int(tm_time.tm_year + 1900, dest);
- }
-};
-
-// month 1-12
-class m_formatter final : public flag_formatter
-{
-public:
- explicit m_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 2;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad2(tm_time.tm_mon + 1, dest);
- }
-};
-
-// day of month 1-31
-class d_formatter final : public flag_formatter
-{
-public:
- explicit d_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 2;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad2(tm_time.tm_mday, dest);
- }
-};
-
-// hours in 24 format 0-23
-class H_formatter final : public flag_formatter
-{
-public:
- explicit H_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 2;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad2(tm_time.tm_hour, dest);
- }
-};
-
-// hours in 12 format 1-12
-class I_formatter final : public flag_formatter
-{
-public:
- explicit I_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 2;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad2(to12h(tm_time), dest);
- }
-};
-
-// minutes 0-59
-class M_formatter final : public flag_formatter
-{
-public:
- explicit M_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 2;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad2(tm_time.tm_min, dest);
- }
-};
-
-// seconds 0-59
-class S_formatter final : public flag_formatter
-{
-public:
- explicit S_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 2;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad2(tm_time.tm_sec, dest);
- }
-};
-
-// milliseconds
-class e_formatter final : public flag_formatter
-{
-public:
- explicit e_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- auto millis = fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time);
- if (padinfo_.enabled())
- {
- const size_t field_size = 3;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
- }
- else
- {
- fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
- }
- }
-};
-
-// microseconds
-class f_formatter final : public flag_formatter
-{
-public:
- explicit f_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time);
- if (padinfo_.enabled())
- {
- const size_t field_size = 6;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad6(static_cast<size_t>(micros.count()), dest);
- }
- else
- {
- fmt_helper::pad6(static_cast<size_t>(micros.count()), dest);
- }
- }
-};
-
-// nanoseconds
-class F_formatter final : public flag_formatter
-{
-public:
- explicit F_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
- if (padinfo_.enabled())
- {
- const size_t field_size = 9;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad9(static_cast<size_t>(ns.count()), dest);
- }
- else
- {
- fmt_helper::pad9(static_cast<size_t>(ns.count()), dest);
- }
- }
-};
-
-// seconds since epoch
-class E_formatter final : public flag_formatter
-{
-public:
- explicit E_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 10;
- scoped_pad p(field_size, padinfo_, dest);
- auto duration = msg.time.time_since_epoch();
- auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
- fmt_helper::append_int(seconds, dest);
- }
-};
-
-// AM/PM
-class p_formatter final : public flag_formatter
-{
-public:
- explicit p_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 2;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::append_string_view(ampm(tm_time), dest);
- }
-};
-
-// 12 hour clock 02:55:02 pm
-class r_formatter final : public flag_formatter
-{
-public:
- explicit r_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 11;
- scoped_pad p(field_size, padinfo_, dest);
-
- fmt_helper::pad2(to12h(tm_time), dest);
- dest.push_back(':');
- fmt_helper::pad2(tm_time.tm_min, dest);
- dest.push_back(':');
- fmt_helper::pad2(tm_time.tm_sec, dest);
- dest.push_back(' ');
- fmt_helper::append_string_view(ampm(tm_time), dest);
- }
-};
-
-// 24-hour HH:MM time, equivalent to %H:%M
-class R_formatter final : public flag_formatter
-{
-public:
- explicit R_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 5;
- scoped_pad p(field_size, padinfo_, dest);
-
- fmt_helper::pad2(tm_time.tm_hour, dest);
- dest.push_back(':');
- fmt_helper::pad2(tm_time.tm_min, dest);
- }
-};
-
-// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
-class T_formatter final : public flag_formatter
-{
-public:
- explicit T_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 8;
- scoped_pad p(field_size, padinfo_, dest);
-
- fmt_helper::pad2(tm_time.tm_hour, dest);
- dest.push_back(':');
- fmt_helper::pad2(tm_time.tm_min, dest);
- dest.push_back(':');
- fmt_helper::pad2(tm_time.tm_sec, dest);
- }
-};
-
-// ISO 8601 offset from UTC in timezone (+-HH:MM)
-class z_formatter final : public flag_formatter
-{
-public:
- explicit z_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- const std::chrono::seconds cache_refresh = std::chrono::seconds(5);
-
- z_formatter() = default;
- z_formatter(const z_formatter &) = delete;
- z_formatter &operator=(const z_formatter &) = delete;
-
- void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 6;
- scoped_pad p(field_size, padinfo_, dest);
-
-#ifdef _WIN32
- int total_minutes = get_cached_offset(msg, tm_time);
-#else
- // No need to chache under gcc,
- // it is very fast (already stored in tm.tm_gmtoff)
- (void)(msg);
- int total_minutes = os::utc_minutes_offset(tm_time);
-#endif
- bool is_negative = total_minutes < 0;
- if (is_negative)
- {
- total_minutes = -total_minutes;
- dest.push_back('-');
- }
- else
- {
- dest.push_back('+');
- }
-
- fmt_helper::pad2(total_minutes / 60, dest); // hours
- dest.push_back(':');
- fmt_helper::pad2(total_minutes % 60, dest); // minutes
- }
-
-private:
- log_clock::time_point last_update_{std::chrono::seconds(0)};
-#ifdef _WIN32
- int offset_minutes_{0};
-
- int get_cached_offset(const log_msg &msg, const std::tm &tm_time)
- {
- if (msg.time - last_update_ >= cache_refresh)
- {
- offset_minutes_ = os::utc_minutes_offset(tm_time);
- last_update_ = msg.time;
- }
- return offset_minutes_;
- }
-#endif
-};
-
-// Thread id
-class t_formatter final : public flag_formatter
-{
-public:
- explicit t_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- if (padinfo_.enabled())
- {
- const auto field_size = fmt_helper::count_digits(msg.thread_id);
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::append_int(msg.thread_id, dest);
- }
- else
- {
- fmt_helper::append_int(msg.thread_id, dest);
- }
- }
-};
-
-// Current pid
-class pid_formatter final : public flag_formatter
-{
-public:
- explicit pid_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
- {
- const auto pid = static_cast<uint32_t>(details::os::pid());
- if (padinfo_.enabled())
- {
- auto field_size = fmt_helper::count_digits(pid);
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::append_int(pid, dest);
- }
- else
- {
- fmt_helper::append_int(pid, dest);
- }
- }
-};
-
-// message counter formatter
-class i_formatter final : public flag_formatter
-{
-public:
- explicit i_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 6;
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::pad6(msg.msg_id, dest);
- }
-};
-
-class v_formatter final : public flag_formatter
-{
-public:
- explicit v_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- if (padinfo_.enabled())
- {
- scoped_pad p(msg.payload, padinfo_, dest);
- fmt_helper::append_string_view(msg.payload, dest);
- }
- else
- {
- fmt_helper::append_string_view(msg.payload, dest);
- }
- }
-};
-
-class ch_formatter final : public flag_formatter
-{
-public:
- explicit ch_formatter(char ch)
- : ch_(ch)
- {
- }
-
- void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
- {
- const size_t field_size = 1;
- scoped_pad p(field_size, padinfo_, dest);
- dest.push_back(ch_);
- }
-
-private:
- char ch_;
-};
-
-// aggregate user chars to display as is
-class aggregate_formatter final : public flag_formatter
-{
-public:
- aggregate_formatter() = default;
-
- void add_ch(char ch)
- {
- str_ += ch;
- }
- void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
- {
- fmt_helper::append_string_view(str_, dest);
- }
-
-private:
- std::string str_;
-};
-
-// mark the color range. expect it to be in the form of "%^colored text%$"
-class color_start_formatter final : public flag_formatter
-{
-public:
- explicit color_start_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- msg.color_range_start = dest.size();
- }
-};
-class color_stop_formatter final : public flag_formatter
-{
-public:
- explicit color_stop_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- msg.color_range_end = dest.size();
- }
-};
-
-// print source location
-class source_location_formatter final : public flag_formatter
-{
-public:
- explicit source_location_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- if (msg.source.empty())
- {
- return;
- }
- if (padinfo_.enabled())
- {
- const auto text_size = std::char_traits<char>::length(msg.source.filename) + fmt_helper::count_digits(msg.source.line) + 1;
- scoped_pad p(text_size, padinfo_, dest);
- fmt_helper::append_string_view(msg.source.filename, dest);
- dest.push_back(':');
- fmt_helper::append_int(msg.source.line, dest);
- }
- else
- {
- fmt_helper::append_string_view(msg.source.filename, dest);
- dest.push_back(':');
- fmt_helper::append_int(msg.source.line, dest);
- }
- }
-};
-// print source filename
-class source_filename_formatter final : public flag_formatter
-{
-public:
- explicit source_filename_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- if (msg.source.empty())
- {
- return;
- }
- scoped_pad p(msg.source.filename, padinfo_, dest);
- fmt_helper::append_string_view(msg.source.filename, dest);
- }
-};
-
-class source_linenum_formatter final : public flag_formatter
-{
-public:
- explicit source_linenum_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- if (msg.source.empty())
- {
- return;
- }
- if (padinfo_.enabled())
- {
- auto field_size = fmt_helper::count_digits(msg.source.line);
- scoped_pad p(field_size, padinfo_, dest);
- fmt_helper::append_int(msg.source.line, dest);
- }
- else
- {
- fmt_helper::append_int(msg.source.line, dest);
- }
- }
-};
-// print source funcname
-class source_funcname_formatter final : public flag_formatter
-{
-public:
- explicit source_funcname_formatter(padding_info padinfo)
- : flag_formatter(padinfo){};
-
- void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
- {
- if (msg.source.empty())
- {
- return;
- }
- scoped_pad p(msg.source.funcname, padinfo_, dest);
- fmt_helper::append_string_view(msg.source.funcname, dest);
- }
-};
-
-// Full info formatter
-// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
-class full_formatter final : public flag_formatter
-{
-public:
- explicit full_formatter(padding_info padinfo)
- : flag_formatter(padinfo)
- {
- }
-
- void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override
- {
- using std::chrono::duration_cast;
- using std::chrono::milliseconds;
- using std::chrono::seconds;
-
-#ifndef SPDLOG_NO_DATETIME
-
- // cache the date/time part for the next second.
- auto duration = msg.time.time_since_epoch();
- auto secs = duration_cast<seconds>(duration);
-
- if (cache_timestamp_ != secs || cached_datetime_.size() == 0)
- {
- cached_datetime_.clear();
- cached_datetime_.push_back('[');
- fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_);
- cached_datetime_.push_back('-');
-
- fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_);
- cached_datetime_.push_back('-');
-
- fmt_helper::pad2(tm_time.tm_mday, cached_datetime_);
- cached_datetime_.push_back(' ');
-
- fmt_helper::pad2(tm_time.tm_hour, cached_datetime_);
- cached_datetime_.push_back(':');
-
- fmt_helper::pad2(tm_time.tm_min, cached_datetime_);
- cached_datetime_.push_back(':');
-
- fmt_helper::pad2(tm_time.tm_sec, cached_datetime_);
- cached_datetime_.push_back('.');
-
- cache_timestamp_ = secs;
- }
- fmt_helper::append_buf(cached_datetime_, dest);
-
- auto millis = fmt_helper::time_fraction<milliseconds>(msg.time);
- fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
- dest.push_back(']');
- dest.push_back(' ');
-
-#else // no datetime needed
- (void)tm_time;
-#endif
-
-#ifndef SPDLOG_NO_NAME
- if (!msg.logger_name->empty())
- {
- dest.push_back('[');
- // fmt_helper::append_str(*msg.logger_name, dest);
- fmt_helper::append_string_view(*msg.logger_name, dest);
- dest.push_back(']');
- dest.push_back(' ');
- }
-#endif
-
- dest.push_back('[');
- // wrap the level name with color
- msg.color_range_start = dest.size();
- // fmt_helper::append_string_view(level::to_c_str(msg.level), dest);
- fmt_helper::append_string_view(level::to_string_view(msg.level), dest);
- msg.color_range_end = dest.size();
- dest.push_back(']');
- dest.push_back(' ');
-
- // add source location if present
- if (!msg.source.empty())
- {
- dest.push_back('[');
- fmt_helper::append_string_view(msg.source.filename, dest);
- dest.push_back(':');
- fmt_helper::append_int(msg.source.line, dest);
- dest.push_back(']');
- dest.push_back(' ');
- }
- // fmt_helper::append_string_view(msg.msg(), dest);
- fmt_helper::append_string_view(msg.payload, dest);
- }
-
-private:
- std::chrono::seconds cache_timestamp_{0};
- fmt::basic_memory_buffer<char, 128> cached_datetime_;
-};
-
-} // namespace details
-
-class pattern_formatter final : public formatter
-{
-public:
- explicit pattern_formatter(
- std::string pattern, pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol)
- : pattern_(std::move(pattern))
- , eol_(std::move(eol))
- , pattern_time_type_(time_type)
- , last_log_secs_(0)
- {
- std::memset(&cached_tm_, 0, sizeof(cached_tm_));
- compile_pattern_(pattern_);
- }
-
- // use by default full formatter for if pattern is not given
- explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol)
- : pattern_("%+")
- , eol_(std::move(eol))
- , pattern_time_type_(time_type)
- , last_log_secs_(0)
- {
- std::memset(&cached_tm_, 0, sizeof(cached_tm_));
- formatters_.push_back(details::make_unique<details::full_formatter>(details::padding_info{}));
- }
-
- pattern_formatter(const pattern_formatter &other) = delete;
- pattern_formatter &operator=(const pattern_formatter &other) = delete;
-
- std::unique_ptr<formatter> clone() const override
- {
- return details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_);
- }
-
- void format(const details::log_msg &msg, fmt::memory_buffer &dest) override
- {
-#ifndef SPDLOG_NO_DATETIME
- auto secs = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
- if (secs != last_log_secs_)
- {
- cached_tm_ = get_time_(msg);
- last_log_secs_ = secs;
- }
-#endif
- for (auto &f : formatters_)
- {
- f->format(msg, cached_tm_, dest);
- }
- // write eol
- details::fmt_helper::append_string_view(eol_, dest);
- }
-
-private:
- std::string pattern_;
- std::string eol_;
- pattern_time_type pattern_time_type_;
- std::tm cached_tm_;
- std::chrono::seconds last_log_secs_;
-
- std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
-
- std::tm get_time_(const details::log_msg &msg)
- {
- if (pattern_time_type_ == pattern_time_type::local)
- {
- return details::os::localtime(log_clock::to_time_t(msg.time));
- }
- return details::os::gmtime(log_clock::to_time_t(msg.time));
- }
-
- void handle_flag_(char flag, details::padding_info padding)
- {
- switch (flag)
- {
-
- case ('+'): // default formatter
- formatters_.push_back(details::make_unique<details::full_formatter>(padding));
- break;
-
- case 'n': // logger name
- formatters_.push_back(details::make_unique<details::name_formatter>(padding));
- break;
-
- case 'l': // level
- formatters_.push_back(details::make_unique<details::level_formatter>(padding));
- break;
-
- case 'L': // short level
- formatters_.push_back(details::make_unique<details::short_level_formatter>(padding));
- break;
-
- case ('t'): // thread id
- formatters_.push_back(details::make_unique<details::t_formatter>(padding));
- break;
-
- case ('v'): // the message text
- formatters_.push_back(details::make_unique<details::v_formatter>(padding));
- break;
-
- case ('a'): // weekday
- formatters_.push_back(details::make_unique<details::a_formatter>(padding));
- break;
-
- case ('A'): // short weekday
- formatters_.push_back(details::make_unique<details::A_formatter>(padding));
- break;
-
- case ('b'):
- case ('h'): // month
- formatters_.push_back(details::make_unique<details::b_formatter>(padding));
- break;
-
- case ('B'): // short month
- formatters_.push_back(details::make_unique<details::B_formatter>(padding));
- break;
-
- case ('c'): // datetime
- formatters_.push_back(details::make_unique<details::c_formatter>(padding));
- break;
-
- case ('C'): // year 2 digits
- formatters_.push_back(details::make_unique<details::C_formatter>(padding));
- break;
-
- case ('Y'): // year 4 digits
- formatters_.push_back(details::make_unique<details::Y_formatter>(padding));
- break;
-
- case ('D'):
- case ('x'): // datetime MM/DD/YY
- formatters_.push_back(details::make_unique<details::D_formatter>(padding));
- break;
-
- case ('m'): // month 1-12
- formatters_.push_back(details::make_unique<details::m_formatter>(padding));
- break;
-
- case ('d'): // day of month 1-31
- formatters_.push_back(details::make_unique<details::d_formatter>(padding));
- break;
-
- case ('H'): // hours 24
- formatters_.push_back(details::make_unique<details::H_formatter>(padding));
- break;
-
- case ('I'): // hours 12
- formatters_.push_back(details::make_unique<details::I_formatter>(padding));
- break;
-
- case ('M'): // minutes
- formatters_.push_back(details::make_unique<details::M_formatter>(padding));
- break;
-
- case ('S'): // seconds
- formatters_.push_back(details::make_unique<details::S_formatter>(padding));
- break;
-
- case ('e'): // milliseconds
- formatters_.push_back(details::make_unique<details::e_formatter>(padding));
- break;
-
- case ('f'): // microseconds
- formatters_.push_back(details::make_unique<details::f_formatter>(padding));
- break;
-
- case ('F'): // nanoseconds
- formatters_.push_back(details::make_unique<details::F_formatter>(padding));
- break;
-
- case ('E'): // seconds since epoch
- formatters_.push_back(details::make_unique<details::E_formatter>(padding));
- break;
-
- case ('p'): // am/pm
- formatters_.push_back(details::make_unique<details::p_formatter>(padding));
- break;
-
- case ('r'): // 12 hour clock 02:55:02 pm
- formatters_.push_back(details::make_unique<details::r_formatter>(padding));
- break;
-
- case ('R'): // 24-hour HH:MM time
- formatters_.push_back(details::make_unique<details::R_formatter>(padding));
- break;
-
- case ('T'):
- case ('X'): // ISO 8601 time format (HH:MM:SS)
- formatters_.push_back(details::make_unique<details::T_formatter>(padding));
- break;
-
- case ('z'): // timezone
- formatters_.push_back(details::make_unique<details::z_formatter>(padding));
- break;
-
- case ('P'): // pid
- formatters_.push_back(details::make_unique<details::pid_formatter>(padding));
- break;
-
-#ifdef SPDLOG_ENABLE_MESSAGE_COUNTER
- case ('i'):
- formatters_.push_back(details::make_unique<details::i_formatter>(padding));
- break;
-#endif
- case ('^'): // color range start
- formatters_.push_back(details::make_unique<details::color_start_formatter>(padding));
- break;
-
- case ('$'): // color range end
- formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding));
- break;
-
- case ('@'): // source location (filename:filenumber)
- formatters_.push_back(details::make_unique<details::source_location_formatter>(padding));
- break;
-
- case ('s'): // source filename
- formatters_.push_back(details::make_unique<details::source_filename_formatter>(padding));
- break;
-
- case ('#'): // source line number
- formatters_.push_back(details::make_unique<details::source_linenum_formatter>(padding));
- break;
-
- case ('!'): // source funcname
- formatters_.push_back(details::make_unique<details::source_funcname_formatter>(padding));
- break;
-
- case ('%'): // % char
- formatters_.push_back(details::make_unique<details::ch_formatter>('%'));
- break;
-
- default: // Unknown flag appears as is
- auto unknown_flag = details::make_unique<details::aggregate_formatter>();
- unknown_flag->add_ch('%');
- unknown_flag->add_ch(flag);
- formatters_.push_back((std::move(unknown_flag)));
- break;
- }
- }
-
- // Extract given pad spec (e.g. %8X)
- // Advance the given it pass the end of the padding spec found (if any)
- // Return padding.
- details::padding_info handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end)
- {
- using details::padding_info;
- using details::scoped_pad;
- const size_t max_width = 128;
- if (it == end)
- {
- return padding_info{};
- }
-
- padding_info::pad_side side;
- switch (*it)
- {
- case '-':
- side = padding_info::right;
- ++it;
- break;
- case '=':
- side = padding_info::center;
- ++it;
- break;
- default:
- side = details::padding_info::left;
- break;
- }
-
- if (it == end || !std::isdigit(static_cast<unsigned char>(*it)))
- {
- return padding_info{0, side};
- }
-
- auto width = static_cast<size_t>(*it - '0');
- for (++it; it != end && std::isdigit(static_cast<unsigned char>(*it)); ++it)
- {
- auto digit = static_cast<size_t>(*it - '0');
- width = width * 10 + digit;
- }
- return details::padding_info{std::min<size_t>(width, max_width), side};
- }
-
- void compile_pattern_(const std::string &pattern)
- {
- auto end = pattern.end();
- std::unique_ptr<details::aggregate_formatter> user_chars;
- formatters_.clear();
- for (auto it = pattern.begin(); it != end; ++it)
- {
- if (*it == '%')
- {
- if (user_chars) // append user chars found so far
- {
- formatters_.push_back(std::move(user_chars));
- }
-
- auto padding = handle_padspec_(++it, end);
-
- if (it != end)
- {
- handle_flag_(*it, padding);
- }
- else
- {
- break;
- }
- }
- else // chars not following the % sign should be displayed as is
- {
- if (!user_chars)
- {
- user_chars = details::make_unique<details::aggregate_formatter>();
- }
- user_chars->add_ch(*it);
- }
- }
- if (user_chars) // append raw chars found so far
- {
- formatters_.push_back(std::move(user_chars));
- }
- }
-};
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/periodic_worker.h b/matching/include/spdlog/details/periodic_worker.h
deleted file mode 100644
index fa6488d..0000000
--- a/matching/include/spdlog/details/periodic_worker.h
+++ /dev/null
@@ -1,71 +0,0 @@
-
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// periodic worker thread - periodically executes the given callback function.
-//
-// RAII over the owned thread:
-// creates the thread on construction.
-// stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
-
-#include <chrono>
-#include <condition_variable>
-#include <functional>
-#include <mutex>
-#include <thread>
-namespace spdlog {
-namespace details {
-
-class periodic_worker
-{
-public:
- periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
- {
- active_ = (interval > std::chrono::seconds::zero());
- if (!active_)
- {
- return;
- }
-
- worker_thread_ = std::thread([this, callback_fun, interval]() {
- for (;;)
- {
- std::unique_lock<std::mutex> lock(this->mutex_);
- if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
- {
- return; // active_ == false, so exit this thread
- }
- callback_fun();
- }
- });
- }
-
- periodic_worker(const periodic_worker &) = delete;
- periodic_worker &operator=(const periodic_worker &) = delete;
-
- // stop the worker thread and join it
- ~periodic_worker()
- {
- if (worker_thread_.joinable())
- {
- {
- std::lock_guard<std::mutex> lock(mutex_);
- active_ = false;
- }
- cv_.notify_one();
- worker_thread_.join();
- }
- }
-
-private:
- bool active_;
- std::thread worker_thread_;
- std::mutex mutex_;
- std::condition_variable cv_;
-};
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/registry.h b/matching/include/spdlog/details/registry.h
deleted file mode 100644
index ccd5395..0000000
--- a/matching/include/spdlog/details/registry.h
+++ /dev/null
@@ -1,285 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Loggers registy of unique name->logger pointer
-// An attempt to create a logger with an already existing name will be ignored
-// If user requests a non existing logger, nullptr will be returned
-// This class is thread safe
-
-#include "spdlog/common.h"
-#include "spdlog/details/periodic_worker.h"
-#include "spdlog/logger.h"
-
-#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
-// support for the default stdout color logger
-#ifdef _WIN32
-#include "spdlog/sinks/wincolor_sink.h"
-#else
-#include "spdlog/sinks/ansicolor_sink.h"
-#endif
-#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-namespace spdlog {
-namespace details {
-class thread_pool;
-
-class registry
-{
-public:
- registry(const registry &) = delete;
- registry &operator=(const registry &) = delete;
-
- void register_logger(std::shared_ptr<logger> new_logger)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- register_logger_(std::move(new_logger));
- }
-
- void initialize_logger(std::shared_ptr<logger> new_logger)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- new_logger->set_formatter(formatter_->clone());
-
- if (err_handler_)
- {
- new_logger->set_error_handler(err_handler_);
- }
-
- new_logger->set_level(level_);
- new_logger->flush_on(flush_level_);
-
- if (automatic_registration_)
- {
- register_logger_(std::move(new_logger));
- }
- }
-
- std::shared_ptr<logger> get(const std::string &logger_name)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- auto found = loggers_.find(logger_name);
- return found == loggers_.end() ? nullptr : found->second;
- }
-
- std::shared_ptr<logger> default_logger()
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- return default_logger_;
- }
-
- // Return raw ptr to the default logger.
- // 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().
- // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
- logger *get_default_raw()
- {
- return default_logger_.get();
- }
-
- // set default logger.
- // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
- void set_default_logger(std::shared_ptr<logger> new_default_logger)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- // remove previous default logger from the map
- if (default_logger_ != nullptr)
- {
- loggers_.erase(default_logger_->name());
- }
- if (new_default_logger != nullptr)
- {
- loggers_[new_default_logger->name()] = new_default_logger;
- }
- default_logger_ = std::move(new_default_logger);
- }
-
- void set_tp(std::shared_ptr<thread_pool> tp)
- {
- std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
- tp_ = std::move(tp);
- }
-
- std::shared_ptr<thread_pool> get_tp()
- {
- std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
- return tp_;
- }
-
- // Set global formatter. Each sink in each logger will get a clone of this object
- void set_formatter(std::unique_ptr<formatter> formatter)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- formatter_ = std::move(formatter);
- for (auto &l : loggers_)
- {
- l.second->set_formatter(formatter_->clone());
- }
- }
-
- void set_level(level::level_enum log_level)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- for (auto &l : loggers_)
- {
- l.second->set_level(log_level);
- }
- level_ = log_level;
- }
-
- void flush_on(level::level_enum log_level)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- for (auto &l : loggers_)
- {
- l.second->flush_on(log_level);
- }
- flush_level_ = log_level;
- }
-
- void flush_every(std::chrono::seconds interval)
- {
- std::lock_guard<std::mutex> lock(flusher_mutex_);
- std::function<void()> clbk = std::bind(&registry::flush_all, this);
- periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
- }
-
- void set_error_handler(log_err_handler handler)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- for (auto &l : loggers_)
- {
- l.second->set_error_handler(handler);
- }
- err_handler_ = handler;
- }
-
- void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- for (auto &l : loggers_)
- {
- fun(l.second);
- }
- }
-
- void flush_all()
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- for (auto &l : loggers_)
- {
- l.second->flush();
- }
- }
-
- void drop(const std::string &logger_name)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- loggers_.erase(logger_name);
- if (default_logger_ && default_logger_->name() == logger_name)
- {
- default_logger_.reset();
- }
- }
-
- void drop_all()
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- loggers_.clear();
- default_logger_.reset();
- }
-
- // clean all resources and threads started by the registry
- void shutdown()
- {
- {
- std::lock_guard<std::mutex> lock(flusher_mutex_);
- periodic_flusher_.reset();
- }
-
- drop_all();
-
- {
- std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
- tp_.reset();
- }
- }
-
- std::recursive_mutex &tp_mutex()
- {
- return tp_mutex_;
- }
-
- void set_automatic_registration(bool automatic_regsistration)
- {
- std::lock_guard<std::mutex> lock(logger_map_mutex_);
- automatic_registration_ = automatic_regsistration;
- }
-
- static registry &instance()
- {
- static registry s_instance;
- return s_instance;
- }
-
-private:
- registry()
- : formatter_(new pattern_formatter())
- {
-
-#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
- // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
-#ifdef _WIN32
- auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
-#else
- auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
-#endif
-
- const char *default_logger_name = "";
- default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
- loggers_[default_logger_name] = default_logger_;
-
-#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
- }
-
- ~registry() = default;
-
- void throw_if_exists_(const std::string &logger_name)
- {
- if (loggers_.find(logger_name) != loggers_.end())
- {
- throw spdlog_ex("logger with name '" + logger_name + "' already exists");
- }
- }
-
- void register_logger_(std::shared_ptr<logger> new_logger)
- {
- auto logger_name = new_logger->name();
- throw_if_exists_(logger_name);
- loggers_[logger_name] = std::move(new_logger);
- }
-
- std::mutex logger_map_mutex_, flusher_mutex_;
- std::recursive_mutex tp_mutex_;
- std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
- std::unique_ptr<formatter> formatter_;
- level::level_enum level_ = spdlog::logger::default_level();
- level::level_enum flush_level_ = level::off;
- log_err_handler err_handler_;
- std::shared_ptr<thread_pool> tp_;
- std::unique_ptr<periodic_worker> periodic_flusher_;
- std::shared_ptr<logger> default_logger_;
- bool automatic_registration_ = true;
-};
-
-} // namespace details
-} // namespace spdlog
diff --git a/matching/include/spdlog/details/thread_pool.h b/matching/include/spdlog/details/thread_pool.h
deleted file mode 100644
index 3557897..0000000
--- a/matching/include/spdlog/details/thread_pool.h
+++ /dev/null
@@ -1,238 +0,0 @@
-#pragma once
-
-#include "spdlog/details/fmt_helper.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/mpmc_blocking_q.h"
-#include "spdlog/details/os.h"
-
-#include <chrono>
-#include <memory>
-#include <thread>
-#include <vector>
-
-namespace spdlog {
-namespace details {
-
-using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
-
-enum class async_msg_type
-{
- log,
- flush,
- terminate
-};
-
-// Async msg to move to/from the queue
-// Movable only. should never be copied
-struct async_msg
-{
- async_msg_type msg_type;
- level::level_enum level;
- log_clock::time_point time;
- size_t thread_id;
- fmt::basic_memory_buffer<char, 176> raw;
-
- size_t msg_id;
- source_loc source;
- async_logger_ptr worker_ptr;
-
- async_msg() = default;
- ~async_msg() = default;
-
- // should only be moved in or out of the queue..
- async_msg(const async_msg &) = delete;
-
-// support for vs2013 move
-#if defined(_MSC_VER) && _MSC_VER <= 1800
- async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type),
- level(other.level),
- time(other.time),
- thread_id(other.thread_id),
- raw(move(other.raw)),
- msg_id(other.msg_id),
- source(other.source),
- worker_ptr(std::move(other.worker_ptr))
- {
- }
-
- async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT
- {
- msg_type = other.msg_type;
- level = other.level;
- time = other.time;
- thread_id = other.thread_id;
- raw = std::move(other.raw);
- msg_id = other.msg_id;
- source = other.source;
- worker_ptr = std::move(other.worker_ptr);
- return *this;
- }
-#else // (_MSC_VER) && _MSC_VER <= 1800
- async_msg(async_msg &&) = default;
- async_msg &operator=(async_msg &&) = default;
-#endif
-
- // construct from log_msg with given type
- async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &m)
- : msg_type(the_type)
- , level(m.level)
- , time(m.time)
- , thread_id(m.thread_id)
- , msg_id(m.msg_id)
- , source(m.source)
- , worker_ptr(std::move(worker))
- {
- fmt_helper::append_string_view(m.payload, raw);
- }
-
- async_msg(async_logger_ptr &&worker, async_msg_type the_type)
- : msg_type(the_type)
- , level(level::off)
- , time()
- , thread_id(0)
- , msg_id(0)
- , source()
- , worker_ptr(std::move(worker))
- {
- }
-
- explicit async_msg(async_msg_type the_type)
- : async_msg(nullptr, the_type)
- {
- }
-
- // copy into log_msg
- log_msg to_log_msg()
- {
- log_msg msg(&worker_ptr->name(), level, string_view_t(raw.data(), raw.size()));
- msg.time = time;
- msg.thread_id = thread_id;
- msg.msg_id = msg_id;
- msg.source = source;
- msg.color_range_start = 0;
- msg.color_range_end = 0;
- return msg;
- }
-};
-
-class thread_pool
-{
-public:
- using item_type = async_msg;
- using q_type = details::mpmc_blocking_queue<item_type>;
-
- thread_pool(size_t q_max_items, size_t threads_n)
- : q_(q_max_items)
- {
- // std::cout << "thread_pool() q_size_bytes: " << q_size_bytes <<
- // "\tthreads_n: " << threads_n << std::endl;
- if (threads_n == 0 || threads_n > 1000)
- {
- throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
- "range is 1-1000)");
- }
- for (size_t i = 0; i < threads_n; i++)
- {
- threads_.emplace_back(&thread_pool::worker_loop_, this);
- }
- }
-
- // message all threads to terminate gracefully join them
- ~thread_pool()
- {
- try
- {
- for (size_t i = 0; i < threads_.size(); i++)
- {
- post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
- }
-
- for (auto &t : threads_)
- {
- t.join();
- }
- }
- catch (...)
- {
- }
- }
-
- thread_pool(const thread_pool &) = delete;
- thread_pool &operator=(thread_pool &&) = delete;
-
- void post_log(async_logger_ptr &&worker_ptr, details::log_msg &msg, async_overflow_policy overflow_policy)
- {
- async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
- post_async_msg_(std::move(async_m), overflow_policy);
- }
-
- void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
- {
- post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
- }
-
- size_t overrun_counter()
- {
- return q_.overrun_counter();
- }
-
-private:
- q_type q_;
-
- std::vector<std::thread> threads_;
-
- void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
- {
- if (overflow_policy == async_overflow_policy::block)
- {
- q_.enqueue(std::move(new_msg));
- }
- else
- {
- q_.enqueue_nowait(std::move(new_msg));
- }
- }
-
- void worker_loop_()
- {
- while (process_next_msg_()) {};
- }
-
- // process next message in the queue
- // return true if this thread should still be active (while no terminate msg
- // was received)
- bool process_next_msg_()
- {
- async_msg incoming_async_msg;
- bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
- if (!dequeued)
- {
- return true;
- }
-
- switch (incoming_async_msg.msg_type)
- {
- case async_msg_type::log:
- {
- auto msg = incoming_async_msg.to_log_msg();
- incoming_async_msg.worker_ptr->backend_log_(msg);
- return true;
- }
- case async_msg_type::flush:
- {
- incoming_async_msg.worker_ptr->backend_flush_();
- return true;
- }
-
- case async_msg_type::terminate:
- {
- return false;
- }
- }
- assert(false && "Unexpected async_msg_type");
- return true;
- }
-};
-
-} // namespace details
-} // namespace spdlog
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-31 20:11:17 +0000