[unord.req] Index unordered associative container members in the library

names index, not the main text index.

Author: zygoloid

source/containers.tex

@@ -2216,6 +2216,15 @@
 \tcode{z} denotes a value of type \tcode{float},
 and \tcode{nh} denotes a non-const rvalue of type \tcode{X::node_type}.
 
+% Local command to index names as members of all unordered containers.
+\newcommand{\indexunordmem}[1]{%
+\indexlibrary{\idxcode{#1}!unordered associative containers}%
+\indexlibrary{\idxcode{unordered_set}!\idxcode{#1}}%
+\indexlibrary{\idxcode{unordered_map}!\idxcode{#1}}%
+\indexlibrary{\idxcode{unordered_multiset}!\idxcode{#1}}%
+\indexlibrary{\idxcode{unordered_multimap}!\idxcode{#1}}%
+}
+
 \begin{libreqtab4d}
   {Unordered associative container requirements (in addition to container)}
   {tab:HashRequirements}
@@ -2229,9 +2238,8 @@
                   &                      & \chdr{pre-/post-condition} & \\ \capsep
 \endhead
 %%
+\indexunordmem{key_type}%
 \tcode{X::key_type}   &
-\indextext{unordered associative containers!\idxcode{key_type}}%
-\indextext{\idxcode{key_type}!unordered associative containers}%
   \tcode{Key}         &
                       &
   compile time        \\ \rowsep
@@ -2251,49 +2259,46 @@
   \requires\ \tcode{value_type} is \tcode{Erasable} from \tcode{X} &
   compile time \\ \rowsep
 
+\indexunordmem{hasher}%
 \tcode{X::hasher}
 &   \tcode{Hash}
 &   \tcode{Hash} shall be a unary function object type such that the expression
     \tcode{hf(k)} has type \tcode{size_t}.%
-    \indextext{unordered associative containers!\idxcode{hasher}}%
-    \indextext{\idxcode{hasher}!unordered associative containers}%
 &   compile time
 \\ \rowsep
 %
+\indexunordmem{key_equal}%
 \tcode{X::key_equal}
 &   \tcode{Pred}
 &   \requires\ \tcode{Pred} is \tcode{CopyConstructible}.\br
     \tcode{Pred} shall be a binary predicate that takes two arguments
     of type \tcode{Key}.  \tcode{Pred} is an equivalence relation.%
-    \indextext{unordered associative containers!\idxcode{key_equal}}%
-    \indextext{\idxcode{key_equal}!unordered associative containers}%
 &   compile time
 \\ \rowsep
 %
+\indexunordmem{local_iterator}%
 \tcode{X::local_iterator}
 &   An iterator type whose category, value type,
     difference type, and pointer and reference types are the same as
     \tcode{X::iterator}'s. \indextext{\idxcode{local_iterator}}
 &   A \tcode{local_iterator} object may be used to iterate through a
     single bucket, but may not be used to iterate across
     buckets.%
-    \indextext{unordered associative containers!\idxcode{local_iterator}}%
-    \indextext{\idxcode{local_iterator}!unordered associative containers}%
 &   compile time
 \\ \rowsep
 %
+\indexunordmem{const_local_iterator}%
 \tcode{X::const_local_iterator}
 &   An iterator type whose category, value type,
     difference type, and pointer and reference types are the same as
     \tcode{X::const_iterator}'s. \indextext{\idxcode{const_local_iterator}}
 &   A \tcode{const_local_iterator} object may be used to iterate through a
     single bucket, but may not be used to iterate across
     buckets.%
-    \indextext{unordered associative containers!\idxcode{const_local_iterator}}%
-    \indextext{\idxcode{const_local_iterator}!unordered associative containers}%
 &   compile time
 \\ \rowsep
 %
+\indexunordmem{node_type}%
 \tcode{X::node_type} &
  a specialization of a \tcode{\placeholder{node_handle}}
  class template, such that the public nested types are
@@ -2431,19 +2436,17 @@
 &   Same as \tcode{a = X(il)}.
 \\ \rowsep
 %
+\indexunordmem{hash_function}%
 \tcode{b.hash_function()}
 &   \tcode{hasher}
 &   Returns \tcode{b}'s hash function.%
-    \indextext{unordered associative containers!\idxcode{hash_function}}%
-    \indextext{\idxcode{hash_function}!unordered associative containers}%
 &   constant
 \\ \rowsep
 %
+\indexunordmem{key_eq}%
 \tcode{b.key_eq()}
 &   \tcode{key_equal}
 &   Returns \tcode{b}'s key equality predicate.%
-    \indextext{unordered associative containers!\idxcode{key_eq}}%
-    \indextext{\idxcode{key_eq}!unordered associative containers}%
 &   constant
 \\ \rowsep
 %
@@ -2481,6 +2484,7 @@
   Average case \bigoh{1}, worst case \bigoh{\tcode{a.} \tcode{size()}}.
 \\ \rowsep
 
+\indexunordmem{insert}%
 \tcode{a_uniq.insert(t)}
 &   \tcode{pair<iterator, bool>}
 &   \requires\ If \tcode{t} is a non-const rvalue expression, \tcode{value_type} shall be
@@ -2491,8 +2495,6 @@
     component of the returned pair indicates whether the insertion
     takes place, and the \tcode{iterator} component points to the element
     with key equivalent to the key of \tcode{t}.%
-    \indextext{unordered associative containers!\idxcode{insert}}%
-    \indextext{\idxcode{insert}!unordered associative containers}%
 &   Average case \bigoh{1}, worst case \bigoh{\tcode{a_uniq.}\br\tcode{size()}}.
 \\ \rowsep
 %
@@ -2503,8 +2505,6 @@
     \tcode{CopyInsertable} into \tcode{X}.\br
     \effects\ Inserts \tcode{t}, and returns an iterator pointing to the newly
     inserted element.
-    \indextext{unordered associative containers!\idxcode{insert}}%
-    \indextext{\idxcode{insert}!unordered associative containers}%
 &   Average case \bigoh{1}, worst case \bigoh{\tcode{a_eq.}\br\tcode{size()}}.
 \\ \rowsep
 %
@@ -2517,8 +2517,6 @@
 to the element with the key equivalent to that of \tcode{t}.  The
 iterator \tcode{p} is a hint pointing to where the search should
 start.  Implementations are permitted to ignore the hint.%
-    \indextext{unordered associative containers!\idxcode{insert}}%
-    \indextext{\idxcode{insert}!unordered associative containers}%
 &   Average case \bigoh{1}, worst case \bigoh{\tcode{a.size()}}.
 \\ \rowsep
 %
@@ -2527,8 +2525,6 @@
 &   \requires\ \tcode{value_type} shall be \tcode{EmplaceConstructible} into \tcode{X} from \tcode{*i}.\br
     \requires \tcode{i} and \tcode{j} are not iterators in \tcode{a}.\br
     \effects Equivalent to \tcode{a.insert(t)} for each element in \tcode{[i,j)}.%
-    \indextext{unordered associative containers!\idxcode{insert}}%
-    \indextext{\idxcode{insert}!unordered associative containers}%
 &   Average case \bigoh{N}, where $N$ is \tcode{distance(i, j)}.
     Worst case \bigoh{N(\tcode{a.size()}\brk{}+\brk{}1)}.
 \\ \rowsep
@@ -2619,21 +2615,18 @@
     \bigoh{\tcode{a.size()}}.
 \\ \rowsep
 %
+\indexunordmem{erase}%
 \tcode{a.erase(q)}
 &   \tcode{iterator}
 &   Erases the element pointed to by \tcode{q}. Returns the
     iterator immediately following \tcode{q} prior to the erasure.
-    \indextext{unordered associative containers!\idxcode{erase}}%
-    \indextext{\idxcode{erase}!unordered associative containers}%
 &   Average case \bigoh{1}, worst case \bigoh{\tcode{a.size()}}.
 \\ \rowsep
 %
 \tcode{a.erase(r)}
 &   \tcode{iterator}
 &   Erases the element pointed to by \tcode{r}. Returns the
     iterator immediately following \tcode{r} prior to the erasure.
-    \indextext{unordered associative containers!\idxcode{erase}}%
-    \indextext{\idxcode{erase}!unordered associative containers}%
 &   Average case \bigoh{1}, worst case \bigoh{\tcode{a.size()}}.
 \\ \rowsep
 %
@@ -2642,148 +2635,132 @@
 &   Erases all elements in the range \tcode{[q1, q2)}. Returns
     the iterator immediately following the erased elements prior to the
     erasure.%
-    \indextext{unordered associative containers!\idxcode{erase}}%
-    \indextext{\idxcode{erase}!unordered associative containers}%
 &   Average case linear in \tcode{distance(q1, q2)},
     worst case \bigoh{\tcode{a.size()}}.
 \\ \rowsep
 %
+\indexunordmem{clear}%
 \tcode{a.clear()}
 & \tcode{void}
 & Erases all elements in the container.
    \postconditions \tcode{a.empty()} returns \tcode{true}%
-    \indextext{unordered associative containers!\idxcode{clear}}%
-    \indextext{\idxcode{clear}!unordered associative containers}%
 & Linear in \tcode{a.size()}.
 \\ \rowsep
 %
+\indexunordmem{find}%
 \tcode{b.find(k)}
 &   \tcode{iterator}; \br \tcode{const_iterator} for const \tcode{b}.
 &   Returns an iterator pointing to an element with key equivalent to
     \tcode{k}, or \tcode{b.end()} if no such element exists.%
-    \indextext{unordered associative containers!\idxcode{find}}%
-    \indextext{\idxcode{find}!unordered associative containers}%
 &   Average case \bigoh{1}, worst case \bigoh{\tcode{b.size()}}.
 \\ \rowsep
 %
+\indexunordmem{count}%
 \tcode{b.count(k)}
 &   \tcode{size_type}
 &   Returns the number of elements with key equivalent to \tcode{k}.%
-    \indextext{unordered associative containers!\idxcode{count}}%
-    \indextext{\idxcode{count}!unordered associative containers}%
 &   Average case \bigoh{\tcode{b.count(k)}}, worst case \bigoh{\tcode{b.size()}}.
 \\ \rowsep
 %
+\indexunordmem{equal_range}%
 \tcode{b.equal_range(k)}
 &   \tcode{pair<iterator, iterator>}; \br
     \tcode{pair<const_iterator, const_iterator>} for const \tcode{b}.
 &   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.%
-    \indextext{unordered associative containers!\idxcode{equal_range}}%
-    \indextext{\idxcode{equal_range}!unordered associative containers}%
 &   Average case \bigoh{\tcode{b.count(k)}}.  Worst case
     \bigoh{\tcode{b.size()}}.
 \\ \rowsep
 %
+\indexunordmem{bucket_count}%
 \tcode{b.bucket_count()}
 &   \tcode{size_type}
 &   Returns the number of buckets that \tcode{b} contains.%
-    \indextext{unordered associative containers!\idxcode{bucket_count}}%
-    \indextext{\idxcode{bucket_count}!unordered associative containers}%
 &   Constant
 \\ \rowsep
 %
+\indexunordmem{max_bucket_count}%
 \tcode{b.max_bucket_count()}
 &   \tcode{size_type}
 &   Returns an upper bound on the number of buckets that \tcode{b} might
     ever contain.%
-    \indextext{unordered associative containers!\idxcode{max_bucket_count}}%
-    \indextext{\idxcode{max_bucket_count}!unordered associative containers}%
 &   Constant
 \\ \rowsep
 %
+\indexunordmem{bucket}%
 \tcode{b.bucket(k)}
 & \tcode{size_type}
 &
   \requires \tcode{b.bucket_count() > 0}.\br
     Returns the index of the bucket in which elements with keys equivalent
     to \tcode{k} would be found, if any such element existed.
     \postconditions the return value shall be in the range \tcode{[0, b.bucket_count())}.%
-    \indextext{unordered associative containers!\idxcode{bucket}}%
-    \indextext{\idxcode{bucket}!unordered associative containers}%
 & Constant
 \\ \rowsep
 %
+\indexunordmem{bucket_size}%
 \tcode{b.bucket_size(n)}
 &   \tcode{size_type}
 &   \requires \tcode{n} shall be in the range \tcode{[0, b.bucket_count())}.
     Returns the number of elements in the $\texttt{n}^{\textrm{ th}}$ bucket.%
-    \indextext{unordered associative containers!\idxcode{bucket_size}}%
-    \indextext{\idxcode{bucket_size}!unordered associative containers}%
 &   \bigoh{\tcode{b.bucket_}\-\tcode{size(n)}}
 \\ \rowsep
 %
+\indexunordmem{begin}%
 \tcode{b.begin(n)}
 &   \tcode{local_iterator}; \br
     \tcode{const_local_iterator} for const \tcode{b}.
 &   \requires \tcode{n} shall be in the range \tcode{[0, b.bucket_count())}.
     \tcode{b.begin(n)} returns an iterator referring to the
     first element in the bucket. If the bucket is empty, then
     \tcode{b.begin(n) == b.end(n)}.%
-    \indextext{unordered associative containers!\idxcode{begin}}%
-    \indextext{\idxcode{begin}!unordered associative containers}%
 &   Constant
 \\ \rowsep
 %
+\indexunordmem{end}%
 \tcode{b.end(n)}
 &   \tcode{local_iterator}; \br
     \tcode{const_local_iterator} for const \tcode{b}.
 &   \requires \tcode{n} shall be in the range \tcode{[0, b.bucket_count())}.
     \tcode{b.end(n)} returns an iterator which is the past-the-end
     value for the bucket.%
-    \indextext{unordered associative containers!\idxcode{end}}%
-    \indextext{\idxcode{end}!unordered associative containers}%
 &   Constant
 \\ \rowsep
 %
+\indexunordmem{cbegin}%
 \tcode{b.cbegin(n)}
 &   \tcode{const_local_iterator}
 &   \requires \tcode{n} shall be in the range \tcode{[0, b.bucket_count())}.
     \tcode{b.cbegin(n)} returns an iterator referring to the
     first element in the bucket. If the bucket is empty, then
     \tcode{b.cbegin(n) == b.cend(n)}.%
-    \indextext{unordered associative containers!\idxcode{cbegin}}%
-    \indextext{\idxcode{cbegin}!unordered associative containers}%
 &   Constant
 \\ \rowsep
 %
+\indexunordmem{cend}%
 \tcode{b.cend(n)}
 &   \tcode{const_local_iterator}
 &   \requires \tcode{n} shall be in the range \tcode{[0, b.bucket_count())}.%
     \tcode{b.cend(n)} returns an iterator which is the past-the-end
     value for the bucket.%
-    \indextext{unordered associative containers!\idxcode{cend}}%
-    \indextext{\idxcode{cend}!unordered associative containers}%
 &   Constant
 \\ \rowsep
 %
+\indexunordmem{load_factor}%
 \tcode{b.load_factor()}
 &   \tcode{float}
 &   Returns the average number of elements per bucket.%
-    \indextext{unordered associative containers!\idxcode{load_factor}}%
-    \indextext{\idxcode{load_factor}!unordered associative containers}%
 &   Constant
 \\ \rowsep
 %
+\indexunordmem{max_load_factor}%
 \tcode{b.max_load_factor()}
 &   \tcode{float}
 &   Returns a positive number that the container attempts to keep the load factor
     less than or equal to. The container automatically increases the
     number of buckets as necessary to keep the load factor below this
     number.%
-    \indextext{unordered associative containers!\idxcode{max_load_factor}}%
-    \indextext{\idxcode{max_load_factor}!unordered associative containers}%
 &   Constant
 \\ \rowsep
 %
@@ -2794,15 +2771,15 @@
 & Constant
 \\ \rowsep
 %
+\indexunordmem{rehash}%
 \tcode{a.rehash(n)}
 & \tcode{void}
 & \postconditions \tcode{a.bucket_count() >= a.size() / a.max_load_factor()} and
         \tcode{a.bucket_count() >= n}.%
-    \indextext{unordered associative containers!\idxcode{rehash}}%
-    \indextext{\idxcode{rehash}!unordered associative containers}%
 & Average case linear in \tcode{a.size()}, worst case quadratic.
 \\ \rowsep
 
+\indexunordmem{reserve}%
 \tcode{a.reserve(n)}  &
   \tcode{void}        &
   Same as \tcode{a.rehash(ceil(n /} \tcode{a.max_load_factor()))}.  &