PendingCursorOperation.hpp

#ifndef _DITTO_PENDING_CURSOR_OPERATION_
#define _DITTO_PENDING_CURSOR_OPERATION_
 
#include "Document.hpp"
#include "DocumentId.hpp"
#include "Helpers.hpp"
#include "LiveQuery.hpp"
#include "MutableDocument.hpp"
#include "SortDirection.hpp"
#include "Subscription.hpp"
#include "UpdateResult.hpp"
#include "json.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace ditto {
class DittoHandleWrapper;
 
class PendingCursorOperation {
  friend class Collection;
  friend class PendingCollectionsOperation;
 
  nlohmann::json query_args;
  uint32_t _offset = 0;
  int32_t _limit = -1;
 
  PendingCursorOperation(
      std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper,
      std::string collection_name, std::string query_str,
      nlohmann::json query_args);
 
  PendingCursorOperation() = default;
  PendingCursorOperation(PendingCursorOperation &&other) noexcept;
  PendingCursorOperation(const PendingCursorOperation &other);
  PendingCursorOperation &operator=(PendingCursorOperation other);
 
  class Impl;
  std::unique_ptr<Impl> impl_;
 
public:
  std::string collection_name;
 
  std::string query;
 
  ~PendingCursorOperation();
 
  // Follows the copy-and-swap idiom as described here:
  // https://stackoverflow.com/a/3279550/2041080
  friend void swap(PendingCursorOperation &first,
                   PendingCursorOperation &second) {
    using std::swap;
 
    swap(first.collection_name, second.collection_name);
    swap(first.query, second.query);
    swap(first.query_args, second.query_args);
    swap(first._offset, second._offset);
    swap(first._limit, second._limit);
    swap(first.impl_, second.impl_);
  }
 
  PendingCursorOperation &limit(uint32_t limit);
 
  PendingCursorOperation &offset(uint32_t offset);
 
  PendingCursorOperation &sort(std::string query, SortDirection direction);
 
  std::vector<Document> exec() const;
 
  std::unordered_map<DocumentId, std::vector<std::unique_ptr<UpdateResult>>,
                     DocumentIdHasher>
  update(std::function<void(std::vector<MutableDocument> &)> fn);
 
  std::vector<DocumentId> remove() const;
 
  std::vector<DocumentId> evict() const;
 
  Subscription subscribe() const;
 
  std::shared_ptr<LiveQuery>
  observe(LiveQueryEventHandler handler) const DITTO_DEPRECATED;
 
  std::shared_ptr<LiveQuery>
  observe(LiveQueryEventCallback event_callback) const;
 
  std::shared_ptr<LiveQuery>
  observe_local(LiveQueryEventHandler handler) const DITTO_DEPRECATED;
 
  std::shared_ptr<LiveQuery>
  observe_local(LiveQueryEventCallback event_callback) const;
 
  std::shared_ptr<LiveQuery> observe_with_next_signal(
      LiveQueryWithNextSignalEventHandler handler) const DITTO_DEPRECATED;
 
  std::shared_ptr<LiveQuery> observe_with_next_signal(
      LiveQueryEventWithNextSignalCallback event_callback) const;
 
  std::shared_ptr<LiveQuery> observe_local_with_next_signal(
      LiveQueryWithNextSignalEventHandler handler) const DITTO_DEPRECATED;
 
  std::shared_ptr<LiveQuery> observe_local_with_next_signal(
      LiveQueryEventWithNextSignalCallback event_callback) const;
};
} // namespace ditto
#endif