Method rehash_impl

ext/include/tsl/array-hash/array_hash.h:1536–1584

  }

  void rehash_impl(size_type bucket_count) {
    GrowthPolicy new_growth_policy(bucket_count);
    if (bucket_count == this->bucket_count()) {
      return;
    }

    if (should_clear_old_erased_values(
            REHASH_CLEAR_OLD_ERASED_VALUE_THRESHOLD)) {
      clear_old_erased_values();
    }

    std::vector<std::size_t> required_size_for_bucket(bucket_count, 0);
    std::vector<std::size_t> bucket_for_ivalue(size(), 0);

    std::size_t ivalue = 0;
    for (auto it = begin(); it != end(); ++it) {
      const std::size_t hash = hash_key(it.key(), it.key_size());
      const std::size_t ibucket = new_growth_policy.bucket_for_hash(hash);

      bucket_for_ivalue[ivalue] = ibucket;
      required_size_for_bucket[ibucket] +=
          array_bucket::entry_required_bytes(it.key_size());
      ivalue++;
    }

    std::vector<array_bucket> new_buckets;
    new_buckets.reserve(bucket_count);
    for (std::size_t ibucket = 0; ibucket < bucket_count; ibucket++) {
      new_buckets.emplace_back(required_size_for_bucket[ibucket]);
    }

    ivalue = 0;
    for (auto it = begin(); it != end(); ++it) {
      const std::size_t ibucket = bucket_for_ivalue[ivalue];
      append_iterator_in_reserved_bucket_no_check(new_buckets[ibucket], it);

      ivalue++;
    }

    using std::swap;
    swap(static_cast<GrowthPolicy&>(*this), new_growth_policy);

    m_buckets_data.swap(new_buckets);
    m_buckets = !m_buckets_data.empty() ? m_buckets_data.data()
                                        : static_empty_bucket_ptr();

    // Call max_load_factor to change m_load_threshold
    max_load_factor(m_max_load_factor);
  }

  template <class U = T, typename std::enable_if<
                             !has_mapped_type<U>::value>::type* = nullptr>