couchbase 4.2.11 → 4.3.1

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

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

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

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

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

@@ -1,145 +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/ansicolor_sink.h>
-#endif
-
-#include <spdlog/pattern_formatter.h>
-#include <spdlog/details/os.h>
-
-namespace spdlog {
-namespace sinks {
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
-    : target_file_(target_file)
-    , mutex_(ConsoleMutex::mutex())
-    , formatter_(details::make_unique<spdlog::pattern_formatter>())
-
-{
-    set_color_mode(mode);
-    colors_.at(level::trace) = to_string_(white);
-    colors_.at(level::debug) = to_string_(cyan);
-    colors_.at(level::info) = to_string_(green);
-    colors_.at(level::warn) = to_string_(yellow_bold);
-    colors_.at(level::err) = to_string_(red_bold);
-    colors_.at(level::critical) = to_string_(bold_on_red);
-    colors_.at(level::off) = to_string_(reset);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, string_view_t color)
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    colors_.at(static_cast<size_t>(color_level)) = to_string_(color);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
-{
-    // Wrap the originally formatted message in color codes.
-    // If color is not supported in the terminal, log as is instead.
-    std::lock_guard<mutex_t> lock(mutex_);
-    msg.color_range_start = 0;
-    msg.color_range_end = 0;
-    memory_buf_t formatted;
-    formatter_->format(msg, formatted);
-    if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
-    {
-        // before color range
-        print_range_(formatted, 0, msg.color_range_start);
-        // in color range
-        print_ccode_(colors_.at(static_cast<size_t>(msg.level)));
-        print_range_(formatted, msg.color_range_start, msg.color_range_end);
-        print_ccode_(reset);
-        // after color range
-        print_range_(formatted, msg.color_range_end, formatted.size());
-    }
-    else // no color
-    {
-        print_range_(formatted, 0, formatted.size());
-    }
-    fflush(target_file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush()
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    fflush(target_file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<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 ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::move(sink_formatter);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color()
-{
-    return should_do_colors_;
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
-{
-    switch (mode)
-    {
-    case color_mode::always:
-        should_do_colors_ = true;
-        return;
-    case color_mode::automatic:
-        should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
-        return;
-    case color_mode::never:
-        should_do_colors_ = false;
-        return;
-    default:
-        should_do_colors_ = false;
-    }
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code)
-{
-    fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end)
-{
-    fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv)
-{
-    return std::string(sv.data(), sv.size());
-}
-
-// ansicolor_stdout_sink
-template<typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode)
-    : ansicolor_sink<ConsoleMutex>(stdout, mode)
-{}
-
-// ansicolor_stderr_sink
-template<typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
-    : ansicolor_sink<ConsoleMutex>(stderr, mode)
-{}
-
-} // namespace sinks
-} // namespace spdlog

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

@@ -1,118 +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/console_globals.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/sinks/sink.h>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <array>
-
-namespace spdlog {
-namespace sinks {
-
-/**
- * This sink prefixes the output with an ANSI escape sequence color code
- * depending on the severity
- * of the message.
- * If no color terminal detected, omit the escape codes.
- */
-
-template<typename ConsoleMutex>
-class ansicolor_sink : public sink
-{
-public:
-    using mutex_t = typename ConsoleMutex::mutex_t;
-    ansicolor_sink(FILE *target_file, color_mode mode);
-    ~ansicolor_sink() override = default;
-
-    ansicolor_sink(const ansicolor_sink &other) = delete;
-    ansicolor_sink(ansicolor_sink &&other) = delete;
-
-    ansicolor_sink &operator=(const ansicolor_sink &other) = delete;
-    ansicolor_sink &operator=(ansicolor_sink &&other) = delete;
-
-    void set_color(level::level_enum color_level, string_view_t color);
-    void set_color_mode(color_mode mode);
-    bool should_color();
-
-    void log(const details::log_msg &msg) override;
-    void flush() override;
-    void set_pattern(const std::string &pattern) final;
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
-
-    // Formatting codes
-    const string_view_t reset = "\033[m";
-    const string_view_t bold = "\033[1m";
-    const string_view_t dark = "\033[2m";
-    const string_view_t underline = "\033[4m";
-    const string_view_t blink = "\033[5m";
-    const string_view_t reverse = "\033[7m";
-    const string_view_t concealed = "\033[8m";
-    const string_view_t clear_line = "\033[K";
-
-    // Foreground colors
-    const string_view_t black = "\033[30m";
-    const string_view_t red = "\033[31m";
-    const string_view_t green = "\033[32m";
-    const string_view_t yellow = "\033[33m";
-    const string_view_t blue = "\033[34m";
-    const string_view_t magenta = "\033[35m";
-    const string_view_t cyan = "\033[36m";
-    const string_view_t white = "\033[37m";
-
-    /// Background colors
-    const string_view_t on_black = "\033[40m";
-    const string_view_t on_red = "\033[41m";
-    const string_view_t on_green = "\033[42m";
-    const string_view_t on_yellow = "\033[43m";
-    const string_view_t on_blue = "\033[44m";
-    const string_view_t on_magenta = "\033[45m";
-    const string_view_t on_cyan = "\033[46m";
-    const string_view_t on_white = "\033[47m";
-
-    /// Bold colors
-    const string_view_t yellow_bold = "\033[33m\033[1m";
-    const string_view_t red_bold = "\033[31m\033[1m";
-    const string_view_t bold_on_red = "\033[1m\033[41m";
-
-private:
-    FILE *target_file_;
-    mutex_t &mutex_;
-    bool should_do_colors_;
-    std::unique_ptr<spdlog::formatter> formatter_;
-    std::array<std::string, level::n_levels> colors_;
-    void print_ccode_(const string_view_t &color_code);
-    void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
-    static std::string to_string_(const string_view_t &sv);
-};
-
-template<typename ConsoleMutex>
-class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex>
-{
-public:
-    explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic);
-};
-
-template<typename ConsoleMutex>
-class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex>
-{
-public:
-    explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic);
-};
-
-using ansicolor_stdout_sink_mt = ansicolor_stdout_sink<details::console_mutex>;
-using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::console_nullmutex>;
-
-using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>;
-using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>;
-
-} // namespace sinks
-} // namespace spdlog
-
-#ifdef SPDLOG_HEADER_ONLY
-#    include "ansicolor_sink-inl.h"
-#endif

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

@@ -1,63 +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/base_sink.h>
-#endif
-
-#include <spdlog/common.h>
-#include <spdlog/pattern_formatter.h>
-
-#include <memory>
-
-template<typename Mutex>
-SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink()
-    : formatter_{details::make_unique<spdlog::pattern_formatter>()}
-{}
-
-template<typename Mutex>
-SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog::formatter> formatter)
-    : formatter_{std::move(formatter)}
-{}
-
-template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
-{
-    std::lock_guard<Mutex> lock(mutex_);
-    sink_it_(msg);
-}
-
-template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush()
-{
-    std::lock_guard<Mutex> lock(mutex_);
-    flush_();
-}
-
-template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern)
-{
-    std::lock_guard<Mutex> lock(mutex_);
-    set_pattern_(pattern);
-}
-
-template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
-{
-    std::lock_guard<Mutex> lock(mutex_);
-    set_formatter_(std::move(sink_formatter));
-}
-
-template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern)
-{
-    set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
-}
-
-template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter)
-{
-    formatter_ = std::move(sink_formatter);
-}

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

@@ -1,52 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-//
-// base sink templated over a mutex (either dummy or real)
-// concrete implementation should override the sink_it_() and flush_()  methods.
-// locking is taken care of in this class - no locking needed by the
-// implementers..
-//
-
-#include <spdlog/common.h>
-#include <spdlog/details/log_msg.h>
-#include <spdlog/sinks/sink.h>
-
-namespace spdlog {
-namespace sinks {
-template<typename Mutex>
-class SPDLOG_API base_sink : public sink
-{
-public:
-    base_sink();
-    explicit base_sink(std::unique_ptr<spdlog::formatter> formatter);
-    ~base_sink() override = default;
-
-    base_sink(const base_sink &) = delete;
-    base_sink(base_sink &&) = delete;
-
-    base_sink &operator=(const base_sink &) = delete;
-    base_sink &operator=(base_sink &&) = delete;
-
-    void log(const details::log_msg &msg) final;
-    void flush() final;
-    void set_pattern(const std::string &pattern) final;
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final;
-
-protected:
-    // sink formatter
-    std::unique_ptr<spdlog::formatter> formatter_;
-    Mutex mutex_;
-
-    virtual void sink_it_(const details::log_msg &msg) = 0;
-    virtual void flush_() = 0;
-    virtual void set_pattern_(const std::string &pattern);
-    virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);
-};
-} // namespace sinks
-} // namespace spdlog
-
-#ifdef SPDLOG_HEADER_ONLY
-#    include "base_sink-inl.h"
-#endif

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

@@ -1,44 +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/basic_file_sink.h>
-#endif
-
-#include <spdlog/common.h>
-#include <spdlog/details/os.h>
-
-namespace spdlog {
-namespace sinks {
-
-template<typename Mutex>
-SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers)
-    : file_helper_{event_handlers}
-{
-    file_helper_.open(filename, truncate);
-}
-
-template<typename Mutex>
-SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const
-{
-    return file_helper_.filename();
-}
-
-template<typename Mutex>
-SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
-{
-    memory_buf_t formatted;
-    base_sink<Mutex>::formatter_->format(msg, formatted);
-    file_helper_.write(formatted);
-}
-
-template<typename Mutex>
-SPDLOG_INLINE void basic_file_sink<Mutex>::flush_()
-{
-    file_helper_.flush();
-}
-
-} // namespace sinks
-} // namespace spdlog