couchbase 4.3.1 → 4.4.0

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

@@ -27,117 +27,118 @@ namespace couchbase::transactions
  */
 class transactions_cleanup_config
 {
-  public:
-    /**
-     * @brief Enable/disable the lost attempts cleanup loop.
-     * @see @ref cleanup_window() for description of the cleanup lost attempts loop.
-     *
-     * @param value If false, do not start the lost attempts cleanup threads.
-     * @return reference to this, so calls can be chained.
-     */
-    transactions_cleanup_config& cleanup_lost_attempts(bool value)
-    {
-        cleanup_lost_attempts_ = value;
-        return *this;
-    }
-    /**
-     * @brief Get lost attempts cleanup loop status.
-     * @see @ref cleanup_window() for description of the lost attempts cleanup loop.
-     *
-     * @return If false, no lost attempts cleanup threads will be launched.
-     */
-    [[nodiscard]] bool cleanup_lost_attempts() const
-    {
-        return cleanup_lost_attempts_;
-    }
+public:
+  /**
+   * @brief Enable/disable the lost attempts cleanup loop.
+   * @see @ref cleanup_window() for description of the cleanup lost attempts loop.
+   *
+   * @param value If false, do not start the lost attempts cleanup threads.
+   * @return reference to this, so calls can be chained.
+   */
+  auto cleanup_lost_attempts(bool value) -> transactions_cleanup_config&
+  {
+    cleanup_lost_attempts_ = value;
+    return *this;
+  }
+  /**
+   * @brief Get lost attempts cleanup loop status.
+   * @see @ref cleanup_window() for description of the lost attempts cleanup loop.
+   *
+   * @return If false, no lost attempts cleanup threads will be launched.
+   */
+  [[nodiscard]] auto cleanup_lost_attempts() const -> bool
+  {
+    return cleanup_lost_attempts_;
+  }
 
-    /**
-     * @brief Set state for the client attempts cleanup loop.
-     * @see @ref cleanup_client_attempts()
-     *
-     * @param value If true, run the cleanup client attempts loop.
-     * @return reference to this, so calls can be chained.
-     */
-    transactions_cleanup_config& cleanup_client_attempts(bool value)
-    {
-        cleanup_client_attempts_ = value;
-        return *this;
-    }
+  /**
+   * @brief Set state for the client attempts cleanup loop.
+   * @see @ref cleanup_client_attempts()
+   *
+   * @param value If true, run the cleanup client attempts loop.
+   * @return reference to this, so calls can be chained.
+   */
+  auto cleanup_client_attempts(bool value) -> transactions_cleanup_config&
+  {
+    cleanup_client_attempts_ = value;
+    return *this;
+  }
 
-    /**
-     * @brief Get state of client attempts cleanup loop.
-     *
-     * A transactions object will create a background thread to do any cleanup necessary
-     * for the transactions it has attempted.  This can be disabled if set to false.
-     *
-     * @return true if the thread is enabled, false if not.
-     */
-    [[nodiscard]] bool cleanup_client_attempts() const
-    {
-        return cleanup_client_attempts_;
-    }
+  /**
+   * @brief Get state of client attempts cleanup loop.
+   *
+   * A transactions object will create a background thread to do any cleanup necessary
+   * for the transactions it has attempted.  This can be disabled if set to false.
+   *
+   * @return true if the thread is enabled, false if not.
+   */
+  [[nodiscard]] auto cleanup_client_attempts() const -> bool
+  {
+    return cleanup_client_attempts_;
+  }
 
-    /**
-     * @brief Get cleanup window
-     *
-     * Each @ref transactions instance has background threads which looks for evidence of
-     * transactions that somehow were not cleaned up during ordinary processing.  There is one
-     * of these per bucket.  The thread looks through the active transaction records on that bucket
-     * once during each window.  There are potentially 1024 of these records, so over one cleanup
-     * window period, the thread will look for all 1024 of these, and examine any it finds.  Note
-     * you can disable this by setting @ref cleanup_lost_attempts() false.
-     *
-     * @return The cleanup window.
-     */
-    [[nodiscard]] std::chrono::milliseconds cleanup_window() const
-    {
-        return cleanup_window_;
-    }
+  /**
+   * @brief Get cleanup window
+   *
+   * Each @ref transactions instance has background threads which looks for evidence of
+   * transactions that somehow were not cleaned up during ordinary processing.  There is one
+   * of these per bucket.  The thread looks through the active transaction records on that bucket
+   * once during each window.  There are potentially 1024 of these records, so over one cleanup
+   * window period, the thread will look for all 1024 of these, and examine any it finds.  Note
+   * you can disable this by setting @ref cleanup_lost_attempts() false.
+   *
+   * @return The cleanup window.
+   */
+  [[nodiscard]] auto cleanup_window() const -> std::chrono::milliseconds
+  {
+    return cleanup_window_;
+  }
 
-    /**
-     * @brief Set cleanup window
-     *
-     * @see cleanup_window() for more info.
-     * @param duration An std::chrono::duration representing the cleanup window duration.
-     * @return reference to this, so calls can be chained.
-     */
-    template<typename T>
-    transactions_cleanup_config& cleanup_window(T duration)
-    {
-        cleanup_window_ = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
-        return *this;
-    }
+  /**
+   * @brief Set cleanup window
+   *
+   * @see cleanup_window() for more info.
+   * @param duration An std::chrono::duration representing the cleanup window duration.
+   * @return reference to this, so calls can be chained.
+   */
+  template<typename T>
+  auto cleanup_window(T duration) -> transactions_cleanup_config&
+  {
+    cleanup_window_ = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
+    return *this;
+  }
 
-    /**
-     * @brief Add a collection to be cleaned
-     *
-     * This can be called multiple times, to add several collections, if needed.
-     *
-     */
-    transactions_cleanup_config& add_collection(const couchbase::transactions::transaction_keyspace& keyspace)
-    {
-        collections_.emplace_back(keyspace);
-        return *this;
-    }
+  /**
+   * @brief Add a collection to be cleaned
+   *
+   * This can be called multiple times, to add several collections, if needed.
+   *
+   */
+  auto add_collection(const couchbase::transactions::transaction_keyspace& keyspace)
+    -> transactions_cleanup_config&
+  {
+    collections_.emplace_back(keyspace);
+    return *this;
+  }
 
-    /** @private */
-    struct built {
-        bool cleanup_lost_attempts;
-        bool cleanup_client_attempts;
-        std::chrono::milliseconds cleanup_window;
-        std::list<couchbase::transactions::transaction_keyspace> collections;
-    };
+  /** @private */
+  struct built {
+    bool cleanup_lost_attempts;
+    bool cleanup_client_attempts;
+    std::chrono::milliseconds cleanup_window;
+    std::list<couchbase::transactions::transaction_keyspace> collections;
+  };
 
-    /** @private */
-    [[nodiscard]] auto build() const -> built
-    {
-        return { cleanup_lost_attempts_, cleanup_client_attempts_, cleanup_window_, collections_ };
-    }
+  /** @private */
+  [[nodiscard]] auto build() const -> built
+  {
+    return { cleanup_lost_attempts_, cleanup_client_attempts_, cleanup_window_, collections_ };
+  }
 
-  private:
-    bool cleanup_lost_attempts_{ true };
-    bool cleanup_client_attempts_{ true };
-    std::chrono::milliseconds cleanup_window_{ std::chrono::seconds(60) };
-    std::list<couchbase::transactions::transaction_keyspace> collections_{};
+private:
+  bool cleanup_lost_attempts_{ true };
+  bool cleanup_client_attempts_{ true };
+  std::chrono::milliseconds cleanup_window_{ std::chrono::seconds(60) };
+  std::list<couchbase::transactions::transaction_keyspace> collections_{};
 };
 } // namespace couchbase::transactions

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

@@ -41,192 +41,196 @@ namespace couchbase::transactions
  */
 class transactions_config
 {
-  public:
-    transactions_config();
-
-    ~transactions_config();
-
-    transactions_config(const transactions_config& c);
-
-    transactions_config(transactions_config&& c) noexcept;
-
-    transactions_config& operator=(const transactions_config& c);
-
-    /**
-     * @brief Get the default durability level for all transaction operations
-     *
-     * @see couchbase::durability_level for details.
-     *
-     * @return The default durability level used for write operations.
-     */
-    [[nodiscard]] couchbase::durability_level durability_level() const
-    {
-        return level_;
-    }
-
-    /**
-     * @brief Set the default durability level for all transaction operations
-     *
-     * @see couchbase::durability_level for details.
-     *
-     * @param level The default durability level desired for write operations.
-     * @return reference to this, so calls can be chained.
-     */
-    transactions_config& durability_level(enum couchbase::durability_level level)
-    {
-        level_ = level;
-        return *this;
-    }
-
-    /**
-     * @brief Get the timeout for transactions
-     *
-     * Transactions can conflict (or other operations on those documents), and may retry.
-     * This is the maximum time a transaction can take, including any retries.  The transaction will throw
-     * an @ref transaction_expired and rollback when this occurs.
-     *
-     * @return timeout for transactions.
-     */
-    [[nodiscard]] std::chrono::nanoseconds timeout() const
-    {
-        return timeout_;
-    }
-    /**
-     * @brief Set the timeout for transactions.
-     *
-     * @param duration desired expiration for transactions.
-     * @return reference to this, so calls can be chained.
-     */
-    template<typename T>
-    transactions_config& timeout(T duration)
-    {
-        timeout_ = std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
-        return *this;
-    }
-
-    /**
-     * Set the transaction's metadata collection.
-     *
-     * @param keyspace The collection to use for the transaction metadata.
-     * @return reference to this, so calls can be chained.
-     */
-    transactions_config& metadata_collection(const couchbase::transactions::transaction_keyspace& keyspace)
-    {
-        metadata_collection_ = keyspace;
-        return *this;
-    }
-
-    [[nodiscard]] std::optional<couchbase::transactions::transaction_keyspace> metadata_collection() const
-    {
-        return metadata_collection_;
-    }
-
-    /**
-     * Get the query config values
-     *
-     * @return The query configuration for transactions.
-     */
-    [[nodiscard]] const transactions_query_config& query_config() const
-    {
-        return query_config_;
-    }
-
-    /**
-     * Get the query config values
-     *
-     * @return The query configuration for transactions.
-     */
-    [[nodiscard]] transactions_query_config& query_config()
-    {
-        return query_config_;
-    }
-
-    /**
-     * Set the query configuration for transactions.
-     *
-     * @param config The transactions query configuration to use.
-     * @return reference to this, so calls can be chained.
-     */
-    transactions_config& query_config(const transactions_query_config& config)
-    {
-        query_config_ = config;
-        return *this;
-    }
-
-    /**
-     * Get the cleanup configuration for transactions.
-     *
-     * @return The cleanup configuration.
-     */
-    [[nodiscard]] const transactions_cleanup_config& cleanup_config() const
-    {
-        return cleanup_config_;
-    }
-
-    /**
-     * Get the cleanup configuration for transactions.
-     *
-     * @return The cleanup configuration.
-     */
-    [[nodiscard]] transactions_cleanup_config& cleanup_config()
-    {
-        return cleanup_config_;
-    }
-
-    /**
-     * Set the cleanup configuration.
-     *
-     * @param cleanup_config The cleanup configuration to use.
-     * @return reference to this, so calls can be chained.
-     */
-    transactions_config& cleanup_config(const transactions_cleanup_config& cleanup_config)
-    {
-        cleanup_config_ = cleanup_config;
-        return *this;
-    }
-
-    /** @private */
-    transactions_config& test_factories(std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
-                                        std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks)
-    {
-        attempt_context_hooks_ = hooks;
-        cleanup_hooks_ = cleanup_hooks;
-        return *this;
-    }
-
-    /** @private */
-    [[nodiscard]] core::transactions::attempt_context_testing_hooks& attempt_context_hooks() const
-    {
-        return *attempt_context_hooks_;
-    }
-
-    /** @private */
-    [[nodiscard]] core::transactions::cleanup_testing_hooks& cleanup_hooks() const
-    {
-        return *cleanup_hooks_;
-    }
-
-    /** @private */
-    struct built {
-        couchbase::durability_level level;
-        std::chrono::nanoseconds timeout;
-        std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks;
-        std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks;
-        std::optional<couchbase::transactions::transaction_keyspace> metadata_collection;
-        transactions_query_config::built query_config;
-        transactions_cleanup_config::built cleanup_config;
-    };
-
-    /** @internal */
-    [[nodiscard]] built build() const;
-
-  private:
-    couchbase::durability_level level_{ couchbase::durability_level::majority };
-    std::chrono::nanoseconds timeout_{ std::chrono::seconds(15) };
-    std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks_;
-    std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks_;
-    std::optional<couchbase::transactions::transaction_keyspace> metadata_collection_;
-    transactions_query_config query_config_{};
-    transactions_cleanup_config cleanup_config_{};
+public:
+  transactions_config();
+
+  ~transactions_config();
+
+  transactions_config(const transactions_config& c);
+
+  transactions_config(transactions_config&& c) noexcept;
+
+  auto operator=(const transactions_config& c) -> transactions_config&;
+
+  /**
+   * @brief Get the default durability level for all transaction operations
+   *
+   * @see couchbase::durability_level for details.
+   *
+   * @return The default durability level used for write operations.
+   */
+  [[nodiscard]] auto durability_level() const -> couchbase::durability_level
+  {
+    return level_;
+  }
+
+  /**
+   * @brief Set the default durability level for all transaction operations
+   *
+   * @see couchbase::durability_level for details.
+   *
+   * @param level The default durability level desired for write operations.
+   * @return reference to this, so calls can be chained.
+   */
+  auto durability_level(enum couchbase::durability_level level) -> transactions_config&
+  {
+    level_ = level;
+    return *this;
+  }
+
+  /**
+   * @brief Get the timeout for transactions
+   *
+   * Transactions can conflict (or other operations on those documents), and may retry.
+   * This is the maximum time a transaction can take, including any retries.  The transaction will
+   * throw an @ref errc::transaction::expired and rollback when this occurs.
+   *
+   * @return timeout for transactions.
+   */
+  [[nodiscard]] auto timeout() const -> std::chrono::nanoseconds
+  {
+    return timeout_;
+  }
+  /**
+   * @brief Set the timeout for transactions.
+   *
+   * @param duration desired expiration for transactions.
+   * @return reference to this, so calls can be chained.
+   */
+  template<typename T>
+  auto timeout(T duration) -> transactions_config&
+  {
+    timeout_ = std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
+    return *this;
+  }
+
+  /**
+   * Set the transaction's metadata collection.
+   *
+   * @param keyspace The collection to use for the transaction metadata.
+   * @return reference to this, so calls can be chained.
+   */
+  auto metadata_collection(const couchbase::transactions::transaction_keyspace& keyspace)
+    -> transactions_config&
+  {
+    metadata_collection_ = keyspace;
+    return *this;
+  }
+
+  [[nodiscard]] auto metadata_collection() const
+    -> std::optional<couchbase::transactions::transaction_keyspace>
+  {
+    return metadata_collection_;
+  }
+
+  /**
+   * Get the query config values
+   *
+   * @return The query configuration for transactions.
+   */
+  [[nodiscard]] auto query_config() const -> const transactions_query_config&
+  {
+    return query_config_;
+  }
+
+  /**
+   * Get the query config values
+   *
+   * @return The query configuration for transactions.
+   */
+  [[nodiscard]] auto query_config() -> transactions_query_config&
+  {
+    return query_config_;
+  }
+
+  /**
+   * Set the query configuration for transactions.
+   *
+   * @param config The transactions query configuration to use.
+   * @return reference to this, so calls can be chained.
+   */
+  auto query_config(const transactions_query_config& config) -> transactions_config&
+  {
+    query_config_ = config;
+    return *this;
+  }
+
+  /**
+   * Get the cleanup configuration for transactions.
+   *
+   * @return The cleanup configuration.
+   */
+  [[nodiscard]] auto cleanup_config() const -> const transactions_cleanup_config&
+  {
+    return cleanup_config_;
+  }
+
+  /**
+   * Get the cleanup configuration for transactions.
+   *
+   * @return The cleanup configuration.
+   */
+  [[nodiscard]] auto cleanup_config() -> transactions_cleanup_config&
+  {
+    return cleanup_config_;
+  }
+
+  /**
+   * Set the cleanup configuration.
+   *
+   * @param cleanup_config The cleanup configuration to use.
+   * @return reference to this, so calls can be chained.
+   */
+  auto cleanup_config(const transactions_cleanup_config& cleanup_config) -> transactions_config&
+  {
+    cleanup_config_ = cleanup_config;
+    return *this;
+  }
+
+  /** @private */
+  auto test_factories(std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
+                      std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks)
+    -> transactions_config&
+  {
+    attempt_context_hooks_ = hooks;
+    cleanup_hooks_ = cleanup_hooks;
+    return *this;
+  }
+
+  /** @private */
+  [[nodiscard]] auto attempt_context_hooks() const
+    -> core::transactions::attempt_context_testing_hooks&
+  {
+    return *attempt_context_hooks_;
+  }
+
+  /** @private */
+  [[nodiscard]] auto cleanup_hooks() const -> core::transactions::cleanup_testing_hooks&
+  {
+    return *cleanup_hooks_;
+  }
+
+  /** @private */
+  struct built {
+    couchbase::durability_level level;
+    std::chrono::nanoseconds timeout;
+    std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks;
+    std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks;
+    std::optional<couchbase::transactions::transaction_keyspace> metadata_collection;
+    transactions_query_config::built query_config;
+    transactions_cleanup_config::built cleanup_config;
+  };
+
+  /** @internal */
+  [[nodiscard]] auto build() const -> built;
+
+private:
+  couchbase::durability_level level_{ couchbase::durability_level::majority };
+  std::chrono::nanoseconds timeout_{ std::chrono::seconds(15) };
+  std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks_;
+  std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks_;
+  std::optional<couchbase::transactions::transaction_keyspace> metadata_collection_;
+  transactions_query_config query_config_{};
+  transactions_cleanup_config cleanup_config_{};
 };
 } // namespace couchbase::transactions