PendingCollectionsOperation.hpp

#ifndef DITTO_PENDING_COLLECTIONS_OPERATION_H
#define DITTO_PENDING_COLLECTIONS_OPERATION_H
 
#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;
 
DITTO_DISABLE_DEPRECATED_WARNINGS("CollectionsEvent is deprecated")
 

struct DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information see: "
    "https://ditto.com/link/legacy-to-dql-guide") CollectionsEventHandler {
  std::function<void(CollectionsEvent)> fn;
};

struct DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information see: "
    "https://ditto.com/link/legacy-to-dql-guide")
    CollectionsEventWithNextSignalHandler {
  std::function<void(CollectionsEvent, std::function<void()> &)> fn;
};

using CollectionsEventCallback DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information see: "
    "https://ditto.com/link/legacy-to-dql-guide") =
    std::function<void(CollectionsEvent)>;

using CollectionsEventWithNextSignalCallback DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information see: "
    "https://ditto.com/link/legacy-to-dql-guide") =
    std::function<void(CollectionsEvent, std::function<void()> &)>;
 
DITTO_REENABLE_WARNINGS

 * If you want to observe changes in such a way that you can signal when you're
 * ready for the live query to deliver a new update then you can call
 * @ref observe_local_with_next_signal.
 */
class DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information see: "
    "https://ditto.com/link/legacy-to-dql-guide") PendingCollectionsOperation {
  DITTO_DISABLE_DEPRECATED_WARNINGS("The legacy query API is deprecated")
 
  friend class Store;
 
  std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper;
  PendingCursorOperation pending_cursor_operation;
 
  explicit 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);
 
  DITTO_DISABLE_DEPRECATED_WARNINGS("`Collection` is deprecated")
  std::vector<Collection> exec() const;
  DITTO_REENABLE_WARNINGS

  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);
 
  DITTO_REENABLE_WARNINGS
};
} // namespace ditto
#endif