Store.hpp

#ifndef DITTO_STORE_H
#define DITTO_STORE_H
 
#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;
  explicit 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;
 
  // Lock responsible for synchronizing access to the observers set.
  std::shared_ptr<std::mutex> observers_lock;
  bool unregister_observer(std::shared_ptr<StoreObserver>);
 
#ifdef DITTO_INTERNAL_TESTING
public:
#endif
  std::vector<TransactionInfo> get_transactions() const;
 
private:
public:
  // TODO(v5): remove this unused public constructor
  DITTO_DEPRECATED_BECAUSE(
      "Use `Ditto::get_store()` to access its `Store` instance.")
  Store();
 
  DITTO_DISABLE_DEPRECATED_WARNINGS("`observers` is deprecated")
  Store(const Store &other) = default;
  Store(Store &&other) noexcept = default;
  Store &operator=(const Store &other) = default;
  Store &operator=(Store &&other) noexcept = default;
  ~Store() = default;
  DITTO_REENABLE_WARNINGS

  std::set<std::shared_ptr<StoreObserver>> get_observers() const;
 
  // NOLINTBEGIN
  // TODO(v5): make this data member private.  When it becomes private,
  // the deprecation marker can be removed.
  DITTO_DEPRECATED_BECAUSE("Use `Store::get_observers()` instead")
  std::set<std::shared_ptr<StoreObserver>> observers;
  // NOLINTEND

 
  std::set<std::shared_ptr<AttachmentFetcher>> get_attachment_fetchers() const;
 
  DITTO_DISABLE_DEPRECATED_WARNINGS("`Collection` is deprecated")
  DITTO_DEPRECATED_BECAUSE(
      "Use DQL (Ditto Query Language) instead. For more information see: "
      "https://ditto.com/link/legacy-to-dql-guide")
  Collection collection(std::string name) const;
  DITTO_REENABLE_WARNINGS
 
  DITTO_DISABLE_DEPRECATED_WARNINGS("WriteTransaction is deprecated")
  DITTO_DEPRECATED_BECAUSE(
      "Use DQL (Ditto Query Language) instead. For more information see: "
      "https://ditto.com/link/legacy-to-dql-guide")
  std::vector<std::unique_ptr<WriteTransactionResult>>
  write(std::function<void(WriteTransaction &)> fn) const;
  DITTO_REENABLE_WARNINGS
 
  DITTO_DISABLE_DEPRECATED_WARNINGS("PendingCollectionsOperation is deprecated")
  DITTO_DEPRECATED_BECAUSE(
      "Use DQL \"SELECT * from system::collections\" instead.For more "
      "information see: https://ditto.com/link/legacy-to-dql-guide")
  PendingCollectionsOperation collections() const;
  DITTO_REENABLE_WARNINGS

  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