couchbase 4.2.11 → 4.3.1

package/deps/couchbase-cxx-cache/spdlog/66ab2619a0014319471759c03e2de1af6bda14de/spdlog/include/spdlog/sinks/qt_sinks.h

@@ -1,292 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman, mguludag and spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-//
-// Custom sink for QPlainTextEdit or QTextEdit and its childs(QTextBrowser...
-// etc) Building and using requires Qt library.
-//
-// Warning: the qt_sink won't be notified if the target widget is destroyed.
-// If the widget's lifetime can be shorter than the logger's one, you should provide some permanent QObject,
-// and then use a standard signal/slot.
-//
-
-#include "spdlog/common.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/synchronous_factory.h"
-#include "spdlog/sinks/base_sink.h"
-#include <array>
-
-#include <QTextEdit>
-#include <QPlainTextEdit>
-
-//
-// qt_sink class
-//
-namespace spdlog {
-namespace sinks {
-template<typename Mutex>
-class qt_sink : public base_sink<Mutex>
-{
-public:
-    qt_sink(QObject *qt_object, std::string meta_method)
-        : qt_object_(qt_object)
-        , meta_method_(std::move(meta_method))
-    {
-        if (!qt_object_)
-        {
-            throw_spdlog_ex("qt_sink: qt_object is null");
-        }
-    }
-
-    ~qt_sink()
-    {
-        flush_();
-    }
-
-protected:
-    void sink_it_(const details::log_msg &msg) override
-    {
-        memory_buf_t formatted;
-        base_sink<Mutex>::formatter_->format(msg, formatted);
-        const string_view_t str = string_view_t(formatted.data(), formatted.size());
-        QMetaObject::invokeMethod(qt_object_, meta_method_.c_str(), Qt::AutoConnection,
-            Q_ARG(QString, QString::fromUtf8(str.data(), static_cast<int>(str.size())).trimmed()));
-    }
-
-    void flush_() override {}
-
-private:
-    QObject *qt_object_ = nullptr;
-    std::string meta_method_;
-};
-
-// QT color sink to QTextEdit.
-// Color location is determined by the sink log pattern like in the rest of spdlog sinks.
-// Colors can be modified if needed using sink->set_color(level, qtTextCharFormat).
-// max_lines is the maximum number of lines that the sink will hold before removing the oldest lines.
-// Note: Only ascii (latin1) is supported by this sink.
-template<typename Mutex>
-class qt_color_sink : public base_sink<Mutex>
-{
-public:
-    qt_color_sink(QTextEdit *qt_text_edit, int max_lines)
-        : qt_text_edit_(qt_text_edit)
-        , max_lines_(max_lines)
-    {
-        if (!qt_text_edit_)
-        {
-            throw_spdlog_ex("qt_color_text_sink: text_edit is null");
-        }
-
-        default_color_ = qt_text_edit_->currentCharFormat();
-        // set colors
-        QTextCharFormat format;
-        // trace
-        format.setForeground(Qt::gray);
-        colors_.at(level::trace) = format;
-        // debug
-        format.setForeground(Qt::cyan);
-        colors_.at(level::debug) = format;
-        // info
-        format.setForeground(Qt::green);
-        colors_.at(level::info) = format;
-        // warn
-        format.setForeground(Qt::yellow);
-        colors_.at(level::warn) = format;
-        // err
-        format.setForeground(Qt::red);
-        colors_.at(level::err) = format;
-        // critical
-        format.setForeground(Qt::white);
-        format.setBackground(Qt::red);
-        colors_.at(level::critical) = format;
-    }
-
-    ~qt_color_sink()
-    {
-        flush_();
-    }
-
-    void set_default_color(QTextCharFormat format)
-    {
-        // std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        default_color_ = format;
-    }
-
-    void set_level_color(level::level_enum color_level, QTextCharFormat format)
-    {
-        // std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        colors_.at(static_cast<size_t>(color_level)) = format;
-    }
-
-    QTextCharFormat &get_level_color(level::level_enum color_level)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        return colors_.at(static_cast<size_t>(color_level));
-    }
-
-    QTextCharFormat &get_default_color()
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        return default_color_;
-    }
-
-protected:
-    struct invoke_params
-    {
-        invoke_params(int max_lines, QTextEdit *q_text_edit, QString payload, QTextCharFormat default_color, QTextCharFormat level_color,
-            int color_range_start, int color_range_end)
-            : max_lines(max_lines)
-            , q_text_edit(q_text_edit)
-            , payload(std::move(payload))
-            , default_color(default_color)
-            , level_color(level_color)
-            , color_range_start(color_range_start)
-            , color_range_end(color_range_end)
-        {}
-        int max_lines;
-        QTextEdit *q_text_edit;
-        QString payload;
-        QTextCharFormat default_color;
-        QTextCharFormat level_color;
-        int color_range_start;
-        int color_range_end;
-    };
-
-    void sink_it_(const details::log_msg &msg) override
-    {
-        memory_buf_t formatted;
-        base_sink<Mutex>::formatter_->format(msg, formatted);
-
-        const string_view_t str = string_view_t(formatted.data(), formatted.size());
-        // apply the color to the color range in the formatted message.
-        auto payload = QString::fromLatin1(str.data(), static_cast<int>(str.size()));
-
-        invoke_params params{max_lines_,             // max lines
-            qt_text_edit_,                           // text edit to append to
-            std::move(payload),                      // text to append
-            default_color_,                          // default color
-            colors_.at(msg.level),                   // color to apply
-            static_cast<int>(msg.color_range_start), // color range start
-            static_cast<int>(msg.color_range_end)};  // color range end
-
-        QMetaObject::invokeMethod(
-            qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection);
-    }
-
-    void flush_() override {}
-
-    // Add colored text to the text edit widget. This method is invoked in the GUI thread.
-    // It is a static method to ensure that it is handled correctly even if the sink is destroyed prematurely
-    // before it is invoked.
-
-    static void invoke_method_(invoke_params params)
-    {
-        auto *document = params.q_text_edit->document();
-        QTextCursor cursor(document);
-
-        // remove first blocks if number of blocks exceeds max_lines
-        while (document->blockCount() > params.max_lines)
-        {
-            cursor.select(QTextCursor::BlockUnderCursor);
-            cursor.removeSelectedText();
-            cursor.deleteChar(); // delete the newline after the block
-        }
-
-        cursor.movePosition(QTextCursor::End);
-        cursor.setCharFormat(params.default_color);
-
-        // if color range not specified or not not valid, just append the text with default color
-        if (params.color_range_end <= params.color_range_start)
-        {
-            cursor.insertText(params.payload);
-            return;
-        }
-
-        // insert the text before the color range
-        cursor.insertText(params.payload.left(params.color_range_start));
-
-        // insert the colorized text
-        cursor.setCharFormat(params.level_color);
-        cursor.insertText(params.payload.mid(params.color_range_start, params.color_range_end - params.color_range_start));
-
-        // insert the text after the color range with default format
-        cursor.setCharFormat(params.default_color);
-        cursor.insertText(params.payload.mid(params.color_range_end));
-    }
-
-    QTextEdit *qt_text_edit_;
-    int max_lines_;
-    QTextCharFormat default_color_;
-    std::array<QTextCharFormat, level::n_levels> colors_;
-};
-
-#include "spdlog/details/null_mutex.h"
-#include <mutex>
-
-using qt_sink_mt = qt_sink<std::mutex>;
-using qt_sink_st = qt_sink<details::null_mutex>;
-using qt_color_sink_mt = qt_color_sink<std::mutex>;
-using qt_color_sink_st = qt_color_sink<details::null_mutex>;
-} // namespace sinks
-
-//
-// Factory functions
-//
-
-// log to QTextEdit
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append")
-{
-    return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
-}
-
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append")
-{
-    return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
-}
-
-// log to QPlainTextEdit
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_logger_mt(
-    const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText")
-{
-    return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
-}
-
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_logger_st(
-    const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText")
-{
-    return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
-}
-// log to QObject
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method)
-{
-    return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
-}
-
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name, QObject *qt_object, const std::string &meta_method)
-{
-    return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
-}
-
-// log to QTextEdit with colorize output
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_color_logger_mt(const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines)
-{
-    return Factory::template create<sinks::qt_color_sink_mt>(logger_name, qt_text_edit, max_lines);
-}
-
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_color_logger_st(const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines)
-{
-    return Factory::template create<sinks::qt_color_sink_st>(logger_name, qt_text_edit, max_lines);
-}
-
-} // namespace spdlog

package/deps/couchbase-cxx-cache/spdlog/66ab2619a0014319471759c03e2de1af6bda14de/spdlog/include/spdlog/sinks/ringbuffer_sink.h

@@ -1,74 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/details/circular_q.h"
-#include "spdlog/details/log_msg_buffer.h"
-#include "spdlog/details/null_mutex.h"
-
-#include <mutex>
-#include <string>
-#include <vector>
-
-namespace spdlog {
-namespace sinks {
-/*
- * Ring buffer sink
- */
-template<typename Mutex>
-class ringbuffer_sink final : public base_sink<Mutex>
-{
-public:
-    explicit ringbuffer_sink(size_t n_items)
-        : q_{n_items}
-    {}
-
-    std::vector<details::log_msg_buffer> last_raw(size_t lim = 0)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        auto items_available = q_.size();
-        auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;
-        std::vector<details::log_msg_buffer> ret;
-        ret.reserve(n_items);
-        for (size_t i = (items_available - n_items); i < items_available; i++)
-        {
-            ret.push_back(q_.at(i));
-        }
-        return ret;
-    }
-
-    std::vector<std::string> last_formatted(size_t lim = 0)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        auto items_available = q_.size();
-        auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;
-        std::vector<std::string> ret;
-        ret.reserve(n_items);
-        for (size_t i = (items_available - n_items); i < items_available; i++)
-        {
-            memory_buf_t formatted;
-            base_sink<Mutex>::formatter_->format(q_.at(i), formatted);
-            ret.push_back(SPDLOG_BUF_TO_STRING(formatted));
-        }
-        return ret;
-    }
-
-protected:
-    void sink_it_(const details::log_msg &msg) override
-    {
-        q_.push_back(details::log_msg_buffer{msg});
-    }
-    void flush_() override {}
-
-private:
-    details::circular_q<details::log_msg_buffer> q_;
-};
-
-using ringbuffer_sink_mt = ringbuffer_sink<std::mutex>;
-using ringbuffer_sink_st = ringbuffer_sink<details::null_mutex>;
-
-} // namespace sinks
-
-} // namespace spdlog

package/deps/couchbase-cxx-cache/spdlog/66ab2619a0014319471759c03e2de1af6bda14de/spdlog/include/spdlog/sinks/rotating_file_sink-inl.h

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

package/deps/couchbase-cxx-cache/spdlog/66ab2619a0014319471759c03e2de1af6bda14de/spdlog/include/spdlog/sinks/rotating_file_sink.h

@@ -1,81 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/file_helper.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/details/synchronous_factory.h>
-
-#include <chrono>
-#include <mutex>
-#include <string>
-
-namespace spdlog {
-namespace sinks {
-
-//
-// Rotating file sink based on size
-//
-template<typename Mutex>
-class rotating_file_sink final : public base_sink<Mutex>
-{
-public:
-    rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false,
-        const file_event_handlers &event_handlers = {});
-    static filename_t calc_filename(const filename_t &filename, std::size_t index);
-    filename_t filename();
-
-protected:
-    void sink_it_(const details::log_msg &msg) override;
-    void flush_() override;
-
-private:
-    // Rotate files:
-    // log.txt -> log.1.txt
-    // log.1.txt -> log.2.txt
-    // log.2.txt -> log.3.txt
-    // log.3.txt -> delete
-    void rotate_();
-
-    // delete the target if exists, and rename the src file  to target
-    // return true on success, false otherwise.
-    bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);
-
-    filename_t base_filename_;
-    std::size_t max_size_;
-    std::size_t max_files_;
-    std::size_t current_size_;
-    details::file_helper file_helper_;
-};
-
-using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
-using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
-
-} // namespace sinks
-
-//
-// factory functions
-//
-
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> rotating_logger_mt(const std::string &logger_name, const filename_t &filename, size_t max_file_size,
-    size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {})
-{
-    return Factory::template create<sinks::rotating_file_sink_mt>(
-        logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
-}
-
-template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name, const filename_t &filename, size_t max_file_size,
-    size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {})
-{
-    return Factory::template create<sinks::rotating_file_sink_st>(
-        logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
-}
-} // namespace spdlog
-
-#ifdef SPDLOG_HEADER_ONLY
-#    include "rotating_file_sink-inl.h"
-#endif

package/deps/couchbase-cxx-cache/spdlog/66ab2619a0014319471759c03e2de1af6bda14de/spdlog/include/spdlog/sinks/sink-inl.h

@@ -1,25 +0,0 @@
-// 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/sink.h>
-#endif
-
-#include <spdlog/common.h>
-
-SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const
-{
-    return msg_level >= level_.load(std::memory_order_relaxed);
-}
-
-SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level)
-{
-    level_.store(log_level, std::memory_order_relaxed);
-}
-
-SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const
-{
-    return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
-}

package/deps/couchbase-cxx-cache/spdlog/66ab2619a0014319471759c03e2de1af6bda14de/spdlog/include/spdlog/sinks/sink.h

@@ -1,35 +0,0 @@
-// 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

package/deps/couchbase-cxx-cache/spdlog/66ab2619a0014319471759c03e2de1af6bda14de/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h

@@ -1,38 +0,0 @@
-// 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/logger.h>
-#include <spdlog/common.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