couchbase 3.8.1 → 3.9.0

data/ext/couchbase/core/utils/movable_function.hxx

@@ -17,106 +17,355 @@
 
 #pragma once
 
+#include <cstddef>
 #include <functional>
 #include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
 
-/* replace with standard version once http://wg21.link/P0288 will be accepted and implemented */
+/* replace with std::move_only_function once http://wg21.link/P0288 is available (C++23) */
 namespace couchbase::core::utils
 {
+#ifdef __clang_analyzer__
+// Declared but never defined: an opaque sink (analysis only; analysis does not link, and it is
+// absent from every real build). See emplace() below -- handing the owned target pointer to a
+// non-const opaque sink marks it "escaped" so MallocChecker stops tracking an allocation it would
+// otherwise lose inside asio's deeply templated post/dispatch machinery and report as a spurious
+// leak. The parameter is NON-const on purpose: checkPointerEscapeAux only releases a symbol through
+// a const pointer when it is new/new[]-family, but unconditionally through a non-const pointer.
+void
+movable_function_analyzer_escape(void*) noexcept;
+#endif
+
 template<typename Signature>
-class movable_function : public std::function<Signature>
-{
-  template<typename Functor, typename En = void>
-  struct wrapper;
+class movable_function;
 
-  template<typename Functor>
-  struct wrapper<Functor, std::enable_if_t<std::is_copy_constructible_v<Functor>>> {
-    Functor fn;
+/**
+ * A move-only, type-erased callable, equivalent in spirit to std::move_only_function (C++23).
+ *
+ * A target that fits the inline buffer and is nothrow-move-constructible is stored in place, so the
+ * common asio/KV handlers (a captured shared_ptr `self` plus a few members) are type-erased with no
+ * heap allocation; larger targets are held on the heap. The type owns its target and transfers
+ * ownership on move (copying is not provided). It offers `operator bool` and comparison against
+ * nullptr, and throws std::bad_function_call when invoked while empty.
+ */
+template<typename R, typename... Args>
+class movable_function<R(Args...)>
+{
+#ifdef __clang_analyzer__
+  // Analyzer-only implementation (compiled only under the Clang Static Analyzer, never in real
+  // builds). The production small-buffer path below frees its target through an indirect
+  // `vtable_->destroy(buffer_)` function pointer the analyzer cannot resolve; blind to the free,
+  // MallocChecker reports spurious "Potential memory leak" at every caller that stores a
+  // heap-owning handler (libstdc++'s own std::move_only_function hits the identical limitation,
+  // llvm-project#69602). Under analysis we instead own the target via
+  // std::unique_ptr<callable_base>, whose destruction is an ordinary virtual delete that
+  // MallocChecker models natively -- no manual vtable, no unresolved indirect free, no escape
+  // heuristics. This models the same own-once / free-once / move-transfers semantics as the real
+  // path, so it does not mask genuine leaks.
+  struct callable_base {
+    callable_base() = default;
+    callable_base(const callable_base&) = delete;
+    callable_base(callable_base&&) = delete;
+    auto operator=(const callable_base&) -> callable_base& = delete;
+    auto operator=(callable_base&&) -> callable_base& = delete;
+    virtual ~callable_base() = default;
+    virtual auto invoke(Args... args) -> R = 0;
+  };
 
-    template<typename... Args>
-    auto operator()(Args&&... args)
+  template<typename F>
+  struct callable_model : callable_base {
+    F fn;
+    // Forwarding ctor so the target is copied from an lvalue or moved from an rvalue, matching the
+    // production `decayed(std::forward<F>(f))` -- a plain `F&&` parameter would reject lvalue
+    // targets.
+    template<typename U>
+    explicit callable_model(U&& u)
+      : fn(std::forward<U>(u))
+    {
+    }
+    auto invoke(Args... args) -> R override
     {
-      return fn(std::forward<Args>(args)...);
+      if constexpr (std::is_void_v<R>) {
+        fn(std::forward<Args>(args)...);
+      } else {
+        return fn(std::forward<Args>(args)...);
+      }
     }
   };
 
-  template<typename Functor>
-  struct copy_wrapper {
-    Functor fn;
+  std::unique_ptr<callable_base> holder_{};
 
-    explicit copy_wrapper(Functor&& f)
-      : fn(std::move(f))
-    {
-    }
+  template<typename F>
+  void emplace(F&& f)
+  {
+    holder_ = std::make_unique<callable_model<std::decay_t<F>>>(std::forward<F>(f));
+    // Escape the owned block: some callers (e.g. asio::post/dispatch) move *this into templated
+    // machinery the analyzer cannot follow, where it would otherwise lose this allocation and
+    // report a spurious leak. holder_.get() is a direct object pointer, so the non-const escape
+    // releases exactly the callable_model block (see the sink declaration).
+    movable_function_analyzer_escape(static_cast<void*>(holder_.get()));
+  }
+
+  void move_from(movable_function&& other) noexcept
+  {
+    holder_ = std::move(other.holder_);
+  }
+
+  void reset() noexcept
+  {
+    holder_.reset();
+  }
+#else
+  // Sized to hold typical handlers (e.g. a shared_ptr self, a time_point, and a shared_ptr span)
+  // inline; larger callables fall back to the heap. The 6-pointer estimate is 48 bytes on 64-bit;
+  // a 48-byte floor keeps that inline capacity on 32-bit too (where 6 pointers would be only 24
+  // bytes), so the small-buffer optimization does not silently regress to more heap allocations.
+  static constexpr std::size_t buffer_size = (6 * sizeof(void*) > 48) ? (6 * sizeof(void*)) : 48;
+
+  struct vtable {
+    R (*invoke)(void* self, Args&&... args);
+    void (*move)(void* dst, void* src) noexcept; // move-construct dst from src, then destroy src
+    void (*destroy)(void* self) noexcept;
   };
 
-  template<typename Functor>
-  struct wrapper<Functor,
-                 std::enable_if_t<!std::is_copy_constructible_v<Functor> &&
-                                  std::is_move_constructible_v<Functor>>> {
-    std::shared_ptr<copy_wrapper<Functor>> fnPtr;
+  template<typename F>
+  static constexpr bool fits_inline_v =
+    sizeof(F) <= buffer_size && alignof(F) <= alignof(std::max_align_t) &&
+    std::is_nothrow_move_constructible_v<F>;
 
-    explicit wrapper(Functor&& f)
-      : fnPtr(new copy_wrapper<Functor>(std::move(f)))
-    {
-    }
+  template<typename F>
+  static auto inline_vtable() -> const vtable&
+  {
+    // The target lives in buffer_ (an unsigned char array) via placement-new, so accesses go
+    // through std::launder to obtain a pointer with the target's lifetime rather than the array's.
+    static const vtable vt{
+      [](void* self, Args&&... args) -> R {
+        // For a void signature the target's result is discardable (std::is_invocable_r_v<void, ...>
+        // admits a value-returning callable), so a value-returning target must be invoked without a
+        // return statement -- `return <non-void>;` in a void thunk is ill-formed.
+        if constexpr (std::is_void_v<R>) {
+          (*std::launder(static_cast<F*>(self)))(std::forward<Args>(args)...);
+        } else {
+          return (*std::launder(static_cast<F*>(self)))(std::forward<Args>(args)...);
+        }
+      },
+      [](void* dst, void* src) noexcept {
+        ::new (dst) F(std::move(*std::launder(static_cast<F*>(src))));
+        std::launder(static_cast<F*>(src))->~F();
+      },
+      [](void* self) noexcept {
+        std::launder(static_cast<F*>(self))->~F();
+      },
+    };
+    return vt;
+  }
 
-    wrapper(wrapper&& /* other */) noexcept = default;
-    auto operator=(wrapper&& /* other */) noexcept -> wrapper& = default;
+  template<typename F>
+  static auto heap_vtable() -> const vtable&
+  {
+    // The buffer holds an owned F* (placement-new'd in emplace()), so every access to that pointer
+    // goes through std::launder to reflect the pointer object's lifetime, not the array's.
+    static const vtable vt{
+      [](void* self, Args&&... args) -> R {
+        // Same void-result handling as the inline thunk: discard a value-returning target rather
+        // than emit `return <non-void>;` in a void-returning thunk.
+        if constexpr (std::is_void_v<R>) {
+          (**std::launder(static_cast<F**>(self)))(std::forward<Args>(args)...);
+        } else {
+          return (**std::launder(static_cast<F**>(self)))(std::forward<Args>(args)...);
+        }
+      },
+      [](void* dst, void* src) noexcept {
+        // Begin the lifetime of the owned pointer in dst (uninitialized storage) rather than
+        // assigning through an F** into it, matching the placement-new in emplace(). The alias
+        // keeps this a new-expression rather than something that reads as a C-style cast.
+        using owned_ptr = F*;
+        ::new (dst) owned_ptr(*std::launder(static_cast<F**>(src)));
+        *std::launder(static_cast<F**>(src)) = nullptr;
+      },
+      [](void* self) noexcept {
+        delete *std::launder(static_cast<F**>(self));
+      },
+    };
+    return vt;
+  }
 
-    wrapper(const wrapper& other) = default;
-    auto operator=(const wrapper& /* other */) -> wrapper& = default;
+  // Zero-initialized so the object has no uninitialized members; the bytes are always overwritten
+  // by emplace()/move_from() before vtable_ is set and are only ever read back through vtable_
+  // (null while the buffer holds no target), so the initialization is defensive, not relied upon.
+  alignas(std::max_align_t) unsigned char buffer_[buffer_size]{};
+  const vtable* vtable_{ nullptr };
 
-    template<typename... Args>
-    auto operator()(Args&&... args)
-    {
-      return std::move(fnPtr->fn)(std::forward<Args>(args)...);
+// MSVC emits C4702 (unreachable code) during a late optimization pass, not during parsing, so a
+// push/pop around the individual store does not catch it -- the suppression must wrap the whole
+// function. For an F whose selected constructor can only throw (e.g. throwing_copy_functor in the
+// unit tests) MSVC proves construction never returns and flags every following statement as
+// unreachable; every other F reaches them normally, so the warning is a false positive here.
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4702)
+#endif
+  template<typename F>
+  void emplace(F&& f)
+  {
+    using decayed = std::decay_t<F>;
+    if constexpr (fits_inline_v<decayed>) {
+      ::new (static_cast<void*>(buffer_)) decayed(std::forward<F>(f));
+      vtable_ = &inline_vtable<decayed>();
+    } else {
+      // Begin the lifetime of a decayed* in the buffer (symmetric with the inline placement-new
+      // above), then read it back through the heap vtable.
+      ::new (static_cast<void*>(buffer_)) decayed*(new decayed(std::forward<F>(f)));
+      vtable_ = &heap_vtable<decayed>();
     }
-  };
+  }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
 
-  using base = std::function<Signature>;
+  void move_from(movable_function&& other) noexcept
+  {
+    if (other.vtable_ != nullptr) {
+      other.vtable_->move(buffer_, other.buffer_);
+      vtable_ = other.vtable_;
+      other.vtable_ = nullptr;
+    }
+  }
+
+  void reset() noexcept
+  {
+    if (vtable_ != nullptr) {
+      vtable_->destroy(buffer_);
+      vtable_ = nullptr;
+    }
+  }
+#endif
+
+  // Constrain on constructibility as well as invocability: emplace() stores the target by
+  // constructing a std::decay_t<F> from the forwarded argument, so a callable that cannot be
+  // constructed there (e.g. a non-movable functor passed as an rvalue) is removed from overload
+  // resolution rather than producing a hard error inside emplace().
+  //
+  // std::conjunction, not &&: the terms have to be instantiated one at a time, stopping at the
+  // first that is false. Asking whether this type is copy constructible -- which anything holding
+  // it in a std::any does -- instantiates this constraint with F = const movable_function&, and the
+  // constructibility term then asks for the trait that is already being computed. && evaluates
+  // lazily but instantiates every operand regardless, so the self-exclusion has to gate the others
+  // rather than merely precede them.
+  template<typename F>
+  using enable_if_callable = std::enable_if_t<
+    std::conjunction_v<std::negation<std::is_same<std::decay_t<F>, movable_function>>,
+                       std::is_constructible<std::decay_t<F>, F>,
+                       std::is_invocable_r<R, std::decay_t<F>&, Args...>>>;
 
 public:
   movable_function() noexcept = default;
   movable_function(std::nullptr_t) noexcept
-    : base(nullptr)
   {
   }
 
-  template<typename Functor>
-  movable_function(Functor&& f)
-    : base(wrapper<Functor>{ std::forward<Functor>(f) })
+  template<typename F, typename = enable_if_callable<F>>
+  movable_function(F&& f)
   {
+    emplace(std::forward<F>(f));
   }
 
   movable_function(movable_function&& other) noexcept
-    : base(std::move(static_cast<base&&>(other)))
   {
-    other = nullptr;
+    move_from(std::move(other));
   }
 
   auto operator=(movable_function&& other) noexcept -> movable_function&
   {
-    base::operator=(std::move(static_cast<base&&>(other)));
-    other = nullptr;
+    if (this != &other) {
+      reset();
+      move_from(std::move(other));
+    }
     return *this;
   }
 
-  auto operator=(std::nullptr_t /* other */) -> movable_function&
+  movable_function(const movable_function&) = delete;
+  auto operator=(const movable_function&) -> movable_function& = delete;
+
+  ~movable_function()
   {
-    base::operator=(nullptr);
+    reset();
+  }
+
+  auto operator=(std::nullptr_t) noexcept -> movable_function&
+  {
+    reset();
     return *this;
   }
 
-  template<typename Functor>
-  auto operator=(Functor&& f) -> movable_function&
+// Same MSVC C4702 false positive as emplace(), and the same whole-function suppression: for an F
+// whose constructor can only throw, the temporary below can never return normally, so MSVC flags
+// the assignment and return as unreachable, even though every other F reaches them normally.
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4702)
+#endif
+  template<typename F, typename = enable_if_callable<F>>
+  auto operator=(F&& f) -> movable_function&
   {
-    base::operator=(wrapper<Functor>{ std::forward<Functor>(f) });
+    // Strong exception guarantee, matching std::function / std::move_only_function: build the new
+    // target in a temporary first -- the only step that can throw (heap allocation, or a throwing
+    // copy when f is an lvalue) -- then adopt it through the noexcept move-assignment. A bare
+    // reset()+emplace() would give only the basic guarantee: a throwing emplace() would leave the
+    // previous target already destroyed and *this empty.
+    *this = movable_function(std::forward<F>(f));
     return *this;
   }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+  explicit operator bool() const noexcept
+  {
+#ifdef __clang_analyzer__
+    return static_cast<bool>(holder_);
+#else
+    return vtable_ != nullptr;
+#endif
+  }
+
+  friend auto operator==(const movable_function& f, std::nullptr_t) noexcept -> bool
+  {
+    return !static_cast<bool>(f);
+  }
+
+  friend auto operator==(std::nullptr_t, const movable_function& f) noexcept -> bool
+  {
+    return !static_cast<bool>(f);
+  }
+
+  friend auto operator!=(const movable_function& f, std::nullptr_t) noexcept -> bool
+  {
+    return static_cast<bool>(f);
+  }
 
-  using base::operator bool;
-  using base::operator();
+  friend auto operator!=(std::nullptr_t, const movable_function& f) noexcept -> bool
+  {
+    return static_cast<bool>(f);
+  }
+
+  auto operator()(Args... args) const -> R
+  {
+#ifdef __clang_analyzer__
+    if (!holder_) {
+      throw std::bad_function_call{};
+    }
+    return holder_->invoke(std::forward<Args>(args)...);
+#else
+    if (vtable_ == nullptr) {
+      throw std::bad_function_call{};
+    }
+    return vtable_->invoke(const_cast<void*>(static_cast<const void*>(buffer_)),
+                           std::forward<Args>(args)...);
+#endif
+  }
 };
 
 } // namespace couchbase::core::utils

data/ext/couchbase/core/utils/name_codec.hxx

@@ -17,25 +17,168 @@
 
 #pragma once
 
-#include <sstream>
+#include <algorithm>
+#include <initializer_list>
 #include <string>
+#include <string_view>
 
 namespace couchbase::core::utils
 {
+/**
+ * Renders names as Analytics SQL++ delimited identifiers.
+ *
+ * Two distinct operations are involved, and this file keeps them apart deliberately:
+ *
+ *   - QUOTING wraps a name in backticks so the parser reads it as one identifier token instead of
+ *     as keywords and punctuation. Analytics calls the result a delimited identifier.
+ *   - ESCAPING rewrites individual characters inside those backticks so that none of them can end
+ *     the token early or be reinterpreted by the parser.
+ *
+ * Both are needed: quoting alone is not safe, because a character inside the quotes can still
+ * terminate them.
+ *
+ * The grammar for a delimited identifier is (asterix-lang-sqlpp SQLPP.jj, token QUOTED_STRING):
+ *
+ *     "`" ( "\\\\" | "\\\"" | "\\/" | "\\b" | "\\f" | "\\n" | "\\r" | "\\t" | ~["`","\\"] )* "`"
+ *
+ * so the only escape mechanism is a backslash sequence, and the only two characters with any
+ * special meaning inside the quotes are the backslash and the backtick. Three consequences shape
+ * this code:
+ *
+ *   - THE BACKSLASH MUST BE ESCAPED, as "\\\\". It is the escape introducer, and before the lexer
+ *     ever runs, the character stream expands a \\uXXXX sequence into the character it denotes
+ *     (JavaCharStream::readChar). That expansion fires only when the backslash run preceding the
+ *     'u' is of odd length, so doubling every backslash makes every run even and puts the
+ *     expansion permanently out of reach. Leaving backslashes alone instead would let the six
+ *     characters \\u0060 become a real backtick and close the identifier.
+ *
+ *   - A BACKTICK CANNOT BE ESCAPED AT ALL, so a name containing one has no representation as a
+ *     delimited identifier. Note that doubling it is NOT an escape here: unlike a string literal,
+ *     whose grammar rule concatenates adjacent tokens and so does give "``" the meaning of one
+ *     literal quote, an identifier is a single token with no such rule, and "`a``b`" is simply two
+ *     adjacent tokens. Requests reject these names up front via all_quotable(); see the note on
+ *     append_escaped() for what happens if one gets through anyway.
+ *
+ *   - NOTHING ELSE NEEDS ESCAPING. Every other byte, including a raw quote, slash, newline, tab,
+ *     NUL and anything above 0x7f, is matched by ~["`","\\"] and passes through unchanged. In
+ *     particular a double quote must NOT be escaped as "\\\"": the server only honours that escape
+ *     when the escaped character is the same as the opening delimiter, so inside backticks it
+ *     would silently drop the quote and corrupt the name.
+ */
 struct analytics {
-  static auto uncompound_name(const std::string& name) -> std::string
+  /**
+   * True when every name can be quoted, i.e. none of them contains a backtick.
+   *
+   * Requests call this before building a statement and fail with errc::common::invalid_argument
+   * when it returns false. It reports only whether the whole set is usable, not which name was at
+   * fault: the encoders return a single error code and have no channel for a richer message.
+   */
+  [[nodiscard]] static auto all_quotable(std::initializer_list<std::string_view> names) -> bool
   {
-    std::stringstream ss;
-    ss << '`';
+    return std::all_of(names.begin(), names.end(), [](const auto name) {
+      return name.find('`') == std::string_view::npos;
+    });
+  }
+
+  /**
+   * Quotes a name as a single delimited identifier, escaping its body.
+   *
+   * Preconditions: all_quotable({ name }). Separators are not interpreted, so a '.' or '/' in the
+   * name becomes part of the identifier rather than splitting it.
+   */
+  [[nodiscard]] static auto quote_identifier(const std::string& name) -> std::string
+  {
+    std::string result;
+    result.reserve(name.size() + 2);
+    result.push_back('`');
     for (const auto symbol : name) {
-      if (symbol == '/') {
-        ss << "`.`";
-      } else {
-        ss << symbol;
+      append_escaped(result, symbol);
+    }
+    result.push_back('`');
+    return result;
+  }
+
+  /**
+   * Quotes a dotted field path ("address.city") by quoting each segment separately and rejoining
+   * them with an unquoted '.', so that the parser sees a path of identifiers rather than one
+   * identifier containing dots.
+   *
+   * Preconditions: all_quotable({ path }).
+   */
+  [[nodiscard]] static auto quote_field_path(const std::string& path) -> std::string
+  {
+    return quote_parts(path, '.', '.');
+  }
+
+  /**
+   * Quotes a dataverse name, which the SDK spells as a '/'-separated compound ("bucket/scope"),
+   * into the dot-qualified form the statement needs: "bucket/scope" becomes `bucket`.`scope`.
+   *
+   * Preconditions: all_quotable({ name }).
+   *
+   * This is a pure encoder: it does not substitute a default for an empty name. Requests that treat
+   * the dataverse as optional already default it to "Default" in their own declarations, and the
+   * two that do not (analytics_dataverse_create, analytics_dataverse_drop) take the dataverse as a
+   * required argument naming the object to create or drop, where silently retargeting an empty name
+   * onto "Default" would be destructive.
+   */
+  [[nodiscard]] static auto quote_dataverse_name(const std::string& name) -> std::string
+  {
+    return quote_parts(name, '/', '.');
+  }
+
+private:
+  /**
+   * Splits on separator, quotes each part, and rejoins with joiner. The separator itself is never
+   * escaped, because it is consumed here rather than passed to quote_identifier(); an empty part
+   * yields an empty identifier, which the server rejects rather than misinterprets.
+   */
+  [[nodiscard]] static auto quote_parts(const std::string& name, char separator, char joiner)
+    -> std::string
+  {
+    std::string result;
+    result.reserve(name.size() + 2);
+    for (std::size_t start = 0;;) {
+      const auto pos = name.find(separator, start);
+      // Standing in for "this is not the first part", which holds only because quote_identifier()
+      // never returns an empty string. Were that to change, a leading separator would lose its
+      // empty first part and silently retarget the name instead of producing one the server
+      // rejects.
+      if (!result.empty()) {
+        result.push_back(joiner);
       }
+      result.append(quote_identifier(
+        name.substr(start, pos == std::string::npos ? std::string::npos : pos - start)));
+      if (pos == std::string::npos) {
+        return result;
+      }
+      start = pos + 1;
+    }
+  }
+
+  /**
+   * Appends one character of an identifier body.
+   *
+   * The backslash is escaped, which is the whole of what escaping means here. The backtick has no
+   * escape, so it cannot be handled correctly at all; emitting it doubled is a deliberate last
+   * resort for a name that reached this point without passing all_quotable(). It produces two
+   * adjacent identifier tokens and therefore an unparseable statement, which fails closed, rather
+   * than a lone backtick, which would end the identifier and let the rest of the name be parsed as
+   * SQL++. It is a backstop against a future caller forgetting the precondition, not an escape.
+   */
+  static void append_escaped(std::string& result, char symbol)
+  {
+    switch (symbol) {
+      case '\\':
+        result.append("\\\\");
+        break;
+      case '`':
+        result.append("``");
+        break;
+      default:
+        result.push_back(symbol);
+        break;
     }
-    ss << '`';
-    return ss.str();
   }
 };
-} // namespace couchbase::core::utils
+} // namespace couchbase::core::utils

data/ext/couchbase/core/{columnar/retry_info.hxx → utils/process_id.hxx}

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2024. Couchbase, Inc.
+ *   Copyright 2026. Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -17,18 +17,23 @@
 
 #pragma once
 
-#include "error.hxx"
+#include <cstdint>
 
-#include <cstddef>
-#include <string>
+#if defined(_WIN32)
+#include <process.h>
+#else
+#include <unistd.h>
+#endif
 
-namespace couchbase::core::columnar
+namespace couchbase::core::utils
 {
-struct retry_info {
-  std::size_t retry_attempts{ 0 };
-  std::string last_dispatched_to{};
-  std::string last_dispatched_from{};
-  std::string last_dispatched_to_host{};
-  error last_error{};
-};
-} // namespace couchbase::core::columnar
+inline auto
+current_process_id() -> std::int64_t
+{
+#if defined(_WIN32)
+  return static_cast<std::int64_t>(::_getpid());
+#else
+  return static_cast<std::int64_t>(::getpid());
+#endif
+}
+} // namespace couchbase::core::utils