couchbase 4.4.1-dev.1 → 4.4.1

package/deps/couchbase-cxx-cache/spdlog/25435891d500fa18cdfc40bd923333e006159907/spdlog/include/spdlog/sinks/qt_sinks.h

@@ -1,304 +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 <QPlainTextEdit>
-#include <QTextEdit>
-
-//
-// 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. By default, only ascii (latin1) is supported by this sink. Set is_utf8 to true if utf8
-// support is needed.
-template <typename Mutex>
-class qt_color_sink : public base_sink<Mutex> {
-public:
-    qt_color_sink(QTextEdit *qt_text_edit,
-                  int max_lines,
-                  bool dark_colors = false,
-                  bool is_utf8 = false)
-        : qt_text_edit_(qt_text_edit),
-          max_lines_(max_lines),
-          is_utf8_(is_utf8) {
-        if (!qt_text_edit_) {
-            throw_spdlog_ex("qt_color_text_sink: text_edit is null");
-        }
-
-        default_color_ = qt_text_edit_->currentCharFormat();
-        // set colors
-        QTextCharFormat format;
-        // trace
-        format.setForeground(dark_colors ? Qt::darkGray : Qt::gray);
-        colors_.at(level::trace) = format;
-        // debug
-        format.setForeground(dark_colors ? Qt::darkCyan : Qt::cyan);
-        colors_.at(level::debug) = format;
-        // info
-        format.setForeground(dark_colors ? Qt::darkGreen : Qt::green);
-        colors_.at(level::info) = format;
-        // warn
-        format.setForeground(dark_colors ? Qt::darkYellow : 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.
-        QString payload;
-        int color_range_start = static_cast<int>(msg.color_range_start);
-        int color_range_end = static_cast<int>(msg.color_range_end);
-        if (is_utf8_) {
-            payload = QString::fromUtf8(str.data(), static_cast<int>(str.size()));
-            // convert color ranges from byte index to character index.
-            if (msg.color_range_start < msg.color_range_end) {
-                color_range_start = QString::fromUtf8(str.data(), msg.color_range_start).size();
-                color_range_end = QString::fromUtf8(str.data(), msg.color_range_end).size();
-            }
-        } else {
-            payload = QString::fromLatin1(str.data(), static_cast<int>(str.size()));
-        }
-
-        invoke_params params{max_lines_,             // max lines
-                             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
-                             color_range_start,      // color range start
-                             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_;
-    bool is_utf8_;
-    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,
-                                                  bool is_utf8 = false) {
-    return Factory::template create<sinks::qt_color_sink_mt>(logger_name, qt_text_edit, max_lines,
-                                                             false, is_utf8);
-}
-
-template <typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> qt_color_logger_st(const std::string &logger_name,
-                                                  QTextEdit *qt_text_edit,
-                                                  int max_lines,
-                                                  bool is_utf8 = false) {
-    return Factory::template create<sinks::qt_color_sink_st>(logger_name, qt_text_edit, max_lines,
-                                                             false, is_utf8);
-}
-
-}  // namespace spdlog

package/deps/couchbase-cxx-cache/spdlog/25435891d500fa18cdfc40bd923333e006159907/spdlog/include/spdlog/stopwatch.h

@@ -1,62 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#include <chrono>
-#include <spdlog/fmt/fmt.h>
-
-// Stopwatch support for spdlog  (using std::chrono::steady_clock).
-// Displays elapsed seconds since construction as double.
-//
-// Usage:
-//
-// spdlog::stopwatch sw;
-// ...
-// spdlog::debug("Elapsed: {} seconds", sw);    =>  "Elapsed 0.005116733 seconds"
-// spdlog::info("Elapsed: {:.6} seconds", sw);  =>  "Elapsed 0.005163 seconds"
-//
-//
-// If other units are needed (e.g. millis instead of double), include "fmt/chrono.h" and use
-// "duration_cast<..>(sw.elapsed())":
-//
-// #include <spdlog/fmt/chrono.h>
-//..
-// using std::chrono::duration_cast;
-// using std::chrono::milliseconds;
-// spdlog::info("Elapsed {}", duration_cast<milliseconds>(sw.elapsed())); => "Elapsed 5ms"
-
-namespace spdlog {
-class stopwatch {
-    using clock = std::chrono::steady_clock;
-    std::chrono::time_point<clock> start_tp_;
-
-public:
-    stopwatch()
-        : start_tp_{clock::now()} {}
-
-    std::chrono::duration<double> elapsed() const {
-        return std::chrono::duration<double>(clock::now() - start_tp_);
-    }
-
-    void reset() { start_tp_ = clock::now(); }
-};
-}  // namespace spdlog
-
-// Support for fmt formatting  (e.g. "{:012.9}" or just "{}")
-namespace
-#ifdef SPDLOG_USE_STD_FORMAT
-    std
-#else
-    fmt
-#endif
-{
-
-template <>
-struct formatter<spdlog::stopwatch> : formatter<double> {
-    template <typename FormatContext>
-    auto format(const spdlog::stopwatch &sw, FormatContext &ctx) const -> decltype(ctx.out()) {
-        return formatter<double>::format(sw.elapsed().count(), ctx);
-    }
-};
-}  // namespace std

package/deps/couchbase-cxx-cache/spdlog/25435891d500fa18cdfc40bd923333e006159907/spdlog/include/spdlog/version.h

@@ -1,11 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#define SPDLOG_VER_MAJOR 1
-#define SPDLOG_VER_MINOR 13
-#define SPDLOG_VER_PATCH 0
-
-#define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch)
-#define SPDLOG_VERSION SPDLOG_TO_VERSION(SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH)

package/deps/couchbase-cxx-cache/spdlog/25435891d500fa18cdfc40bd923333e006159907/spdlog/src/bundled_fmtlib_format.cpp

@@ -1,49 +0,0 @@
-// Slightly modified version of fmt lib's format.cc (version 1.9.1) source file.
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-
-#ifndef SPDLOG_COMPILED_LIB
-    #error Please define SPDLOG_COMPILED_LIB to compile this file.
-#endif
-
-#if !defined(SPDLOG_FMT_EXTERNAL) && !defined(SPDLOG_USE_STD_FORMAT)
-
-    #include <spdlog/fmt/bundled/format-inl.h>
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template FMT_API auto dragonbox::to_decimal(float x) noexcept -> dragonbox::decimal_fp<float>;
-template FMT_API auto dragonbox::to_decimal(double x) noexcept -> dragonbox::decimal_fp<double>;
-
-    #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-template FMT_API locale_ref::locale_ref(const std::locale &loc);
-template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
-    #endif
-
-// Explicit instantiations for char.
-
-template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<char>;
-template FMT_API auto decimal_point_impl(locale_ref) -> char;
-
-template FMT_API void buffer<char>::append(const char *, const char *);
-
-// DEPRECATED!
-// There is no correspondent extern template in format.h because of
-// incompatibility between clang and gcc (#2377).
-template FMT_API void vformat_to(buffer<char> &,
-                                 string_view,
-                                 basic_format_args<FMT_BUFFER_CONTEXT(char)>,
-                                 locale_ref);
-
-// Explicit instantiations for wchar_t.
-
-template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<wchar_t>;
-template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
-
-template FMT_API void buffer<wchar_t>::append(const wchar_t *, const wchar_t *);
-
-}  // namespace detail
-FMT_END_NAMESPACE
-
-#endif  // !SPDLOG_FMT_EXTERNAL