P1661R1 Remove dedicated precalculated hash lookup interface

Author: jensmaurer

source/containers.tex

@@ -2292,9 +2292,8 @@
   \end{itemize}
   where \tcode{r1} and \tcode{r2} are keys of elements in \tcode{a_tran},
 \item \tcode{n} denotes a value of type \tcode{size_type},
-\item \tcode{z} denotes a value of type \tcode{float},
-\item \tcode{nh} denotes a non-const rvalue of type \tcode{X::node_type}, and
-\item \tcode{hk} and \tcode{hke} denote values of type \tcode{size_t}.
+\item \tcode{z} denotes a value of type \tcode{float}, and
+\item \tcode{nh} denotes a non-const rvalue of type \tcode{X::node_type}.
 \end{itemize}
 
 % Local command to index names as members of all unordered containers.
@@ -2748,14 +2747,6 @@
 &   Average case \bigoh{1}, worst case \bigoh{\tcode{b.size()}}.
 \\ \rowsep
 %
-\tcode{b.find(k, hk)}
-&   \tcode{iterator}; \br \tcode{const_iterator} for const \tcode{b}.
-&   \expects \tcode{b.hash_function()(k)} equals \tcode{hk}.\br
-    \returns An iterator pointing to an element with key equivalent to
-    \tcode{k}, or \tcode{b.end()} if no such element exists.
-&   Average case \bigoh{1}, worst case \bigoh{\tcode{b.size()}}.
-\\ \rowsep
-%
 \tcode{a_tran.find(ke)}
 &   \tcode{iterator}; \br \tcode{const_iterator} for const \tcode{a_tran}.
 &   \returns An iterator pointing to an element with key equivalent to
@@ -2764,29 +2755,13 @@
     worst case \bigoh{\tcode{a_tran.}\br{}\tcode{size()}}. % avoid overfull
 \\ \rowsep
 %
-\tcode{a_tran.find(ke, hke)}
-&   \tcode{iterator}; \br \tcode{const_iterator} for const \tcode{a_tran}.
-&   \expects \tcode{a_tran.hash_function()(ke)} equals \tcode{hke}.\br
-    \returns An iterator pointing to an element with key equivalent to
-    \tcode{ke}, or \tcode{a_tran.end()} if no such element exists.%
-&   Average case \bigoh{1},
-    worst case \bigoh{\tcode{a_tran.}\br{}\tcode{size()}}. % avoid overfull
-\\ \rowsep
-%
 \indexunordmem{count}%
 \tcode{b.count(k)}
 &   \tcode{size_type}
 &   \returns The number of elements with key equivalent to \tcode{k}.%
 &   Average case \bigoh{\tcode{b.count(k)}}, worst case \bigoh{\tcode{b.size()}}.
 \\ \rowsep
 %
-\tcode{b.count(k, hk)}
-&   \tcode{size_type}
-&   \expects \tcode{b.hash_function()(k)} equals \tcode{hk}.\br
-    \returns The number of elements with key equivalent to \tcode{k}.%
-&   Average case \bigoh{\tcode{b.count(k)}}, worst case \bigoh{\tcode{b.size()}}.
-\\ \rowsep
-%
 \tcode{a_tran.count(ke)}
 &   \tcode{size_type}
 &   \returns The number of elements with key equivalent to \tcode{ke}.%
@@ -2795,44 +2770,20 @@
     worst case \bigoh{\tcode{a_tran.}\br{}\tcode{size()}}. % avoid overfull
 \\ \rowsep
 %
-\tcode{a_tran.count(ke, hke)}
-&   \tcode{size_type}
-&   \expects \tcode{b.hash_function()(ke)} equals \tcode{hke}.\br
-    \returns The number of elements with key equivalent to \tcode{ke}.%
-&   Average case
-    \bigoh{\tcode{a_tran.}\br{}\tcode{count(ke)}}, % avoid overfull
-    worst case \bigoh{\tcode{a_tran.}\br{}\tcode{size()}}. % avoid overfull
-\\ \rowsep
-%
 \indexunordmem{contains}%
 \tcode{b.contains(k)}
 &   \tcode{bool}
 &   \effects Equivalent to \tcode{b.find(k) != b.end()}%
 &   Average case \bigoh{1}, worst case \bigoh{\tcode{b.size()}}.
 \\ \rowsep
 %
-\tcode{b.contains(k, hk)}
-&   \tcode{bool}
-&   \expects \tcode{b.hash_function()(ke)} equals \tcode{hke}.\br
-    \effects Equivalent to \tcode{b.find(k) != b.end()}%
-&   Average case \bigoh{1}, worst case \bigoh{\tcode{b.size()}}.
-\\ \rowsep
-%
 \tcode{a_tran.contains(ke)}
 &   \tcode{bool}
 &   \effects Equivalent to \tcode{a_tran.find(ke) != a_tran.end()}%
 &   Average case \bigoh{1},
     worst case \bigoh{\tcode{a_tran.}\br{}\tcode{size()}}. % avoid overfull
 \\ \rowsep
 %
-\tcode{a_tran.contains(ke, hke)}
-&   \tcode{bool}
-&   \expects \tcode{a_tran.hash_function()(ke)} equals \tcode{hke}.\br
-    \effects Equivalent to \tcode{a_tran.find(ke, hke) != a_tran.end()}%
-&   Average case \bigoh{1},
-    worst case \bigoh{\tcode{a_tran.}\br{}\tcode{size()}}. % avoid overfull
-\\ \rowsep
-%
 \indexunordmem{equal_range}%
 \tcode{b.equal_range(k)}
 &   \tcode{pair<iterator, iterator>}; \br
@@ -2844,17 +2795,6 @@
     \bigoh{\tcode{b.size()}}.
 \\ \rowsep
 %
-\tcode{b.equal_range(k, hk)}
-&   \tcode{pair<iterator, iterator>}; \br
-    \tcode{pair<const_iterator, const_iterator>} for const \tcode{b}.
-&   \expects \tcode{b.hash_function()(k)} equals \tcode{hk}.\br
-    \returns A range containing all elements with keys equivalent to
-    \tcode{k}.  Returns \tcode{make_pair(b.end(), b.end())} if
-    no such elements exist.%
-&   Average case \bigoh{\tcode{b.count(k)}}, worst case
-    \bigoh{\tcode{b.size()}}.
-\\ \rowsep
-%
 \tcode{a_tran.equal_range(ke)}
 &   \tcode{pair<iterator, iterator>}; \br
     \tcode{pair<const_iterator, const_iterator>} for const \tcode{a_tran}.
@@ -2866,17 +2806,6 @@
     worst case \bigoh{\tcode{a_tran.}\br{}\tcode{size()}}. % avoid overfull
 \\ \rowsep
 %
-\tcode{a_tran.equal_range(ke, hke)}
-&   \tcode{pair<iterator, iterator>}; \br
-    \tcode{pair<const_iterator, const_iterator>} for const \tcode{a_tran}.
-&   \expects \tcode{a_tran.hash_function()(ke)} equals \tcode{hke}.\br
-    \returns A range containing all elements with keys equivalent to
-    \tcode{ke}.  Returns \tcode{make_pair(a_tran.end(), a_tran.end())} if
-    no such elements exist.%
-&   Average case
-    \bigoh{\tcode{a_tran.}\br{}\tcode{count(ke)}}, % avoid overfull
-    worst case \bigoh{\tcode{a_tran.}\br{}\tcode{size()}}. % avoid overfull
-\\ \rowsep
 \indexunordmem{bucket_count}%
 \tcode{b.bucket_count()}
 &   \tcode{size_type}
@@ -7989,40 +7918,23 @@
     // map operations
     iterator         find(const key_type& k);
     const_iterator   find(const key_type& k) const;
-    iterator         find(const key_type& k, size_t hash);
-    const_iterator   find(const key_type& k, size_t hash) const;
     template<class K>
       iterator       find(const K& k);
     template<class K>
       const_iterator find(const K& k) const;
     template<class K>
-      iterator       find(const K& k, size_t hash);
-    template<class K>
-      const_iterator find(const K& k, size_t hash) const;
     size_type        count(const key_type& k) const;
-    size_type        count(const key_type& k, size_t hash) const;
     template<class K>
       size_type      count(const K& k) const;
-    template<class K>
-      size_type      count(const K& k, size_t hash) const;
     bool             contains(const key_type& k) const;
-    bool             contains(const key_type& k, size_t hash) const;
     template<class K>
       bool           contains(const K& k) const;
-    template<class K>
-      bool           contains(const K& k, size_t hash) const;
     pair<iterator, iterator>               equal_range(const key_type& k);
     pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
-    pair<iterator, iterator>               equal_range(const key_type& k, size_t hash);
-    pair<const_iterator, const_iterator>   equal_range(const key_type& k, size_t hash) const;
     template<class K>
       pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
       pair<const_iterator, const_iterator> equal_range(const K& k) const;
-    template<class K>
-      pair<iterator, iterator>             equal_range(const K& k, size_t hash);
-    template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& k, size_t hash) const;
 
     // \ref{unord.map.elem}, element access
     mapped_type& operator[](const key_type& k);
@@ -8577,40 +8489,22 @@
     // map operations
     iterator         find(const key_type& k);
     const_iterator   find(const key_type& k) const;
-    iterator         find(const key_type& k, size_t hash);
-    const_iterator   find(const key_type& k, size_t hash) const;
     template<class K>
       iterator       find(const K& k);
     template<class K>
       const_iterator find(const K& k) const;
-    template<class K>
-      iterator       find(const K& k, size_t hash);
-    template<class K>
-      const_iterator find(const K& k, size_t hash) const;
     size_type        count(const key_type& k) const;
-    size_type        count(const key_type& k, size_t hash) const;
     template<class K>
       size_type      count(const K& k) const;
-    template<class K>
-      size_type      count(const K& k, size_t hash) const;
     bool             contains(const key_type& k) const;
-    bool             contains(const key_type& k, size_t hash) const;
     template<class K>
       bool           contains(const K& k) const;
-    template<class K>
-      bool           contains(const K& k, size_t hash) const;
     pair<iterator, iterator>               equal_range(const key_type& k);
     pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
-    pair<iterator, iterator>               equal_range(const key_type& k, size_t hash);
-    pair<const_iterator, const_iterator>   equal_range(const key_type& k, size_t hash) const;
     template<class K>
       pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
       pair<const_iterator, const_iterator> equal_range(const K& k) const;
-    template<class K>
-      pair<iterator, iterator>             equal_range(const K& k, size_t hash);
-    template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& k, size_t hash) const;
 
     // bucket interface
     size_type bucket_count() const noexcept;
@@ -8957,40 +8851,22 @@
     // set operations
     iterator         find(const key_type& k);
     const_iterator   find(const key_type& k) const;
-    iterator         find(const key_type& k, size_t hash);
-    const_iterator   find(const key_type& k, size_t hash) const;
     template<class K>
       iterator       find(const K& k);
     template<class K>
       const_iterator find(const K& k) const;
-    template<class K>
-      iterator       find(const K& k, size_t hash);
-    template<class K>
-      const_iterator find(const K& k, size_t hash) const;
     size_type        count(const key_type& k) const;
-    size_type        count(const key_type& k, size_t hash) const;
     template<class K>
       size_type      count(const K& k) const;
-    template<class K>
-      size_type      count(const K& k, size_t hash) const;
     bool             contains(const key_type& k) const;
-    bool             contains(const key_type& k, size_t hash) const;
     template<class K>
       bool           contains(const K& k) const;
-    template<class K>
-      bool           contains(const K& k, size_t hash) const;
     pair<iterator, iterator>               equal_range(const key_type& k);
     pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
-    pair<iterator, iterator>               equal_range(const key_type& k, size_t hash);
-    pair<const_iterator, const_iterator>   equal_range(const key_type& k, size_t hash) const;
     template<class K>
       pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
       pair<const_iterator, const_iterator> equal_range(const K& k) const;
-    template<class K>
-      pair<iterator, iterator>             equal_range(const K& k, size_t hash);
-    template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& k, size_t hash) const;
 
     // bucket interface
     size_type bucket_count() const noexcept;
@@ -9299,40 +9175,22 @@
     // set operations
     iterator         find(const key_type& k);
     const_iterator   find(const key_type& k) const;
-    iterator         find(const key_type& k, size_t hash);
-    const_iterator   find(const key_type& k, size_t hash) const;
     template<class K>
       iterator       find(const K& k);
     template<class K>
       const_iterator find(const K& k) const;
-    template<class K>
-      iterator       find(const K& k, size_t hash);
-    template<class K>
-      const_iterator find(const K& k, size_t hash) const;
     size_type        count(const key_type& k) const;
-    size_type        count(const key_type& k, size_t hash) const;
     template<class K>
       size_type      count(const K& k) const;
-    template<class K>
-      size_type      count(const K& k, size_t hash) const;
     bool             contains(const key_type& k) const;
-    bool             contains(const key_type& k, size_t hash) const;
     template<class K>
       bool           contains(const K& k) const;
-    template<class K>
-      bool           contains(const K& k, size_t hash) const;
     pair<iterator, iterator>               equal_range(const key_type& k);
     pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
-    pair<iterator, iterator>               equal_range(const key_type& k, size_t hash);
-    pair<const_iterator, const_iterator>   equal_range(const key_type& k, size_t hash) const;
     template<class K>
       pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
       pair<const_iterator, const_iterator> equal_range(const K& k) const;
-    template<class K>
-      pair<iterator, iterator>             equal_range(const K& k, size_t hash);
-    template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& k, size_t hash) const;
 
     // bucket interface
     size_type bucket_count() const noexcept;

source/support.tex

@@ -610,8 +610,6 @@
   \tcode{<map>} \tcode{<set>} \\ \rowsep
 \defnlibxname{cpp_lib_generic_unordered_lookup}             & \tcode{201811L} &
   \tcode{<unordered_map>} \tcode{<unordered_set>} \\ \rowsep
-\defnlibxname{cpp_lib_generic_unordered_hash_lookup}        & \tcode{201902L} &
-  \tcode{<unordered_map>} \tcode{<unordered_set>} \\ \rowsep
 \defnlibxname{cpp_lib_hardware_interference_size}           & \tcode{201703L} &
   \tcode{<new>} \\ \rowsep
 \defnlibxname{cpp_lib_has_unique_object_representations}    & \tcode{201606L} &