couchbase 4.4.1-dev.2 → 4.4.1

package/deps/couchbase-cxx-cache/spdlog/19df5d3d8e5526c255d27414e09568671ef87483/spdlog/include/spdlog/sinks/qt_sinks.h

@@ -0,0 +1,304 @@
+// 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 children (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 colorized 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/19df5d3d8e5526c255d27414e09568671ef87483/spdlog/include/spdlog/stopwatch.h

@@ -0,0 +1,66 @@
+// 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_);
+    }
+
+    std::chrono::milliseconds elapsed_ms() const {
+        return std::chrono::duration_cast<std::chrono::milliseconds>(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/19df5d3d8e5526c255d27414e09568671ef87483/spdlog/include/spdlog/version.h

@@ -0,0 +1,11 @@
+// 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 14
+#define SPDLOG_VER_PATCH 1
+
+#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/19df5d3d8e5526c255d27414e09568671ef87483/spdlog/src/bundled_fmtlib_format.cpp

@@ -0,0 +1,46 @@
+// Slightly modified version of fmt lib's format.cc 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*);
+
+template FMT_API void vformat_to(buffer<char>&,
+                                 string_view,
+                                 typename vformat_args<>::type,
+                                 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

package/deps/couchbase-cxx-client/CMakeLists.txt

@@ -14,9 +14,14 @@ if(NOT DEFINED COUCHBASE_CXX_CLIENT_MASTER_PROJECT)
   endif()
 endif()
 
+option(COUCHBASE_CXX_CLIENT_COLUMNAR "Build with Columnar additions" FALSE)
+if(COUCHBASE_CXX_CLIENT_COLUMNAR)
+  message(STATUS "COUCHBASE_CXX_CLIENT_COLUMNAR=${COUCHBASE_CXX_CLIENT_COLUMNAR} building with Columnar additions.")
+endif()
+
 project(
   couchbase_cxx_client
-  VERSION "1.0.0"
+  VERSION "1.0.1"
   LANGUAGES CXX C)
 message(STATUS "Couchbase C++ client ${couchbase_cxx_client_VERSION} build ${couchbase_cxx_client_BUILD_NUMBER}, master: ${COUCHBASE_CXX_CLIENT_MASTER_PROJECT}")
 message(STATUS "System: ${CMAKE_SYSTEM_NAME}, ${CMAKE_SYSTEM_VERSION}, ${CMAKE_SYSTEM_PROCESSOR}")
@@ -219,10 +224,14 @@ set(couchbase_cxx_client_FILES
     core/impl/scan_result.cxx
     core/io/dns_client.cxx
     core/io/dns_config.cxx
+    core/io/http_session.cxx
     core/io/http_parser.cxx
+    core/io/http_streaming_parser.cxx
+    core/io/http_streaming_response.cxx
     core/io/mcbp_message.cxx
     core/io/mcbp_parser.cxx
     core/io/mcbp_session.cxx
+    core/io/config_tracker.cxx
     core/key_value_config.cxx
     core/management/analytics_link_azure_blob_external.cxx
     core/management/analytics_link_couchbase_remote.cxx
@@ -371,6 +380,7 @@ set(couchbase_cxx_client_FILES
     core/range_scan_options.cxx
     core/range_scan_orchestrator.cxx
     core/retry_orchestrator.cxx
+    core/row_streamer.cxx
     core/scan_result.cxx
     core/search_query_options.cxx
     core/seed_config.cxx
@@ -409,6 +419,14 @@ set(couchbase_cxx_client_FILES
     core/utils/split_string.cxx
     core/utils/url_codec.cxx
     core/view_query_options.cxx
+    core/http_component.cxx
+    core/columnar/agent.cxx
+    core/columnar/agent_config.cxx
+    core/columnar/error.cxx
+    core/columnar/error_codes.cxx
+    core/columnar/query_component.cxx
+    core/columnar/query_result.cxx
+    core/columnar/backoff_calculator.cxx
 )
 
 if(COUCHBASE_CXX_CLIENT_BUILD_SHARED OR BUILD_SHARED_LIBS)
@@ -419,12 +437,17 @@ endif()
 add_library(couchbase_cxx_client::couchbase_cxx_client ALIAS couchbase_cxx_client)
 set_target_properties(couchbase_cxx_client PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
-target_include_directories(couchbase_cxx_client PRIVATE ${PROJECT_BINARY_DIR}/generated)
-target_include_directories(couchbase_cxx_client PUBLIC ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/private)
+target_include_directories(couchbase_cxx_client PRIVATE ${PROJECT_BINARY_DIR}/generated ${PROJECT_BINARY_DIR}/generated_$<CONFIG>)
+target_include_directories(couchbase_cxx_client PUBLIC ${PROJECT_SOURCE_DIR})
 target_include_directories(couchbase_cxx_client SYSTEM PUBLIC ${PROJECT_SOURCE_DIR}/third_party/cxx_function
                                                               ${PROJECT_SOURCE_DIR}/third_party/expected/include)
 target_link_libraries(couchbase_cxx_client PRIVATE project_options project_warnings)
 
+if (COUCHBASE_CXX_CLIENT_CLANG_TIDY)
+  set_target_properties(couchbase_cxx_client PROPERTIES CXX_CLANG_TIDY "${COUCHBASE_CXX_CLIENT_CLANG_TIDY}")
+  message(STATUS "clang-tidy: ${COUCHBASE_CXX_CLIENT_CLANG_TIDY}")
+endif()
+
 include(cmake/DetectStandardFilesystem.cmake)
 couchbase_cxx_check_filesystem(
   couchbase_cxx_client

package/deps/couchbase-cxx-client/README.md

@@ -21,9 +21,9 @@ CPMAddPackage(
   NAME
   couchbase_cxx_client
   GIT_TAG
-  1.0.0
+  1.0.1
   VERSION
-  1.0.0
+  1.0.1
   GITHUB_REPOSITORY
   "couchbase/couchbase-cxx-client"
   OPTIONS

package/deps/couchbase-cxx-client/cmake/0001-fix-build-for-mingw-w64-ucrt-x86_64-toolchain.patch

@@ -28,11 +28,12 @@ index 0cd1a12aa..ab33badc0 100644
 --- a/src/crypto/curve25519/internal.h
 +++ b/src/crypto/curve25519/internal.h
 @@ -32,7 +32,7 @@ void x25519_NEON(uint8_t out[32], const uint8_t scalar[32],
-#endif
+ #endif
 
-#if !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_SMALL) && -defined(__GNUC__) && defined(__x86_64__)
+ #if !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_SMALL) && \
+-    defined(__GNUC__) && defined(__x86_64__)
 +    defined(__GNUC__) && defined(__x86_64__) && !defined(__MINGW32__)
-#define BORINGSSL_FE25519_ADX
+ #define BORINGSSL_FE25519_ADX
 
  // fiat_curve25519_adx_mul is defined in
 --

package/deps/couchbase-cxx-client/cmake/CompilerWarnings.cmake

@@ -31,6 +31,7 @@ function(set_project_warnings project_name)
       /w14906 # string literal cast to 'LPWSTR'
       /w14928 # illegal copy-initialization; more than one user-defined conversion has been implicitly applied
       /permissive- # standards conformance mode for MSVC compiler.
+      /utf-8  # enable Unicode support
   )
 
   set(COMMON_WARNINGS

package/deps/couchbase-cxx-client/cmake/OpenSSL.cmake

@@ -233,10 +233,14 @@ file(
   "
 #include \"core/mozilla_ca_bundle.hxx\"
 
+#include <gsl/span>
+
+#include <array>
+#include <string_view>
+
 namespace couchbase::core::default_ca
 {
-constexpr inline std::size_t number_of_certificates{ ${NUMBER_OF_CERTIFICATES} };
-constexpr inline certificate certificates[]{
+constexpr inline std::array<certificate, ${NUMBER_OF_CERTIFICATES}> certificates{
 ")
 foreach(CERTIFICATE ${CERTIFICATES})
   string(
@@ -244,30 +248,33 @@ foreach(CERTIFICATE ${CERTIFICATES})
           "[ \t\r\n]*([^=\n]+)[ \t\r\n]*=+\n(-----BEGIN CERTIFICATE-----[^-]+-----END CERTIFICATE-----)"
           PARTS
           ${CERTIFICATE})
-  file(APPEND ${CA_BUNDLE_CPP_FILE} "    { R\"(${CMAKE_MATCH_1})\",\n      R\"(${CMAKE_MATCH_2})\" },\n\n")
+  file(APPEND ${CA_BUNDLE_CPP_FILE}
+"  certificate{ R\"(${CMAKE_MATCH_1})\",
+               R\"(${CMAKE_MATCH_2})\" },
+
+")
 endforeach()
 
 file(
   APPEND ${CA_BUNDLE_CPP_FILE}
-  "    { \"\", \"\" },
-};
+"};
 
 auto
 mozilla_ca_certs() -> gsl::span<const certificate>
 {
-    return { certificates, number_of_certificates };
+  return certificates;
 }
 
 auto
 mozilla_ca_certs_date() -> std::string_view
 {
-    return \"${COUCHBASE_CXX_CLIENT_MOZILLA_CA_BUNDLE_DATE}\";
+  return \"${COUCHBASE_CXX_CLIENT_MOZILLA_CA_BUNDLE_DATE}\";
 }
 
 auto
 mozilla_ca_certs_sha256() -> std::string_view
 {
-    return \"${COUCHBASE_CXX_CLIENT_MOZILLA_CA_BUNDLE_SHA256}\";
+  return \"${COUCHBASE_CXX_CLIENT_MOZILLA_CA_BUNDLE_SHA256}\";
 }
 } // namespace couchbase::core::default_ca
 ")

package/deps/couchbase-cxx-client/cmake/StandardProjectSettings.cmake

@@ -31,7 +31,7 @@ if(ENABLE_IPO)
   endif()
 endif()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang" AND NOT WIN32)
   add_compile_options(-fcolor-diagnostics)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT MINGW)
   add_compile_options(-fdiagnostics-color=always)

package/deps/couchbase-cxx-client/cmake/StaticAnalyzers.cmake

@@ -5,23 +5,45 @@ option(ENABLE_INCLUDE_WHAT_YOU_USE "Enable static analysis with include-what-you
 if(ENABLE_CPPCHECK)
   find_program(CPPCHECK cppcheck)
   if(CPPCHECK)
+    set(CPPCHECK_EXTRA_ARGS "")
+    if(ENABLE_CPPCHECK_INCONCLUSIVE)
+      set(CPPCHECK_EXTRA_ARGS "${CPPCHECK_EXTRA_ARGS} --inconclusive")
+    endif()
     set(CMAKE_CXX_CPPCHECK
         ${CPPCHECK}
-        --suppress=missingInclude
+        --error-exitcode=42
+        --verbose
+        --std=c++17
         --enable=all
         --inline-suppr
-        --inconclusive
-        -i
-        ${CMAKE_SOURCE_DIR}/imgui/lib)
+        --check-level=exhaustive
+        --suppressions-list=${PROJECT_SOURCE_DIR}/.cppcheck_suppressions.txt
+        ${CPPCHECK_EXTRA_ARGS})
   else()
     message(SEND_ERROR "cppcheck requested but executable not found")
   endif()
 endif()
 
 if(ENABLE_CLANG_TIDY)
-  find_program(CLANGTIDY clang-tidy)
+  option(ENABLE_CLANG_TIDY_FIX "Try to fix the code if clang-tidy can propose a solution" OFF)
+  if(APPLE)
+    execute_process(
+      COMMAND brew --prefix llvm
+      OUTPUT_VARIABLE LLVM_ROOT_DIR
+      ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+  endif()
+
+  if(LLVM_ROOT_DIR)
+    find_program(CLANGTIDY clang-tidy HINTS "${LLVM_ROOT_DIR}/bin")
+  else()
+    find_program(CLANGTIDY clang-tidy)
+  endif()
   if(CLANGTIDY)
-    set(CMAKE_CXX_CLANG_TIDY ${CLANGTIDY} -extra-arg=-Wno-unknown-warning-option)
+    set(COUCHBASE_CXX_CLIENT_CLANG_TIDY "${CLANGTIDY};-extra-arg=-Wno-unknown-warning-option")
+    if(ENABLE_CLANG_TIDY_FIX)
+      set(COUCHBASE_CXX_CLIENT_CLANG_TIDY
+          "${COUCHBASE_CXX_CLIENT_CLANG_TIDY};-fix;-export-fixes=${PROJECT_BINARY_DIR}/clang-tidy-fixes.yaml")
+    endif()
   else()
     message(SEND_ERROR "clang-tidy requested but executable not found")
   endif()