Differ.hpp

#ifndef _DITTO_DIFFER_
#define _DITTO_DIFFER_
 
#include "QueryResult.hpp"
 
#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <set>
#include <utility>
 
namespace ditto {

using IndexSet = std::set<std::size_t>;

struct Diff {
public:
  struct Move {
    std::size_t from;

    std::size_t to;

    Move(std::size_t from, std::size_t to) : from(from), to(to) {}

    Move() : from(0), to(0) {}
 
    Move(const Move &other) = default;
    Move &operator=(const Move &other) = default;
    Move(Move &&other) = default;
    Move &operator=(Move &&other) = default;
 
    bool operator==(const Move &other) const {
      return from == other.from && to == other.to;
    }
 
    bool operator!=(const Move &other) const { return !(*this == other); }
 
    bool operator<(const Move &other) const {
      return from < other.from || (from == other.from && to < other.to);
    }
  };

  IndexSet insertions;

  IndexSet deletions;

  IndexSet updates;

  std::vector<Move> moves;

  Diff() = default;

  Diff(IndexSet insertions, IndexSet deletions, IndexSet updates,
       std::vector<Move> moves)
      : insertions(std::move(insertions)), deletions(std::move(deletions)),
        updates(std::move(updates)), moves(std::move(moves)) {}


  explicit Diff(const nlohmann::json &json);
 
  Diff(const Diff &other) = default;
  Diff &operator=(const Diff &other) = default;
  Diff(Diff &&other) = default;
  Diff &operator=(Diff &&other) = default;

  bool operator==(const Diff &other) const;

  bool operator!=(const Diff &other) const;
};

class Differ {
private:
  std::shared_ptr<dittoffi_differ_t> ffi_differ;
 
public:
  Differ();
 
  ~Differ();
 
  Differ(const Differ &) = delete;
  Differ &operator=(const Differ &) = delete;
  Differ(Differ &&) = default;
  Differ &operator=(Differ &&) = default;

  Diff diff(const std::vector<QueryResultItem> &items);
};
 
} // namespace ditto
 
#endif