PendingCollectionsOperation.hpp

#ifndef _DITTO_PENDING_COLLECTIONS_OPERATION_
#define _DITTO_PENDING_COLLECTIONS_OPERATION_
 
#include "Collection.hpp"
#include "CollectionsEvent.hpp"
#include "LiveQuery.hpp"
#include "PendingCursorOperation.hpp"
#include "SortDirection.hpp"
#include "Subscription.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace ditto {
class DittoHandleWrapper;
 
struct CollectionsEventHandler {
  std::function<void(CollectionsEvent)> fn;
};
 
struct CollectionsEventWithNextSignalHandler {
  std::function<void(CollectionsEvent, std::function<void()> &)> fn;
};
 
typedef std::function<void(CollectionsEvent)> CollectionsEventCallback;
 
typedef std::function<void(CollectionsEvent, std::function<void()> &)>
    CollectionsEventWithNextSignalCallback;
 
class PendingCollectionsOperation {
  friend class Store;
 
  std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper;
  PendingCursorOperation pending_cursor_operation;
 
  PendingCollectionsOperation(
      std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper);
 
public:
  ~PendingCollectionsOperation();
 
  PendingCollectionsOperation &limit(uint32_t limit);
 
  PendingCollectionsOperation &offset(uint32_t offset);
 
  PendingCollectionsOperation &sort(std::string query, SortDirection direction);
 
  std::vector<Collection> exec() const;
 
  std::shared_ptr<Subscription> subscribe() const;
 
  std::shared_ptr<LiveQuery>
  observe_local(CollectionsEventCallback event_callback) const;
 
  std::shared_ptr<LiveQuery> observe_local_with_next_signal(
      CollectionsEventWithNextSignalCallback event_callback) const;
 
private:
  static LiveQueryEventCallback
  buildLiveQueryCallback(CollectionsEventCallback callback,
                         std::shared_ptr<DittoHandleWrapper> dhw);
 
  static LiveQueryEventWithNextSignalCallback
  buildLiveQueryWithNextSignalCallback(
      CollectionsEventWithNextSignalCallback callback,
      std::shared_ptr<DittoHandleWrapper> dhw);
};
} // namespace ditto
#endif