Replace boost::hash by std::hash (#6892)

* Replace boost::hash by std::hash

* Fix formatting

* Update CHANGELOG.md

include/util/guidance/bearing_class.hpp

@@ -1,15 +1,14 @@
 #ifndef OSRM_UTIL_GUIDANCE_BEARING_CLASS_HPP_
 #define OSRM_UTIL_GUIDANCE_BEARING_CLASS_HPP_
 
+#include "util/std_hash.hpp"
+#include "util/typedefs.hpp"
+
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <vector>
 
-#include <boost/functional/hash.hpp>
-
-#include "util/typedefs.hpp"
-
 namespace osrm::util::guidance
 {
 class BearingClass;
@@ -62,7 +61,10 @@ namespace std
 inline size_t hash<::osrm::util::guidance::BearingClass>::operator()(
     const ::osrm::util::guidance::BearingClass &bearing_class) const
 {
-    return boost::hash_value(bearing_class.available_bearings);
+    std::size_t value = 0;
+    hash_range(
+        value, bearing_class.available_bearings.cbegin(), bearing_class.available_bearings.cend());
+    return value;
 }
 } // namespace std
 

include/util/guidance/turn_lanes.hpp

@@ -1,36 +1,22 @@
 #ifndef OSRM_UTIL_GUIDANCE_TURN_LANES_HPP
 #define OSRM_UTIL_GUIDANCE_TURN_LANES_HPP
 
+#include "util/concurrent_id_map.hpp"
+#include "util/std_hash.hpp"
+#include "util/typedefs.hpp"
+
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <unordered_map>
 #include <vector>
 
-#include "util/concurrent_id_map.hpp"
-#include "util/typedefs.hpp"
-
-#include <boost/functional/hash.hpp>
-
 namespace osrm::util::guidance
 {
 class LaneTuple;
 class LaneTupleIdPair;
 } // namespace osrm::util::guidance
 
-namespace std
-{
-template <> struct hash<::osrm::util::guidance::LaneTuple>
-{
-    inline std::size_t operator()(const ::osrm::util::guidance::LaneTuple &bearing_class) const;
-};
-template <> struct hash<::osrm::util::guidance::LaneTupleIdPair>
-{
-    inline std::size_t
-    operator()(const ::osrm::util::guidance::LaneTupleIdPair &bearing_class) const;
-};
-} // namespace std
-
 namespace osrm::util::guidance
 {
 
@@ -61,14 +47,6 @@ class LaneTuple
 
     LaneID lanes_in_turn;
     LaneID first_lane_from_the_right; // is INVALID_LANEID when no lanes present
-
-    friend std::size_t hash_value(const LaneTuple &tup)
-    {
-        std::size_t seed{0};
-        boost::hash_combine(seed, tup.lanes_in_turn);
-        boost::hash_combine(seed, tup.first_lane_from_the_right);
-        return seed;
-    }
 };
 
 class LaneTupleIdPair
@@ -78,18 +56,36 @@ class LaneTupleIdPair
     LaneDescriptionID second;
 
     bool operator==(const LaneTupleIdPair &other) const;
+};
 
-    friend std::size_t hash_value(const LaneTupleIdPair &pair)
+using LaneDataIdMap = ConcurrentIDMap<LaneTupleIdPair, LaneDataID>;
+
+} // namespace osrm::util::guidance
+
+namespace std
+{
+template <> struct hash<::osrm::util::guidance::LaneTuple>
+{
+    inline std::size_t operator()(const ::osrm::util::guidance::LaneTuple &lane_tuple) const
     {
         std::size_t seed{0};
-        boost::hash_combine(seed, pair.first);
-        boost::hash_combine(seed, pair.second);
+        hash_combine(seed, lane_tuple.lanes_in_turn);
+        hash_combine(seed, lane_tuple.first_lane_from_the_right);
         return seed;
     }
 };
 
-using LaneDataIdMap = ConcurrentIDMap<LaneTupleIdPair, LaneDataID, boost::hash<LaneTupleIdPair>>;
-
-} // namespace osrm::util::guidance
+template <> struct hash<::osrm::util::guidance::LaneTupleIdPair>
+{
+    inline std::size_t
+    operator()(const ::osrm::util::guidance::LaneTupleIdPair &lane_tuple_id_pair) const
+    {
+        std::size_t seed{0};
+        hash_combine(seed, lane_tuple_id_pair.first);
+        hash_combine(seed, lane_tuple_id_pair.second);
+        return seed;
+    }
+};
+} // namespace std
 
 #endif /* OSRM_UTIL_GUIDANCE_TURN_LANES_HPP */

include/util/std_hash.hpp

@@ -1,7 +1,11 @@
 #ifndef STD_HASH_HPP
 #define STD_HASH_HPP
 
+#include <cstddef>
 #include <functional>
+#include <tuple>
+#include <utility>
+#include <vector>
 
 // this is largely inspired by boost's hash combine as can be found in
 // "The C++ Standard Library" 2nd Edition. Nicolai M. Josuttis. 2012.
@@ -11,6 +15,14 @@ template <typename T> void hash_combine(std::size_t &seed, const T &val)
     seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 }
 
+template <typename It> void hash_range(std::size_t &seed, It first, const It last)
+{
+    for (; first != last; ++first)
+    {
+        hash_combine(seed, *first);
+    }
+}
+
 template <typename T> void hash_val(std::size_t &seed, const T &val) { hash_combine(seed, val); }
 
 template <typename T, typename... Types>
@@ -29,13 +41,39 @@ template <typename... Types> std::size_t hash_val(const Types &...args)
 
 namespace std
 {
+template <typename... T> struct hash<std::tuple<T...>>
+{
+    template <std::size_t... I>
+    static auto apply_tuple(const std::tuple<T...> &t, std::index_sequence<I...>)
+    {
+        std::size_t seed = 0;
+        return ((seed = hash_val(std::get<I>(t), seed)), ...);
+    }
+
+    auto operator()(const std::tuple<T...> &t) const
+    {
+        return apply_tuple(t, std::make_index_sequence<sizeof...(T)>());
+    }
+};
+
 template <typename T1, typename T2> struct hash<std::pair<T1, T2>>
 {
-    size_t operator()(const std::pair<T1, T2> &pair) const
+    std::size_t operator()(const std::pair<T1, T2> &pair) const
     {
         return hash_val(pair.first, pair.second);
     }
 };
+
+template <typename T> struct hash<std::vector<T>>
+{
+    auto operator()(const std::vector<T> &lane_description) const
+    {
+        std::size_t seed = 0;
+        hash_range(seed, lane_description.begin(), lane_description.end());
+        return seed;
+    }
+};
+
 } // namespace std
 
 #endif // STD_HASH_HPP

include/util/trigonometry_table.hpp

@@ -364,7 +364,6 @@ const constexpr double SCALING_FACTOR = 4. / boost::math::constants::pi<double>(
 
 inline double atan2_lookup(double y, double x)
 {
-
     using namespace boost::math::constants;
 
     if (std::abs(x) < std::numeric_limits<double>::epsilon())