Update robin_map 1.2.1 ==> 1.3.0-054ec5a

Author: halx99

3rdparty/README.md

@@ -212,9 +212,10 @@
 
 ## robin-map
 - [![Upstream](https://img.shields.io/github/v/tag/Tessil/robin-map?label=Upstream)](https://github.com/Tessil/robin-map)
-- Version: 1.2.1 with modified for more compatible with stl
+- Version: 1.3.0-054ec5a (until Mar 17, 2025) with modified for stl compatibility
     - Modify `robin_map::iterator->second` to mutable same with `stl map/unordered_map`
     - Forward `robin_map::operator[]` key by `std::forward` same with `stl map/unordered_map`
+    - Improve code compiler compatibility, i.g. `std::max` ==> `(std::max)`
 - License: MIT
 
 ## simdjson

3rdparty/robin-map/include/tsl/robin_growth_policy.h

@@ -35,6 +35,16 @@
 #include <ratio>
 #include <stdexcept>
 
+// A change of the major version indicates an API and/or ABI break (change of
+// in-memory layout of the data structure)
+#define TSL_RH_VERSION_MAJOR 1
+// A change of the minor version indicates the addition of a feature without
+// impact on the API/ABI
+#define TSL_RH_VERSION_MINOR 3
+// A change of the patch version indicates a bugfix without additional
+// functionality
+#define TSL_RH_VERSION_PATCH 0
+
 #ifdef TSL_DEBUG
 #define tsl_rh_assert(expr) assert(expr)
 #else
@@ -243,7 +253,7 @@ namespace detail {
 #define TSL_RH_NB_PRIMES 23
 #endif
 
-static constexpr const std::array<std::size_t, TSL_RH_NB_PRIMES> PRIMES = {{
+inline constexpr std::array<std::size_t, TSL_RH_NB_PRIMES> PRIMES = {{
     1u,
     5u,
     17u,
@@ -309,8 +319,7 @@ static constexpr std::size_t mod(std::size_t hash) {
 // MOD_PRIME[iprime](hash) returns hash % PRIMES[iprime]. This table allows for
 // faster modulo as the compiler can optimize the modulo code better with a
 // constant known at the compilation.
-static constexpr const std::array<std::size_t (*)(std::size_t),
-                                  TSL_RH_NB_PRIMES>
+inline constexpr std::array<std::size_t (*)(std::size_t), TSL_RH_NB_PRIMES>
     MOD_PRIME = {{
         &mod<0>,  &mod<1>,  &mod<2>,  &mod<3>,  &mod<4>,  &mod<5>,
         &mod<6>,  &mod<7>,  &mod<8>,  &mod<9>,  &mod<10>, &mod<11>,

3rdparty/robin-map/include/tsl/robin_hash.h

@@ -66,12 +66,6 @@ template <std::size_t GrowthFactor>
 struct is_power_of_two_policy<tsl::rh::power_of_two_growth_policy<GrowthFactor>>
     : std::true_type {};
 
-// Only available in C++17, we need to be compatible with C++11
-template <class T>
-const T& clamp(const T& v, const T& lo, const T& hi) {
-  return (std::min)(hi, (std::max)(lo, v));
-}
-
 template <typename T, typename U>
 static T numeric_cast(U value,
                       const char* error_message = "numeric_cast() failed.") {
@@ -87,6 +81,8 @@ static T numeric_cast(U value,
     TSL_RH_THROW_OR_TERMINATE(std::runtime_error, error_message);
   }
 
+  TSL_RH_UNUSED(error_message);
+
   return ret;
 }
 
@@ -252,22 +248,14 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
 
   value_type& value() noexcept {
     tsl_rh_assert(!empty());
-#if defined(__cplusplus) && __cplusplus >= 201703L
     return *std::launder(
         reinterpret_cast<value_type*>(std::addressof(m_value)));
-#else
-    return *reinterpret_cast<value_type*>(std::addressof(m_value));
-#endif
   }
 
   const value_type& value() const noexcept {
     tsl_rh_assert(!empty());
-#if defined(__cplusplus) && __cplusplus >= 201703L
     return *std::launder(
         reinterpret_cast<const value_type*>(std::addressof(m_value)));
-#else
-    return *reinterpret_cast<const value_type*>(std::addressof(m_value));
-#endif
   }
 
   distance_type dist_from_ideal_bucket() const noexcept {
@@ -597,7 +585,6 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
   using const_iterator = robin_const_iterator;
 
  public:
-#if defined(__cplusplus) && __cplusplus >= 201402L
   robin_hash(size_type bucket_count, const Hash& hash, const KeyEqual& equal,
              const Allocator& alloc,
              float min_load_factor = DEFAULT_MIN_LOAD_FACTOR,
@@ -625,47 +612,6 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     this->min_load_factor(min_load_factor);
     this->max_load_factor(max_load_factor);
   }
-#else
-  /**
-   * C++11 doesn't support the creation of a std::vector with a custom allocator
-   * and 'count' default-inserted elements. The needed contructor `explicit
-   * vector(size_type count, const Allocator& alloc = Allocator());` is only
-   * available in C++14 and later. We thus must resize after using the
-   * `vector(const Allocator& alloc)` constructor.
-   *
-   * We can't use `vector(size_type count, const T& value, const Allocator&
-   * alloc)` as it requires the value T to be copyable.
-   */
-  robin_hash(size_type bucket_count, const Hash& hash, const KeyEqual& equal,
-             const Allocator& alloc,
-             float min_load_factor = DEFAULT_MIN_LOAD_FACTOR,
-             float max_load_factor = DEFAULT_MAX_LOAD_FACTOR)
-      : Hash(hash),
-        KeyEqual(equal),
-        GrowthPolicy(bucket_count),
-        m_buckets_data(alloc),
-        m_buckets(static_empty_bucket_ptr()),
-        m_bucket_count(bucket_count),
-        m_nb_elements(0),
-        m_grow_on_next_insert(false),
-        m_try_shrink_on_next_insert(false) {
-    if (bucket_count > max_bucket_count()) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The map exceeds its maximum bucket count.");
-    }
-
-    if (m_bucket_count > 0) {
-      m_buckets_data.resize(m_bucket_count);
-      m_buckets = m_buckets_data.data();
-
-      tsl_rh_assert(!m_buckets_data.empty());
-      m_buckets_data.back().set_as_last_bucket();
-    }
-
-    this->min_load_factor(min_load_factor);
-    this->max_load_factor(max_load_factor);
-  }
-#endif
 
   robin_hash(const robin_hash& other)
       : Hash(other),
@@ -876,6 +822,10 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     return try_emplace(std::forward<K>(key), std::forward<Args>(args)...).first;
   }
 
+  void erase_fast(iterator pos) {
+    erase_from_bucket(pos);
+  }
+
   /**
    * Here to avoid `template<class K> size_type erase(const K& key)` being used
    * when we use an `iterator` instead of a `const_iterator`.
@@ -892,8 +842,6 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
       ++pos;
     }
 
-    m_try_shrink_on_next_insert = true;
-
     return pos;
   }
 
@@ -972,8 +920,6 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     auto it = find(key, hash);
     if (it != end()) {
       erase_from_bucket(it);
-      m_try_shrink_on_next_insert = true;
-
       return 1;
     } else {
       return 0;
@@ -1129,13 +1075,13 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
   float max_load_factor() const { return m_max_load_factor; }
 
   void min_load_factor(float ml) {
-    m_min_load_factor = clamp(ml, float(MINIMUM_MIN_LOAD_FACTOR),
-                              float(MAXIMUM_MIN_LOAD_FACTOR));
+    m_min_load_factor = std::clamp(ml, float(MINIMUM_MIN_LOAD_FACTOR),
+                                   float(MAXIMUM_MIN_LOAD_FACTOR));
   }
 
   void max_load_factor(float ml) {
-    m_max_load_factor = clamp(ml, float(MINIMUM_MAX_LOAD_FACTOR),
-                              float(MAXIMUM_MAX_LOAD_FACTOR));
+    m_max_load_factor = std::clamp(ml, float(MINIMUM_MAX_LOAD_FACTOR),
+                                   float(MAXIMUM_MAX_LOAD_FACTOR));
     m_load_threshold = size_type(float(bucket_count()) * m_max_load_factor);
     tsl_rh_assert(bucket_count() == 0 || m_load_threshold < bucket_count());
   }
@@ -1267,6 +1213,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
       previous_ibucket = ibucket;
       ibucket = next_bucket(ibucket);
     }
+    m_try_shrink_on_next_insert = true;
   }
 
   template <class K, class... Args>
@@ -1579,6 +1526,9 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     } else {
       m_bucket_count = numeric_cast<size_type>(
           bucket_count_ds, "Deserialized bucket_count is too big.");
+      // Recompute m_load_threshold, during max_load_factor() the bucket count
+      // was still 0 which would trigger rehash on first insert
+      m_load_threshold = size_type(float(bucket_count()) * m_max_load_factor);
 
       GrowthPolicy::operator=(GrowthPolicy(m_bucket_count));
       // GrowthPolicy should not modify the bucket count we got from

3rdparty/robin-map/include/tsl/robin_map.h

@@ -344,6 +344,14 @@ class robin_map {
   }
   size_type erase(const key_type& key) { return m_ht.erase(key); }
 
+  /**
+   * Erase the element at position 'pos'. In contrast to the regular erase()
+   * function, erase_fast() does not return an iterator. This allows it to be
+   * faster especially in hash tables with a low load factor, where finding the
+   * next nonempty bucket would be costly.
+   */
+  void erase_fast(iterator pos) { return m_ht.erase_fast(pos); }
+
   /**
    * Use the hash value 'precalculated_hash' instead of hashing the key. The
    * hash value should be the same as hash_function()(key). Useful to speed-up

3rdparty/robin-map/include/tsl/robin_set.h

@@ -264,6 +264,14 @@ class robin_set {
   }
   size_type erase(const key_type& key) { return m_ht.erase(key); }
 
+  /**
+   * Erase the element at position 'pos'. In contrast to the regular erase()
+   * function, erase_fast() does not return an iterator. This allows it to be
+   * faster especially in hash sets with a low load factor, where finding the
+   * next nonempty bucket would be costly.
+   */
+  void erase_fast(iterator pos) { return m_ht.erase_fast(pos); }
+
   /**
    * Use the hash value 'precalculated_hash' instead of hashing the key. The
    * hash value should be the same as hash_function()(key). Useful to speed-up