mqt-core 3.3.2__cp314-cp314t-macosx_11_0_x86_64.whl

mqt/core/include/spdlog/sinks/sink.h

@@ -0,0 +1,34 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg.h>
+#include <spdlog/formatter.h>
+
+namespace spdlog {
+
+namespace sinks {
+class SPDLOG_API sink {
+public:
+    virtual ~sink() = default;
+    virtual void log(const details::log_msg &msg) = 0;
+    virtual void flush() = 0;
+    virtual void set_pattern(const std::string &pattern) = 0;
+    virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) = 0;
+
+    void set_level(level::level_enum log_level);
+    level::level_enum level() const;
+    bool should_log(level::level_enum msg_level) const;
+
+protected:
+    // sink log level - default is all
+    level_t level_{level::trace};
+};
+
+}  // namespace sinks
+}  // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+    #include "sink-inl.h"
+#endif

mqt/core/include/spdlog/sinks/stdout_color_sinks-inl.h

@@ -0,0 +1,38 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+    #include <spdlog/sinks/stdout_color_sinks.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/logger.h>
+
+namespace spdlog {
+
+template <typename Factory>
+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);
+}
+
+template <typename Factory>
+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);
+}
+
+template <typename Factory>
+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);
+}
+
+template <typename Factory>
+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);
+}
+}  // namespace spdlog

mqt/core/include/spdlog/sinks/stdout_color_sinks.h

@@ -0,0 +1,49 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef _WIN32
+    #include <spdlog/sinks/wincolor_sink.h>
+#else
+    #include <spdlog/sinks/ansicolor_sink.h>
+#endif
+
+#include <spdlog/details/synchronous_factory.h>
+
+namespace spdlog {
+namespace sinks {
+#ifdef _WIN32
+using stdout_color_sink_mt = wincolor_stdout_sink_mt;
+using stdout_color_sink_st = wincolor_stdout_sink_st;
+using stderr_color_sink_mt = wincolor_stderr_sink_mt;
+using stderr_color_sink_st = wincolor_stderr_sink_st;
+#else
+using stdout_color_sink_mt = ansicolor_stdout_sink_mt;
+using stdout_color_sink_st = ansicolor_stdout_sink_st;
+using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
+using stderr_color_sink_st = ansicolor_stderr_sink_st;
+#endif
+}  // namespace sinks
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name,
+                                        color_mode mode = color_mode::automatic);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_color_st(const std::string &logger_name,
+                                        color_mode mode = color_mode::automatic);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name,
+                                        color_mode mode = color_mode::automatic);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
+                                        color_mode mode = color_mode::automatic);
+
+}  // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+    #include "stdout_color_sinks-inl.h"
+#endif

mqt/core/include/spdlog/sinks/stdout_sinks-inl.h

@@ -0,0 +1,127 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+    #include <spdlog/sinks/stdout_sinks.h>
+#endif
+
+#include <memory>
+#include <spdlog/details/console_globals.h>
+#include <spdlog/pattern_formatter.h>
+#include <spdlog/details/os.h>
+
+#ifdef _WIN32
+    // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675)
+    // so instead we use ::FileWrite
+    #include <spdlog/details/windows_include.h>
+
+    #ifndef _USING_V110_SDK71_  // fileapi.h doesn't exist in winxp
+        #include <fileapi.h>    // WriteFile (..)
+    #endif
+
+    #include <io.h>     // _get_osfhandle(..)
+    #include <stdio.h>  // _fileno(..)
+#endif                  // _WIN32
+
+namespace spdlog {
+
+namespace sinks {
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
+    : mutex_(ConsoleMutex::mutex()),
+      file_(file),
+      formatter_(details::make_unique<spdlog::pattern_formatter>()) {
+#ifdef _WIN32
+    // get windows handle from the FILE* object
+
+    handle_ = reinterpret_cast<HANDLE>(::_get_osfhandle(::_fileno(file_)));
+
+    // don't throw to support cases where no console is attached,
+    // 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).
+    if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) {
+        throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno);
+    }
+#endif  // _WIN32
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg) {
+#ifdef _WIN32
+    if (handle_ == INVALID_HANDLE_VALUE) {
+        return;
+    }
+    std::lock_guard<mutex_t> lock(mutex_);
+    memory_buf_t formatted;
+    formatter_->format(msg, formatted);
+    auto size = static_cast<DWORD>(formatted.size());
+    DWORD bytes_written = 0;
+    bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0;
+    if (!ok) {
+        throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " +
+                        std::to_string(::GetLastError()));
+    }
+#else
+    std::lock_guard<mutex_t> lock(mutex_);
+    memory_buf_t formatted;
+    formatter_->format(msg, formatted);
+    details::os::fwrite_bytes(formatted.data(), formatted.size(), file_);
+#endif                // _WIN32
+    ::fflush(file_);  // flush every line to terminal
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush() {
+    std::lock_guard<mutex_t> lock(mutex_);
+    fflush(file_);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern) {
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(
+    std::unique_ptr<spdlog::formatter> sink_formatter) {
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::move(sink_formatter);
+}
+
+// stdout sink
+template <typename ConsoleMutex>
+SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink()
+    : stdout_sink_base<ConsoleMutex>(stdout) {}
+
+// stderr sink
+template <typename ConsoleMutex>
+SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
+    : stdout_sink_base<ConsoleMutex>(stderr) {}
+
+}  // namespace sinks
+
+// factory methods
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name) {
+    return Factory::template create<sinks::stdout_sink_mt>(logger_name);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name) {
+    return Factory::template create<sinks::stdout_sink_st>(logger_name);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name) {
+    return Factory::template create<sinks::stderr_sink_mt>(logger_name);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) {
+    return Factory::template create<sinks::stderr_sink_st>(logger_name);
+}
+}  // namespace spdlog

mqt/core/include/spdlog/sinks/stdout_sinks.h

@@ -0,0 +1,84 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <cstdio>
+#include <spdlog/details/console_globals.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/sink.h>
+
+#ifdef _WIN32
+    #include <spdlog/details/windows_include.h>
+#endif
+
+namespace spdlog {
+
+namespace sinks {
+
+template <typename ConsoleMutex>
+class stdout_sink_base : public sink {
+public:
+    using mutex_t = typename ConsoleMutex::mutex_t;
+    explicit stdout_sink_base(FILE *file);
+    ~stdout_sink_base() override = default;
+
+    stdout_sink_base(const stdout_sink_base &other) = delete;
+    stdout_sink_base(stdout_sink_base &&other) = delete;
+
+    stdout_sink_base &operator=(const stdout_sink_base &other) = delete;
+    stdout_sink_base &operator=(stdout_sink_base &&other) = delete;
+
+    void log(const details::log_msg &msg) override;
+    void flush() override;
+    void set_pattern(const std::string &pattern) override;
+
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
+
+protected:
+    mutex_t &mutex_;
+    FILE *file_;
+    std::unique_ptr<spdlog::formatter> formatter_;
+#ifdef _WIN32
+    HANDLE handle_;
+#endif  // WIN32
+};
+
+template <typename ConsoleMutex>
+class stdout_sink : public stdout_sink_base<ConsoleMutex> {
+public:
+    stdout_sink();
+};
+
+template <typename ConsoleMutex>
+class stderr_sink : public stdout_sink_base<ConsoleMutex> {
+public:
+    stderr_sink();
+};
+
+using stdout_sink_mt = stdout_sink<details::console_mutex>;
+using stdout_sink_st = stdout_sink<details::console_nullmutex>;
+
+using stderr_sink_mt = stderr_sink<details::console_mutex>;
+using stderr_sink_st = stderr_sink<details::console_nullmutex>;
+
+}  // namespace sinks
+
+// factory methods
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
+
+}  // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+    #include "stdout_sinks-inl.h"
+#endif

mqt/core/include/spdlog/sinks/syslog_sink.h

@@ -0,0 +1,104 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <array>
+#include <string>
+#include <syslog.h>
+
+namespace spdlog {
+namespace sinks {
+/**
+ * Sink that write to syslog using the `syscall()` library call.
+ */
+template <typename Mutex>
+class syslog_sink : public base_sink<Mutex> {
+public:
+    syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting)
+        : enable_formatting_{enable_formatting},
+          syslog_levels_{{/* spdlog::level::trace      */ LOG_DEBUG,
+                          /* spdlog::level::debug      */ LOG_DEBUG,
+                          /* spdlog::level::info       */ LOG_INFO,
+                          /* spdlog::level::warn       */ LOG_WARNING,
+                          /* spdlog::level::err        */ LOG_ERR,
+                          /* spdlog::level::critical   */ LOG_CRIT,
+                          /* spdlog::level::off        */ LOG_INFO}},
+          ident_{std::move(ident)} {
+        // set ident to be program name if empty
+        ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility);
+    }
+
+    ~syslog_sink() override { ::closelog(); }
+
+    syslog_sink(const syslog_sink &) = delete;
+    syslog_sink &operator=(const syslog_sink &) = delete;
+
+protected:
+    void sink_it_(const details::log_msg &msg) override {
+        string_view_t payload;
+        memory_buf_t formatted;
+        if (enable_formatting_) {
+            base_sink<Mutex>::formatter_->format(msg, formatted);
+            payload = string_view_t(formatted.data(), formatted.size());
+        } else {
+            payload = msg.payload;
+        }
+
+        size_t length = payload.size();
+        // limit to max int
+        if (length > static_cast<size_t>(std::numeric_limits<int>::max())) {
+            length = static_cast<size_t>(std::numeric_limits<int>::max());
+        }
+
+        ::syslog(syslog_prio_from_level(msg), "%.*s", static_cast<int>(length), payload.data());
+    }
+
+    void flush_() override {}
+    bool enable_formatting_ = false;
+
+    //
+    // Simply maps spdlog's log level to syslog priority level.
+    //
+    virtual int syslog_prio_from_level(const details::log_msg &msg) const {
+        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_st = syslog_sink<details::null_mutex>;
+}  // namespace sinks
+
+// Create and register a syslog logger
+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,
+                                                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>
+inline std::shared_ptr<logger> syslog_logger_st(const std::string &logger_name,
+                                                const std::string &syslog_ident = "",
+                                                int syslog_option = 0,
+                                                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

mqt/core/include/spdlog/sinks/systemd_sink.h

@@ -0,0 +1,121 @@
+// Copyright(c) 2019 ZVYAGIN.Alexander@gmail.com
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <array>
+#ifndef SD_JOURNAL_SUPPRESS_LOCATION
+    #define SD_JOURNAL_SUPPRESS_LOCATION
+#endif
+#include <systemd/sd-journal.h>
+
+namespace spdlog {
+namespace sinks {
+
+/**
+ * Sink that write to systemd journal using the `sd_journal_send()` library call.
+ */
+template <typename Mutex>
+class systemd_sink : public base_sink<Mutex> {
+public:
+    systemd_sink(std::string ident = "", bool enable_formatting = false)
+        : ident_{std::move(ident)},
+          enable_formatting_{enable_formatting},
+          syslog_levels_{{/* spdlog::level::trace      */ LOG_DEBUG,
+                          /* spdlog::level::debug      */ LOG_DEBUG,
+                          /* spdlog::level::info       */ LOG_INFO,
+                          /* spdlog::level::warn       */ LOG_WARNING,
+                          /* spdlog::level::err        */ LOG_ERR,
+                          /* spdlog::level::critical   */ LOG_CRIT,
+                          /* spdlog::level::off        */ LOG_INFO}} {}
+
+    ~systemd_sink() override {}
+
+    systemd_sink(const systemd_sink &) = delete;
+    systemd_sink &operator=(const systemd_sink &) = delete;
+
+protected:
+    const std::string ident_;
+    bool enable_formatting_ = false;
+    using levels_array = std::array<int, 7>;
+    levels_array syslog_levels_;
+
+    void sink_it_(const details::log_msg &msg) override {
+        int err;
+        string_view_t payload;
+        memory_buf_t formatted;
+        if (enable_formatting_) {
+            base_sink<Mutex>::formatter_->format(msg, formatted);
+            payload = string_view_t(formatted.data(), formatted.size());
+        } else {
+            payload = msg.payload;
+        }
+
+        size_t length = payload.size();
+        // limit to max int
+        if (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_;
+
+        // Do not send source location if not available
+        if (msg.source.empty()) {
+            // 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),
+#ifndef SPDLOG_NO_THREAD_ID
+                                    "TID=%zu", msg.thread_id,
+#endif
+                                    "SYSLOG_IDENTIFIER=%.*s",
+                                    static_cast<int>(syslog_identifier.size()),
+                                    syslog_identifier.data(), nullptr);
+        } else {
+            err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(),
+                                    "PRIORITY=%d", syslog_level(msg.level),
+#ifndef SPDLOG_NO_THREAD_ID
+                                    "TID=%zu", msg.thread_id,
+#endif
+                                    "SYSLOG_IDENTIFIER=%.*s",
+                                    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) {
+            throw_spdlog_ex("Failed writing to systemd", errno);
+        }
+    }
+
+    int syslog_level(level::level_enum l) {
+        return syslog_levels_.at(static_cast<levels_array::size_type>(l));
+    }
+
+    void flush_() override {}
+};
+
+using systemd_sink_mt = systemd_sink<std::mutex>;
+using systemd_sink_st = systemd_sink<details::null_mutex>;
+}  // namespace sinks
+
+// Create and register a syslog logger
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> systemd_logger_mt(const std::string &logger_name,
+                                                 const std::string &ident = "",
+                                                 bool enable_formatting = false) {
+    return Factory::template create<sinks::systemd_sink_mt>(logger_name, ident, enable_formatting);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> systemd_logger_st(const std::string &logger_name,
+                                                 const std::string &ident = "",
+                                                 bool enable_formatting = false) {
+    return Factory::template create<sinks::systemd_sink_st>(logger_name, ident, enable_formatting);
+}
+}  // namespace spdlog

mqt/core/include/spdlog/sinks/tcp_sink.h

@@ -0,0 +1,75 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#ifdef _WIN32
+    #include <spdlog/details/tcp_client-windows.h>
+#else
+    #include <spdlog/details/tcp_client.h>
+#endif
+
+#include <chrono>
+#include <functional>
+#include <mutex>
+#include <string>
+
+#pragma once
+
+// Simple tcp client sink
+// Connects to remote address and send the formatted log.
+// 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.
+
+namespace spdlog {
+namespace sinks {
+
+struct tcp_sink_config {
+    std::string server_host;
+    int server_port;
+    bool lazy_connect = false;  // if true connect on first log call instead of on construction
+
+    tcp_sink_config(std::string host, int port)
+        : server_host{std::move(host)},
+          server_port{port} {}
+};
+
+template <typename Mutex>
+class tcp_sink : public spdlog::sinks::base_sink<Mutex> {
+public:
+    // connect to tcp host/port or throw if failed
+    // host can be hostname or ip address
+
+    explicit tcp_sink(tcp_sink_config sink_config)
+        : config_{std::move(sink_config)} {
+        if (!config_.lazy_connect) {
+            this->client_.connect(config_.server_host, config_.server_port);
+        }
+    }
+
+    ~tcp_sink() override = default;
+
+protected:
+    void sink_it_(const spdlog::details::log_msg &msg) override {
+        spdlog::memory_buf_t formatted;
+        spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
+        if (!client_.is_connected()) {
+            client_.connect(config_.server_host, config_.server_port);
+        }
+        client_.send(formatted.data(), formatted.size());
+    }
+
+    void flush_() override {}
+    tcp_sink_config config_;
+    details::tcp_client client_;
+};
+
+using tcp_sink_mt = tcp_sink<std::mutex>;
+using tcp_sink_st = tcp_sink<spdlog::details::null_mutex>;
+
+}  // namespace sinks
+}  // namespace spdlog