hash.h

#pragma once
 
#include <cstddef>
#include <functional>
#include <map>
#include <set>
#include <utility>
#include <vector>
 
namespace dlinear::drake {
 
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 dlinear::drake