transaction_options.hxx

Go to the documentation of this file.

/*
 *     Copyright 2022 Couchbase, Inc.
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
 
#pragma once
 
#include <couchbase/durability_level.hxx>
#include <couchbase/query_scan_consistency.hxx>
#include <couchbase/transactions/transactions_config.hxx>
 
#include <chrono>
#include <optional>
 
namespace couchbase
{
class collection;
 
namespace transactions
{
class transaction_options
{
public:
  transaction_options() = default;

  auto durability_level(durability_level level) -> transaction_options&;

  [[nodiscard]] auto durability_level() const -> std::optional<couchbase::durability_level>;

  auto scan_consistency(query_scan_consistency scan_consistency) -> transaction_options&;

  [[nodiscard]] auto scan_consistency() const -> std::optional<query_scan_consistency>;

  template<typename T>
  auto timeout(T timeout) -> transaction_options&
  {
    timeout_ = std::chrono::duration_cast<std::chrono::nanoseconds>(timeout);
    return *this;
  }
  auto timeout(T timeout) -> transaction_options& {…}

  auto timeout() -> std::optional<std::chrono::nanoseconds>;

  auto metadata_collection(const couchbase::collection& coll) -> transaction_options&;

  auto metadata_collection(const couchbase::transactions::transaction_keyspace& keyspace)
    -> transaction_options&
  {
    metadata_collection_.emplace(keyspace);
    return *this;
  }
  auto metadata_collection(const couchbase::transactions::transaction_keyspace& keyspace) {…}

  [[nodiscard]] auto metadata_collection() const -> std::optional<transaction_keyspace>;

  auto test_factories(std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
                      std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks)
    -> transaction_options&;
  [[nodiscard]] auto apply(const transactions_config::built& conf) const
    -> transactions_config::built;
 
private:
  std::optional<couchbase::durability_level> durability_;
  std::optional<couchbase::query_scan_consistency> scan_consistency_;
  std::optional<std::chrono::nanoseconds> timeout_;
  std::optional<transaction_keyspace> metadata_collection_;
  std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks_;
  std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks_;
};
class transaction_options {…};
} // namespace transactions
} // namespace couchbase