couchbase 4.3.1 → 4.4.0

package/deps/couchbase-cxx-client/core/transactions.hxx

@@ -31,12 +31,8 @@
 #include "core/logger/logger.hxx"
 #include "core/utils/movable_function.hxx"
 
-#include <spdlog/common.h>
-
-#include <cmath>
 #include <functional>
 #include <system_error>
-#include <thread>
 
 // workaround for MSVC define overlap with log levels
 #undef ERROR
@@ -57,19 +53,21 @@ namespace transactions
 class transactions_cleanup;
 
 /** @brief Transaction logic should be contained in a lambda of this form */
-using logic = std::function<void(attempt_context&)>;
+using logic = std::function<void(std::shared_ptr<attempt_context>)>;
 
 /** @brief AsyncTransaction logic should be contained in a lambda of this form */
-using async_logic = std::function<void(async_attempt_context&)>;
+using async_logic = std::function<void(std::shared_ptr<async_attempt_context>)>;
 
 /** @brief AsyncTransaction callback when transaction has completed */
 using txn_complete_callback =
-  std::function<void(std::optional<transaction_exception>, std::optional<::couchbase::transactions::transaction_result>)>;
+  std::function<void(std::optional<transaction_exception>,
+                     std::optional<::couchbase::transactions::transaction_result>)>;
 
 /**
  * @mainpage
- * A transaction consists of a lambda containing all the operations you wish to perform within a transaction.
- * The @ref transactions.run() call yields an @ref attempt_context which you use for those operations.
+ * A transaction consists of a lambda containing all the operations you wish to perform within a
+ * transaction. The @ref transactions.run() call yields an @ref attempt_context which you use for
+ * those operations.
  *
  * @section txn_overview Overview
  *
@@ -84,7 +82,7 @@ using txn_complete_callback =
  * transactions txn(c, config);
  *
  * try {
- *     txn.run([&](transactions::attempt_context& ctx) {
+ *     txn.run([&](std::shared_ptr<transactions::attempt_context> ctx) {
  *         ctx.upsert(coll, "somekey", nlohmann::json::parse("{\"a\":\"thing\"}"));
  *         ctx.insert(coll, "someotherkey", nlohmann::json::parse("{"\a\":\"different thing\"}"));
  *     });
@@ -96,8 +94,8 @@ using txn_complete_callback =
  * }
  * @endcode
  *
- * This upserts a document, and inserts another into the default collection in the bucket named "default".  If
- * unsuccessful, an exception will be raised.
+ * This upserts a document, and inserts another into the default collection in the bucket named
+ * "default".  If unsuccessful, an exception will be raised.
  *
  * For a much more detailed example, see @ref examples/game_server.cxx
  *
@@ -105,22 +103,23 @@ using txn_complete_callback =
  *
  * Each @ref transactions instances spins up background threads to perform cleanup of metadata
  * that could be left behind after failed transactions.  For that reason, creating many
- * @ref transactions objects, especially if they are long-lived, will consume resources.  We recommend
- * simply creating one @ref transactions object per process, and using that for the life of the process,
- * when possible.
+ * @ref transactions objects, especially if they are long-lived, will consume resources.  We
+ * recommend simply creating one @ref transactions object per process, and using that for the life
+ * of the process, when possible.
  *
- * The @ref transactions, @ref cluster, @ref bucket, and @ref collection instances are all safe to use
- * across threads.  The @ref cluster and @ref bucket use libcouchbase internally, and manage a pool of
- * libcouchbase instances, since those instances are not to be used across threads.  The maximum number
- * of instances in the pools (for either the @ref cluster or @ref bucket) can be specified at the time
- * you construct the @ref cluster.  See @ref cluster_options for details.
+ * The @ref transactions, @ref cluster, @ref bucket, and @ref collection instances are all safe to
+ * use across threads.  The @ref cluster and @ref bucket use libcouchbase internally, and manage a
+ * pool of libcouchbase instances, since those instances are not to be used across threads.  The
+ * maximum number of instances in the pools (for either the @ref cluster or @ref bucket) can be
+ * specified at the time you construct the @ref cluster.  See @ref cluster_options for details.
  *
- * Since a @ref transactions instance spins up one thread per bucket for background cleanup tasks, a reasonable
- * starting point for sizing the @ref cluster_options::max_bucket_instances would be one per bucket, plus
- * one per thread that uses the @ref cluster (or the @ref transactions object constructed with that @ref cluster).
- * This could be tuned lower potentially, but this is a the maxmimum one should need.  The pool only
- * creates a new instance when it needs one, so the actual number created may never hit the max.  When
- * the maximum is reached, the thread will block until one is available.
+ * Since a @ref transactions instance spins up one thread per bucket for background cleanup tasks, a
+ * reasonable starting point for sizing the @ref cluster_options::max_bucket_instances would be one
+ * per bucket, plus one per thread that uses the @ref cluster (or the @ref transactions object
+ * constructed with that @ref cluster). This could be tuned lower potentially, but this is a the
+ * maxmimum one should need.  The pool only creates a new instance when it needs one, so the actual
+ * number created may never hit the max.  When the maximum is reached, the thread will block until
+ * one is available.
  *
  * @example examples/game_server.cxx
  */
@@ -130,160 +129,165 @@ using txn_complete_callback =
  */
 class transactions : public couchbase::transactions::transactions
 {
-  public:
-    /**
-     * @brief Destructor
-     */
-    ~transactions();
-
-    /**
-     * @brief Create a transactions object.
-     *
-     * Creates a transactions object, which can be used to run transactions within the current thread.
-     *
-     * @param cluster The cluster to use for the transactions.
-     * @param config The configuration parameters to use for the transactions.
-     * @param cb Called when the transactions object has been created or an error has occurred during the creation.
-     */
-    static void create(core::cluster cluster,
-                       const couchbase::transactions::transactions_config::built&,
-                       utils::movable_function<void(std::error_code, std::shared_ptr<transactions>)>&& cb);
-    static void create(core::cluster cluster,
-                       const couchbase::transactions::transactions_config&,
-                       utils::movable_function<void(std::error_code, std::shared_ptr<transactions>)>&& cb);
-
-    /**
-     * @brief Create a transactions object.
-     *
-     * Creates a transactions object, which can be used to run transactions within the current thread.
-     *
-     * @param cluster The cluster to use for the transactions.
-     * @param config The configuration parameters to use for the transactions.
-     * @return a future containing the error that occurred or the transactions object.
-     */
-    static std::future<std::pair<std::error_code, std::shared_ptr<transactions>>> create(
-      core::cluster cluster,
-      const couchbase::transactions::transactions_config::built& config);
-    static std::future<std::pair<std::error_code, std::shared_ptr<transactions>>> create(
-      core::cluster cluster,
-      const couchbase::transactions::transactions_config& config);
-
-    /**
-     * @brief Run a transaction
-     *
-     * Expects a lambda, which it calls with an @ref attempt_context reference to be used in the lambda for
-     * the transaction operations.
-     *
-     * @param logic The lambda containing the transaction logic.
-     * @return A struct containing some internal state information about the transaction.
-     * @throws @ref transaction_failed, @ref transaction_expired, @ref transaction_commit_ambiguous, all of which
-     *         share a common base class @ref transaction_exception.
-     */
-    couchbase::transactions::transaction_result run(logic&& code);
-
-    couchbase::transactions::transaction_result run(const couchbase::transactions::transaction_options& config, logic&& code);
-
-    std::pair<couchbase::transaction_error_context, couchbase::transactions::transaction_result> run(
-      ::couchbase::transactions::txn_logic&& code,
-      const couchbase::transactions::transaction_options& cfg = couchbase::transactions::transaction_options()) override;
-
-    /**
-     * @brief Run a transaction
-     *
-     * Expects a lambda, which it calls with an @ref async_attempt_context reference to be used in the lambda for
-     * the asynchronous transaction operations. Upon completion, calls the callback.
-     *
-     * @param logic The lambda containing the async transaction logic.
-     * @param cb Called when the transaction is complete.
-     * @return A struct containing some internal state information about the transaction.
-     * @throws @ref transaction_failed, @ref transaction_expired, @ref transaction_commit_ambiguous, all of which
-     *         share a common base class @ref transaction_exception.
-     */
-    void run(async_logic&& code, txn_complete_callback&& cb);
-
-    void run(const couchbase::transactions::transaction_options& config, async_logic&& code, txn_complete_callback&& cb);
-
-    void run(couchbase::transactions::async_txn_logic&& code,
-             couchbase::transactions::async_txn_complete_logic&& complete_cb,
-             const couchbase::transactions::transaction_options& cfg = {}) override;
-    /**
-     * @internal
-     * called internally - will likely move
-     */
-    void commit(attempt_context& ctx)
-    {
-        ctx.commit();
-    }
-
-    /**
-     * @internal
-     * called internally - will likely move
-     */
-    void rollback(attempt_context& ctx)
-    {
-        ctx.rollback();
-    }
-
-    void notify_fork(fork_event event);
-
-    /**
-     * @brief Shut down the transactions object
-     *
-     * The transaction object cannot be used after this call.  Called in destructor, but
-     * available to call sooner if needed.
-     */
-    void close();
-
-    /**
-     * @brief Return reference to @ref transactions_config.
-     *
-     * @return config for this transactions instance.
-     */
-    [[nodiscard]] couchbase::transactions::transactions_config::built& config()
-    {
-        return config_;
-    }
-
-    /**
-     * @internal
-     * Called internally
-     */
-    [[nodiscard]] const transactions_cleanup& cleanup() const
-    {
-        return *cleanup_;
-    }
-
-    /**
-     * @internal
-     * Called internally
-     */
-    [[nodiscard]] transactions_cleanup& cleanup()
-    {
-        return *cleanup_;
-    }
-
-    /**
-     * @brief Return a reference to the @ref core::cluster
-     *
-     * @return Ref to the cluster used by this transaction object.
-     */
-    [[nodiscard]] core::cluster& cluster_ref()
-    {
-        return cluster_;
-    }
-
-    /**
-     * @internal
-     */
-    transactions(core::cluster cluster, const couchbase::transactions::transactions_config::built& config);
-    transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config);
-
-  private:
-    core::cluster cluster_;
-    couchbase::transactions::transactions_config::built config_;
-    std::unique_ptr<transactions_cleanup> cleanup_;
-    const std::size_t max_attempts_{ 1000 };
-    const std::chrono::milliseconds min_retry_delay_{ 1 };
+public:
+  /**
+   * @brief Create a transactions object.
+   *
+   * Creates a transactions object, which can be used to run transactions within the current thread.
+   *
+   * @param cluster The cluster to use for the transactions.
+   * @param config The configuration parameters to use for the transactions.
+   * @param cb Called when the transactions object has been created or an error has occurred during
+   * the creation.
+   */
+  static void create(
+    core::cluster cluster,
+    const couchbase::transactions::transactions_config::built&,
+    utils::movable_function<void(std::error_code, std::shared_ptr<transactions>)>&& cb);
+  static void create(
+    core::cluster cluster,
+    const couchbase::transactions::transactions_config&,
+    utils::movable_function<void(std::error_code, std::shared_ptr<transactions>)>&& cb);
+
+  /**
+   * @brief Create a transactions object.
+   *
+   * Creates a transactions object, which can be used to run transactions within the current thread.
+   *
+   * @param cluster The cluster to use for the transactions.
+   * @param config The configuration parameters to use for the transactions.
+   * @return a future containing the error that occurred or the transactions object.
+   */
+  static auto create(core::cluster cluster,
+                     const couchbase::transactions::transactions_config::built& config)
+    -> std::future<std::pair<std::error_code, std::shared_ptr<transactions>>>;
+  static auto create(core::cluster cluster,
+                     const couchbase::transactions::transactions_config& config)
+    -> std::future<std::pair<std::error_code, std::shared_ptr<transactions>>>;
+
+  /**
+   * @brief Run a transaction
+   *
+   * Expects a lambda, which it calls with an @ref attempt_context reference to be used in the
+   * lambda for the transaction operations.
+   *
+   * @param logic The lambda containing the transaction logic.
+   * @return A struct containing some internal state information about the transaction.
+   * @throws @ref transaction_failed, @ref errc::transaction::expired, @ref
+   * transaction_commit_ambiguous, all of which share a common base class @ref
+   * transaction_exception.
+   */
+  auto run(logic&& code) -> couchbase::transactions::transaction_result;
+
+  auto run(const couchbase::transactions::transaction_options& config,
+           logic&& code) -> couchbase::transactions::transaction_result;
+
+  auto run(::couchbase::transactions::txn_logic&& code,
+           const couchbase::transactions::transaction_options& cfg)
+    -> std::pair<couchbase::error, couchbase::transactions::transaction_result> override;
+
+  /**
+   * @brief Run a transaction
+   *
+   * Expects a lambda, which it calls with an @ref async_attempt_context reference to be used in the
+   * lambda for the asynchronous transaction operations. Upon completion, calls the callback.
+   *
+   * @param logic The lambda containing the async transaction logic.
+   * @param cb Called when the transaction is complete.
+   * @return A struct containing some internal state information about the transaction.
+   * @throws @ref errc::transaction::failed, @ref errc::transaction::expired, @ref
+   * errc::transaction::ambiguous.
+   */
+  void run(async_logic&& code, txn_complete_callback&& cb);
+
+  void run(const couchbase::transactions::transaction_options& config,
+           async_logic&& code,
+           txn_complete_callback&& cb);
+
+  void run(couchbase::transactions::async_txn_logic&& code,
+           couchbase::transactions::async_txn_complete_logic&& complete_cb,
+           const couchbase::transactions::transaction_options& cfg) override;
+  /**
+   * @internal
+   * called internally - will likely move
+   */
+  void commit(std::shared_ptr<attempt_context> ctx)
+  {
+    ctx->commit();
+  }
+
+  /**
+   * @internal
+   * called internally - will likely move
+   */
+  void rollback(std::shared_ptr<attempt_context> ctx)
+  {
+    ctx->rollback();
+  }
+
+  void notify_fork(fork_event event);
+
+  /**
+   * @brief Shut down the transactions object
+   *
+   * The transaction object cannot be used after this call.  Called in destructor, but
+   * available to call sooner if needed.
+   */
+  void close();
+
+  /**
+   * @brief Return reference to @ref transactions_config.
+   *
+   * @return config for this transactions instance.
+   */
+  [[nodiscard]] auto config() -> couchbase::transactions::transactions_config::built&
+  {
+    return config_;
+  }
+
+  /**
+   * @internal
+   * Called internally
+   */
+  [[nodiscard]] auto cleanup() const -> const transactions_cleanup&
+  {
+    return *cleanup_;
+  }
+
+  /**
+   * @internal
+   * Called internally
+   */
+  [[nodiscard]] auto cleanup() -> transactions_cleanup&
+  {
+    return *cleanup_;
+  }
+
+  /**
+   * @brief Return a reference to the @ref core::cluster
+   *
+   * @return Ref to the cluster used by this transaction object.
+   */
+  [[nodiscard]] auto cluster_ref() -> core::cluster&
+  {
+    return cluster_;
+  }
+
+  /**
+   * @internal
+   */
+  transactions(core::cluster cluster,
+               const couchbase::transactions::transactions_config::built& config);
+  transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config);
+
+  ~transactions() override;
+
+private:
+  core::cluster cluster_;
+  couchbase::transactions::transactions_config::built config_;
+  std::unique_ptr<transactions_cleanup> cleanup_;
+  const std::size_t max_attempts_{ 1000 };
+  const std::chrono::milliseconds min_retry_delay_{ 1 };
 };
 } // namespace transactions
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/utils/binary.cxx

@@ -19,9 +19,9 @@
 
 namespace couchbase::core::utils
 {
-binary
-to_binary(std::string_view value) noexcept
+auto
+to_binary(std::string_view value) noexcept -> binary
 {
-    return to_binary(value.data(), value.size());
+  return to_binary(value.data(), value.size());
 }
 } // namespace couchbase::core::utils

package/deps/couchbase-cxx-client/core/utils/binary.hxx

@@ -28,30 +28,34 @@ namespace couchbase::core::utils
 using binary = std::vector<std::byte>;
 
 template<typename T>
-[[nodiscard]] binary
-to_binary(const T* data, const std::size_t size) noexcept
+[[nodiscard]] auto
+to_binary(const T* data, const std::size_t size) noexcept -> binary
 {
-    static_assert(sizeof(T) == 1);
-    binary copy;
-    copy.reserve(size);
-    copy.insert(copy.end(), reinterpret_cast<const std::byte*>(data), reinterpret_cast<const std::byte*>(data + size));
-    return copy;
+  static_assert(sizeof(T) == 1);
+  binary copy;
+  copy.reserve(size);
+  copy.insert(copy.end(),
+              reinterpret_cast<const std::byte*>(data),
+              reinterpret_cast<const std::byte*>(data + size));
+  return copy;
 }
 
-[[nodiscard]] binary
-to_binary(std::string_view value) noexcept;
+[[nodiscard]] auto
+to_binary(std::string_view value) noexcept -> binary;
 
 template<typename InputIterator, typename OutputIterator>
-OutputIterator
-to_binary(InputIterator first, InputIterator last, OutputIterator result) noexcept
+auto
+to_binary(InputIterator first, InputIterator last, OutputIterator result) noexcept -> OutputIterator
 {
-    return std::transform(first, last, result, [](auto e) { return static_cast<std::byte>(e); });
+  return std::transform(first, last, result, [](auto e) {
+    return static_cast<std::byte>(e);
+  });
 }
 
 template<typename Container, typename OutputIterator>
-OutputIterator
-to_binary(Container container, OutputIterator result) noexcept
+auto
+to_binary(Container container, OutputIterator result) noexcept -> OutputIterator
 {
-    return to_binary(std::begin(container), std::end(container), result);
+  return to_binary(std::begin(container), std::end(container), result);
 }
 } // namespace couchbase::core::utils

package/deps/couchbase-cxx-client/core/utils/byteswap.hxx

@@ -21,29 +21,29 @@
 
 namespace couchbase::core::utils
 {
-static constexpr std::uint16_t
-byte_swap(std::uint16_t value)
+static constexpr auto
+byte_swap(std::uint16_t value) -> std::uint16_t
 {
-    auto hi = static_cast<std::uint16_t>(value << 8U);
-    auto lo = static_cast<std::uint16_t>(value >> 8U);
-    return hi | lo;
+  auto hi = static_cast<std::uint16_t>(value << 8U);
+  auto lo = static_cast<std::uint16_t>(value >> 8U);
+  return hi | lo;
 }
 
-static constexpr std::uint32_t
-byte_swap(std::uint32_t value)
+static constexpr auto
+byte_swap(std::uint32_t value) -> std::uint32_t
 {
-    std::uint32_t byte0 = value & 0x000000ffU;
-    std::uint32_t byte1 = value & 0x0000ff00U;
-    std::uint32_t byte2 = value & 0x00ff0000U;
-    std::uint32_t byte3 = value & 0xff000000U;
-    return (byte0 << 24) | (byte1 << 8) | (byte2 >> 8) | (byte3 >> 24);
+  std::uint32_t byte0 = value & 0x000000ffU;
+  std::uint32_t byte1 = value & 0x0000ff00U;
+  std::uint32_t byte2 = value & 0x00ff0000U;
+  std::uint32_t byte3 = value & 0xff000000U;
+  return (byte0 << 24) | (byte1 << 8) | (byte2 >> 8) | (byte3 >> 24);
 }
 
-static constexpr std::uint64_t
-byte_swap(std::uint64_t value)
+static constexpr auto
+byte_swap(std::uint64_t value) -> std::uint64_t
 {
-    std::uint64_t hi = byte_swap(static_cast<std::uint32_t>(value));
-    std::uint32_t lo = byte_swap(static_cast<std::uint32_t>(value >> 32));
-    return (hi << 32) | lo;
+  std::uint64_t hi = byte_swap(static_cast<std::uint32_t>(value));
+  std::uint32_t lo = byte_swap(static_cast<std::uint32_t>(value >> 32));
+  return (hi << 32) | lo;
 }
 } // namespace couchbase::core::utils