hash.hpp

#pragma once
 
#include <cstddef>
#include <functional>
#include <map>
#include <set>
#include <utility>
#include <vector>

namespace delpi::hash {

template <class T>
size_t hash_combine(size_t seed, const T &v);
 
template <class T, class... Rest>
size_t hash_combine(size_t seed, const T &v, Rest... rest) {
  return hash_combine(hash_combine(seed, v), rest...);
}

template <typename It>
size_t hash_range(It first, It last) {
  size_t seed{};
  for (; first != last; ++first) {
    seed = hash_combine(seed, *first);
  }
  return seed;
}

template <class T>
struct hash_value {
  size_t operator()(const T &v) const { return std::hash<T>{}(v); }
};

template <class T1, class T2>
struct hash_value<std::pair<T1, T2>> {
  size_t operator()(const std::pair<T1, T2> &p) const { return hash_combine(0, p.first, p.second); }
};

template <class T>
struct hash_value<std::vector<T>> {
  size_t operator()(const std::vector<T> &vec) const { return hash_range(vec.begin(), vec.end()); }
};

template <class T>
struct hash_value<std::set<T>> {
  size_t operator()(const std::set<T> &s) const { return hash_range(s.begin(), s.end()); }
};

template <class T1, class T2>
struct hash_value<std::map<T1, T2>> {
  size_t operator()(const std::map<T1, T2> &map) const { return hash_range(map.begin(), map.end()); }
};

template <class T>
inline size_t hash_combine(size_t seed, const T &v) {
  seed ^= hash_value<T>{}(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
  return seed;
}
 
}  // namespace delpi::hash