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 "WriteTransaction.hpp"
#include "WriteTransactionResult.hpp"
 
#include <functional>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <vector>
 
namespace ditto {
class DittoHandleWrapper;
class Store {
  friend class AttachmentFetcher;
  friend class Ditto;
  friend class StoreObserver;
 
  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>);
 
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;
};
} // namespace ditto
#endif