Class array_hash

ext/include/tsl/array-hash/array_hash.h:767–1804

          bool StoreNullTerminator, class KeySizeT, class IndexSizeT,
          class GrowthPolicy>
class array_hash : private value_container<T>,
                   private Hash,
                   private GrowthPolicy {
 private:
  template <typename U>
  using has_mapped_type =
      typename std::integral_constant<bool, !std::is_same<U, void>::value>;

  /**
   * If there is a mapped type in array_hash, we store the values in m_values of
   * value_container class and we store an index to m_values in the bucket. The
   * index is of type IndexSizeT.
   */
  using array_bucket = tsl::detail_array_hash::array_bucket<
      CharT,
      typename std::conditional<has_mapped_type<T>::value, IndexSizeT,
                                void>::type,
      KeyEqual, KeySizeT, StoreNullTerminator>;

 public:
  template <bool IsConst>
  class array_hash_iterator;

  using char_type = CharT;
  using key_size_type = KeySizeT;
  using index_size_type = IndexSizeT;
  using size_type = std::size_t;
  using hasher = Hash;
  using key_equal = KeyEqual;
  using iterator = array_hash_iterator<false>;
  using const_iterator = array_hash_iterator<true>;

  /*
   * Iterator classes
   */
 public:
  template <bool IsConst>
  class array_hash_iterator {
    friend class array_hash;

   private:
    using iterator_array_bucket = typename array_bucket::const_iterator;

    using iterator_buckets = typename std::conditional<
        IsConst, typename std::vector<array_bucket>::const_iterator,
        typename std::vector<array_bucket>::iterator>::type;

    using array_hash_ptr = typename std::conditional<IsConst, const array_hash*,
                                                     array_hash*>::type;

   public:
    using iterator_category = std::forward_iterator_tag;
    using value_type =
        typename std::conditional<has_mapped_type<T>::value, T, void>::type;
    using difference_type = std::ptrdiff_t;
    using reference = typename std::conditional<
        has_mapped_type<T>::value,
        typename std::conditional<