Transaction.hpp

#ifndef DITTO_TRANSACTION_H
#define DITTO_TRANSACTION_H
 
#include "QueryResult.hpp"
 
#include <string>
 
namespace ditto {
 
class Store;

class TransactionOptions {
private:
  bool read_only = false;
  std::string hint;
 
public:
  TransactionOptions() = default;

  TransactionOptions &set_read_only(bool read_only);

  bool get_read_only() const;

  TransactionOptions &set_hint(std::string hint);

  const std::string &get_hint() const;
};

struct TransactionInfo {
  std::string id;

  std::string hint;

  bool is_read_only = false;
};

void from_json(const nlohmann::json &j, TransactionInfo &c);

void to_json(nlohmann::json &j, const TransactionInfo &c);

enum class TransactionCompletionAction {
  commit,

  rollback,
};

namespace internal {
 
void transaction_execute_cb(
    void *env_ptr, dittoffi_result_dittoffi_query_result_ptr_t ffi_result);
 
} // namespace internal
 
// clang-format off
// clang-format on
class Transaction {
  friend class Store;
 
  friend void ditto::internal::transaction_execute_cb(
      void *env_ptr, dittoffi_result_dittoffi_query_result_ptr_t ffi_result);
 
  struct Impl;
  std::unique_ptr<Impl> impl;
 
  explicit Transaction(Impl *impl);
 
  static TransactionCompletionAction
  perform(Store &store, const TransactionOptions &options,
          const std::function<TransactionCompletionAction(Transaction &)> &fn);
 
#ifdef DITTO_INTERNAL_TESTING
public:
#endif
  TransactionCompletionAction complete(TransactionCompletionAction action);
 
private:
public:
  ~Transaction();
 
  Transaction(const Transaction &) = delete;
  Transaction &operator=(const Transaction &) = delete;
  Transaction(Transaction &&) = default;
  Transaction &operator=(Transaction &&) = default;

  TransactionInfo get_info() const;

  Store &get_store() const;

  QueryResult execute(std::string query, nlohmann::json query_args = nullptr);
};
 
} // namespace ditto
 
#endif