Store.hpp

#ifndef _DITTO_STORE_
#define _DITTO_STORE_
 
#include "Attachment.hpp"
#include "AttachmentFetchEvent.hpp"
#include "AttachmentFetcher.hpp"
#include "AttachmentToken.hpp"
#include "Collection.hpp"
#include "DiskUsage.hpp"
#include "Ditto.hpp"
#include "PendingCollectionsOperation.hpp"
#include "QueryResult.hpp"
#include "StoreObserver.hpp"
#include "Transaction.hpp"
#include "WriteTransaction.hpp"
#include "WriteTransactionResult.hpp"
 
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <vector>
 
namespace ditto {
class DittoHandleWrapper;
// clang-format off
// clang-format on
class Store {
  friend class AttachmentFetcher;
  friend class Ditto;
  friend class StoreObserver;
  friend class Transaction;
 
  static bool finalize_attachment_fetcher(
      std::shared_ptr<AttachmentFetcher> const &attachment_fetcher,
      std::shared_ptr<std::set<std::shared_ptr<AttachmentFetcher>>> const
          &attachment_fetchers,
      std::lock_guard<std::mutex> const &lock);
 
  std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper;
  DiskUsage disk_usage;
  Store(std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper);
  void set_weak_ditto_fields(std::weak_ptr<Ditto::Fields> weak_ditto_fields);
  std::weak_ptr<Ditto::Fields> weak_ditto_fields;
 
  // Lock responsible for synchronizing access to the attachment_fetchers set.
  std::shared_ptr<std::mutex> attachment_fetchers_lock;
  mutable std::shared_ptr<std::set<std::shared_ptr<AttachmentFetcher>>>
      attachment_fetchers;
 
  bool unregister_observer(std::shared_ptr<StoreObserver>);
 
#ifdef DITTO_INTERNAL_TESTING
public:
#endif
  std::vector<TransactionInfo> get_transactions() const;
 
private:
public:
  Store();

  std::set<std::shared_ptr<StoreObserver>> observers;

  std::set<std::shared_ptr<AttachmentFetcher>> get_attachment_fetchers() const;

  Collection collection(std::string name) const;

  std::vector<std::unique_ptr<WriteTransactionResult>>
  write(std::function<void(WriteTransaction &)> fn) const;

  PendingCollectionsOperation collections() const;

  DiskUsage get_disk_usage() const;

  QueryResult execute(std::string query, nlohmann::json query_args = nullptr);

  std::shared_ptr<StoreObserver>
  register_observer(std::string query, StoreObservationHandler change_handler);

  std::shared_ptr<StoreObserver>
  register_observer(std::string query, nlohmann::json query_args,
                    StoreObservationHandler change_handler);

  std::shared_ptr<StoreObserver>
  register_observer(std::string query,
                    StoreObservationHandlerWithNextSignal change_handler);

  std::shared_ptr<StoreObserver>
  register_observer(std::string query, nlohmann::json query_args,
                    StoreObservationHandlerWithNextSignal change_handler);

  Attachment new_attachment(std::string path,
                            std::map<std::string, std::string> metadata =
                                std::map<std::string, std::string>()) const;

  std::shared_ptr<AttachmentFetcher>
  fetch_attachment(std::shared_ptr<AttachmentToken> token,
                   AttachmentFetcherEventHandler event_handler) const;

  std::shared_ptr<AttachmentFetcher>
  fetch_attachment(std::unordered_map<std::string, any> map,
                   AttachmentFetcherEventHandler event_handler) const;
 
  // clang-format off
  // clang-format on
  TransactionCompletionAction transaction(
      const TransactionOptions &options,
      const std::function<TransactionCompletionAction(Transaction &)> &fn);

  TransactionCompletionAction transaction(
      const std::function<TransactionCompletionAction(Transaction &)> &fn);

  void execute_transaction(const TransactionOptions &options,
                           const std::function<void(Transaction &)> &fn);

  void execute_transaction(const std::function<void(Transaction &)> &fn);

  template <typename T>
  T transaction_returning(const TransactionOptions &options,
                          const std::function<T(Transaction &)> &fn) {
    std::promise<T> promise;
    auto future = promise.get_future();
    transaction(options,
                [&promise,
                 &fn](Transaction &transaction) -> TransactionCompletionAction {
                  try {
                    promise.set_value(fn(transaction));
                    return TransactionCompletionAction::commit;
                  } catch (const std::exception &e) {
                    promise.set_exception(std::current_exception());
                    throw;
                  }
                });
    return future.get();
  }

  template <typename T>
  T transaction_returning(const std::function<T(Transaction &)> &fn) {
    return transaction_returning(TransactionOptions(), fn);
  }
};
 
} // namespace ditto
 
#endif