LiveQuery.hpp

#ifndef DITTO_LIVE_QUERY_H
#define DITTO_LIVE_QUERY_H
 
#include "Document.hpp"
#include "Helpers.hpp"
#include "LiveQueryEvent.hpp"
#include "LiveQueryMove.hpp"
#include "Observer.hpp"
#include "SingleDocumentLiveQueryEvent.hpp"
#include "Subscription.hpp"
#include "json.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace ditto {
class DittoHandleWrapper;
class OrderBy;
 
DITTO_DISABLE_DEPRECATED_WARNINGS(
    "Document is deprecated, and will be removed in v5")
 

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

 * updates relating to a live query associated with a single document.
 */
struct DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information "
    "see: https://ditto.com/link/legacy-to-dql-guide")
    SingleDocumentLiveQueryEventHandler {
  std::function<void(std::shared_ptr<Document>, SingleDocumentLiveQueryEvent)>
      fn;
};

using SingleDocumentLiveQueryEventWithNextSignalCallback
    DITTO_DEPRECATED_BECAUSE(
        "Use Ditto's query language with "
        "Store::execute(). For more information "
        "see: https://ditto.com/link/legacy-to-dql-guide") =
        std::function<void(std::shared_ptr<Document>,
                           SingleDocumentLiveQueryEvent,
                           std::function<void()> &)>;

 * information see: https://ditto.com/link/legacy-to-dql-guide
 *
 * @brief A thin wrapper around a function that will get called when there are
 * updates relating to a live query associated with a single document that has
 * an associated function to call when the next event is ready to be delivered.
 */
struct DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information "
    "see: https://ditto.com/link/legacy-to-dql-guide")
    SingleDocumentLiveQueryWithNextSignalEventHandler {
  std::function<void(std::shared_ptr<Document>, SingleDocumentLiveQueryEvent,
                     std::function<void()> &)>
      fn;
};

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


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

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


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

 * @deprecated Use DQL (%Ditto Query Language) instead. For more
 * information see: https://ditto.com/link/legacy-to-dql-guide
 *
 * @brief The type that is returned when calling `observe_local`. It handles the
 * logic for calling the event handler that is provided to the `observe_local`
 * call.
 *
 * These objects must be kept in scope for as long as you wish to keep receiving
 * updates about the associated query.
 */
class DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information "
    "see: https://ditto.com/link/legacy-to-dql-guide") LiveQuery
    : public Observer {
  DITTO_DISABLE_DEPRECATED_WARNINGS("The legacy query API is deprecated")
 
public:
  ~LiveQuery(); // required by pimpl.
  LiveQuery(LiveQuery &&);
  LiveQuery &operator=(LiveQuery &&);
 
  struct ArcCtx;
 
private:
  LiveQuery(std::shared_ptr<DittoHandleWrapper> const &ditto_handle_wrapper,
            std::string query, nlohmann::json query_args, std::string coll_name,
            std::shared_ptr<OrderBy> const &order_by, int32_t limit,
            uint32_t offset, LiveQueryAvailability_t availability,
            std::unique_ptr<Subscription> &&subscription,
            LiveQueryEventWithNextSignalCallback &&event_callback);
 
  void on_stop() override;
  // Non-trivial dtor requires manual swap for assignment operators.
  static void swap(LiveQuery &lhs, LiveQuery &rhs) noexcept;
 
  std::unique_ptr<ArcCtx> ctx; // pimpl.
 
  friend class PendingCursorOperation;
  friend class PendingIDSpecificOperation;
 
  DITTO_REENABLE_WARNINGS
};
 
} // namespace ditto
 
#endif