Method deserialize_impl

ext/include/tsl/array-hash/array_hash.h:1653–1727

  template <class Deserializer>
  void deserialize_impl(Deserializer& deserializer, bool hash_compatible) {
    tsl_ah_assert(m_buckets_data.empty());  // Current hash table must be empty

    const slz_size_type version =
        deserialize_value<slz_size_type>(deserializer);
    // For now we only have one version of the serialization protocol.
    // If it doesn't match there is a problem with the file.
    if (version != SERIALIZATION_PROTOCOL_VERSION) {
      throw std::runtime_error(
          "Can't deserialize the array_map/set. The protocol version header is "
          "invalid.");
    }

    const slz_size_type bucket_count_ds =
        deserialize_value<slz_size_type>(deserializer);
    const slz_size_type nb_elements =
        deserialize_value<slz_size_type>(deserializer);
    const float max_load_factor = deserialize_value<float>(deserializer);

    m_nb_elements = numeric_cast<IndexSizeT>(
        nb_elements, "Deserialized nb_elements is too big.");

    size_type bucket_count = numeric_cast<size_type>(
        bucket_count_ds, "Deserialized bucket_count is too big.");
    GrowthPolicy::operator=(GrowthPolicy(bucket_count));

    this->max_load_factor(max_load_factor);
    value_container<T>::reserve(m_nb_elements);

    if (hash_compatible) {
      if (bucket_count != bucket_count_ds) {
        throw std::runtime_error(
            "The GrowthPolicy is not the same even though hash_compatible is "
            "true.");
      }

      m_buckets_data.reserve(bucket_count);
      for (size_type i = 0; i < bucket_count; i++) {
        m_buckets_data.push_back(array_bucket::deserialize(deserializer));
        deserialize_bucket_values(deserializer, m_buckets_data.back());
      }
    } else {
      m_buckets_data.resize(bucket_count);
      for (size_type i = 0; i < bucket_count; i++) {
        // TODO use buffer to avoid reallocation on each deserialization.
        array_bucket bucket = array_bucket::deserialize(deserializer);
        deserialize_bucket_values(deserializer, bucket);

        for (auto it_val = bucket.cbegin(); it_val != bucket.cend(); ++it_val) {
          const std::size_t ibucket =
              bucket_for_hash(hash_key(it_val.key(), it_val.key_size()));

          auto it_find = m_buckets_data[ibucket].find_or_end_of_bucket(
              it_val.key(), it_val.key_size());
          if (it_find.second) {
            throw std::runtime_error(
                "Error on deserialization, the same key is presents multiple "
                "times.");