WriteTransactionPendingCursorOperation.hpp

#ifndef DITTO_WRITE_TRANSACTION_PENDING_CURSOR_OPERATION_H
#define DITTO_WRITE_TRANSACTION_PENDING_CURSOR_OPERATION_H
 
#include "Document.hpp"
#include "DocumentId.hpp"
#include "MutableDocument.hpp"
#include "SortDirection.hpp"
#include "UpdateResult.hpp"
#include "WriteTransaction.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace ditto {
class DittoHandleWrapper;

class DITTO_DEPRECATED_BECAUSE(
    "Use DQL (Ditto Query Language) instead. For more information see: "
    "https://ditto.com/link/legacy-to-dql-guide")
    WriteTransactionPendingCursorOperation {
  DITTO_DISABLE_DEPRECATED_WARNINGS("The legacy query API is deprecated")
 
  friend class ScopedWriteTransaction;
 
  nlohmann::json query_args;
  // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
  WriteTransaction &base_transaction;
  uint32_t _offset = 0;
  int32_t _limit = -1;
 
  WriteTransactionPendingCursorOperation(
      std::string collection_name, std::string query, nlohmann::json query_args,
      std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper,
      WriteTransaction &base_transaction);
 
  WriteTransactionPendingCursorOperation(
      WriteTransactionPendingCursorOperation &&other) noexcept;
  WriteTransactionPendingCursorOperation &
  operator=(WriteTransactionPendingCursorOperation &&other) noexcept;
 
  class Impl;
  std::unique_ptr<Impl> impl_;
 
public:
  ~WriteTransactionPendingCursorOperation();

  // TODO(v5): make collection_name private and provide a getter
  std::string collection_name; // NOLINT

  // TODO(v5): make query private and provide a getter
  std::string query; // NOLINT

  WriteTransactionPendingCursorOperation &limit(uint32_t limit);

  WriteTransactionPendingCursorOperation &offset(uint32_t offset);

  WriteTransactionPendingCursorOperation &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) const;

  std::vector<DocumentId> remove() const;

  std::vector<DocumentId> evict() const;
 
  DITTO_REENABLE_WARNINGS
};
} // namespace ditto
#endif