[lib] Fix cross-references to container requirements tables

Author: jensmaurer

source/containers.tex

@@ -31,10 +31,10 @@
 \end{libsumtab}
 
 
-\rSec1[container.requirements]{Container requirements}%
+\rSec1[container.requirements]{Requirements}%
 \indextext{requirements!container}
 
-\rSec2[container.requirements.general]{General container requirements}
+\rSec2[container.requirements.pre]{Preamble}
 
 \pnum
 Containers are objects that store other objects.
@@ -54,7 +54,7 @@
 \end{example}
 
 \pnum
-Allocator-aware containers (\tref{container.alloc.req})
+Allocator-aware containers\iref{container.alloc.reqmts}
 other than \tcode{basic_string} construct elements using the function
 \tcode{allocator_traits<allocator_type>::rebind_traits<U>::\brk{}construct}
 and destroy elements using the function
@@ -69,8 +69,12 @@
 aligned buffers and call \tcode{construct} to place the element into the buffer.
 \end{note}
 
+\rSec2[container.gen.reqmts]{General containers}
+
+\rSec3[container.requirements.general]{General}
+
 \pnum
-In this subclause,
+In subclause \ref{container.gen.reqmts},
 \begin{itemize}
 \item
 \tcode{X} denotes a container class containing objects of type \tcode{T},
@@ -86,6 +90,8 @@
 \tcode{rv} denotes a non-const rvalue of type \tcode{X}.
 \end{itemize}
 
+\rSec3[container.reqmts]{Containers}
+
 % Local command to index names as members of all containers.
 \newcommand{\indexcont}[1]{%
 \indexlibrarymisc{#1}{containers}%
@@ -620,6 +626,8 @@
 with value \tcode{a.end()} before the swap will have value \tcode{b.end()} after the
 swap.
 
+\rSec3[container.rev.reqmts]{Reversible container requirements}
+
 % Local command to index names as members of all containers.
 \renewcommand{\indexcont}[1]{%
 \indexlibrarymisc{#1}{reversible containers}%
@@ -807,6 +815,8 @@
 \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators} and
 model \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous}.
 
+\rSec3[container.opt.reqmts]{Optional container requirements}
+
 \pnum
 The following operations are provided
 for some types of containers but not others. Those containers for which the
@@ -846,6 +856,8 @@
 Linear.
 \end{itemdescr}
 
+\rSec3[container.alloc.reqmts]{Allocator-aware containers}
+
 \pnum
 All of the containers defined in \ref{containers} and in~\ref{basic.string} except \tcode{array}
 meet the additional requirements of an \defnadj{allocator-aware}{container},
@@ -2087,7 +2099,7 @@
 template<@\unspecnc@>
 class @\placeholder{node-handle}@ {
 public:
-  // These type declarations are described in Tables \ref{tab:container.assoc.req} and \ref{tab:container.hash.req}.
+  // These type declarations are described in \ref{associative.reqmts} and \ref{unord.req}.
   using value_type     = @\seebelownc{}@;     // not present for map containers
   using key_type       = @\seebelownc{}@;     // not present for set containers
   using mapped_type    = @\seebelownc{}@;     // not present for set containers
@@ -2522,7 +2534,7 @@
 have the specified semantics,
 except that for
 \tcode{map} and \tcode{multimap}, the requirements placed on \tcode{value_type}
-in \tref{container.alloc.req} apply instead to \tcode{key_type}
+in \ref{container.alloc.reqmts} apply instead to \tcode{key_type}
 and \tcode{mapped_type}.
 \begin{note}
 For example, in some cases \tcode{key_type} and \tcode{mapped_type}
@@ -3943,7 +3955,7 @@
 the following types, statements, and expressions are well-formed and
 have the specified semantics,
 except that for \tcode{unordered_map} and \tcode{unordered_multimap},
-the requirements placed on \tcode{value_type} in \tref{container.alloc.req}
+the requirements placed on \tcode{value_type} in \ref{container.alloc.reqmts}
 apply instead to \tcode{key_type} and \tcode{mapped_type}.
 \begin{note}
 For example, \tcode{key_type} and \tcode{mapped_type}
@@ -5773,8 +5785,10 @@
 
 \pnum
 \indextext{requirements!container}%
-An \tcode{array} meets all of the requirements of a container and
-of a reversible container\iref{container.requirements}, except that a default
+An \tcode{array} meets all of the requirements
+of a container\iref{container.reqmts} and
+of a reversible container\iref{container.rev.reqmts},
+except that a default
 constructed \tcode{array} object is not empty and that \tcode{swap} does not have constant
 complexity. An \tcode{array} meets some of the requirements of a sequence
 container\iref{sequence.reqmts}.
@@ -6088,11 +6102,12 @@
 Storage management is handled automatically.
 
 \pnum
-A
-\tcode{deque}
-meets all of the requirements of a container, of a reversible container
-(given in tables in~\ref{container.requirements}), of a sequence container,
-including the optional sequence container requirements\iref{sequence.reqmts}, and of an allocator-aware container (\tref{container.alloc.req}).
+A \tcode{deque} meets all of the requirements
+of a container\iref{container.reqmts},
+of a reversible container\iref{container.rev.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}, and
+of a sequence container,
+including the optional sequence container requirements\iref{sequence.reqmts}.
 Descriptions are provided here only for operations on
 \tcode{deque}
 that are not described in one of these tables
@@ -6504,13 +6519,15 @@
 \end{note}
 
 \pnum
-A \tcode{forward_list} meets all of the requirements of a container\iref{container.requirements.general}, except that the \tcode{size()}
-member function is not provided and \tcode{operator==} has linear complexity.
-A \tcode{forward_list} also meets all of the requirements for an allocator-aware
-container (\tref{container.alloc.req}). In addition, a \tcode{forward_list}
-provides the \tcode{assign} member functions
-(\tref{container.seq.req}) and several of the optional
-container requirements (\tref{container.seq.opt}).
+A \tcode{forward_list} meets all of the requirements
+of a container\iref{container.reqmts},
+except that the \tcode{size()} member function is not provided and
+\tcode{operator==} has linear complexity,
+A \tcode{forward_list} also meets all of the requirements
+for an allocator-aware container\iref{container.alloc.reqmts}.
+In addition, a \tcode{forward_list}
+provides the \tcode{assign} member functions and
+several of the optional sequence container requirements\iref{sequence.reqmts}.
 Descriptions are provided here only for operations on
 \tcode{forward_list} that are not described in that table or for operations where there
 is additional semantic information.
@@ -7304,12 +7321,13 @@
 algorithms only need sequential access anyway.
 
 \pnum
-A \tcode{list} meets all of the requirements of a container, of
-a reversible container (given in two tables in
-\ref{container.requirements}), of a sequence container,
+A \tcode{list} meets all of the requirements
+of a container\iref{container.reqmts},
+of a reversible container\iref{container.rev.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}, and
+of a sequence container,
 including most of the optional sequence container
-requirements\iref{sequence.reqmts}, and of an allocator-aware container
-(\tref{container.alloc.req}).
+requirements\iref{sequence.reqmts}.
 The exceptions are the
 \tcode{operator[]}
 and
@@ -8016,11 +8034,12 @@
 to improve efficiency.
 
 \pnum
-A \tcode{vector} meets all of the requirements of a container and of a
-reversible container (given in two tables in~\ref{container.requirements}), of a
-sequence container, including most of the optional sequence container
-requirements\iref{sequence.reqmts}, of an allocator-aware container
-(\tref{container.alloc.req}),
+A \tcode{vector} meets all of the requirements
+of a container\iref{container.reqmts},
+of a reversible container\iref{container.rev.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts},
+of a sequence container, including most of the optional sequence container
+requirements\iref{sequence.reqmts},
 and, for an element type other than \tcode{bool},
 of a contiguous container\iref{container.requirements.general}.
 The exceptions are the
@@ -8895,10 +8914,11 @@
 on the keys. The \tcode{map} class supports bidirectional iterators.
 
 \pnum
-A
-\tcode{map}
-meets all of the requirements of a container, of a reversible container\iref{container.requirements}, of
-an associative container\iref{associative.reqmts}, and of an allocator-aware container (\tref{container.alloc.req}).
+A \tcode{map} meets all of the requirements of
+a container\iref{container.reqmts},
+of a reversible container\iref{container.rev.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}. and
+of an associative container\iref{associative.reqmts}.
 A
 \tcode{map}
 also provides most operations described in~\ref{associative.reqmts}
@@ -9442,11 +9462,11 @@
 supports bidirectional iterators.
 
 \pnum
-A
-\tcode{multimap} meets all of the requirements of a container and of a
-reversible container\iref{container.requirements}, of an associative
-container\iref{associative.reqmts}, and of an allocator-aware container
-(\tref{container.alloc.req}).
+A \tcode{multimap} meets all of the requirements
+of a container\iref{container.reqmts},
+of a reversible container\iref{container.rev.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}, and
+of an associative container\iref{associative.reqmts}.
 A
 \tcode{multimap}
 also provides most operations described in~\ref{associative.reqmts}
@@ -9763,10 +9783,11 @@
 supports bidirectional iterators.
 
 \pnum
-A \tcode{set} meets all of the requirements of a container, of a reversible
-container\iref{container.requirements}, of an associative
-container\iref{associative.reqmts}, and of an allocator-aware container
-(\tref{container.alloc.req}).
+A \tcode{set} meets all of the requirements
+of a container\iref{container.reqmts},
+of a reversible container\iref{container.rev.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}. and
+of an associative container\iref{associative.reqmts}.
 A
 \tcode{set}
 also provides most operations described in~\ref{associative.reqmts}
@@ -10041,10 +10062,11 @@
 supports bidirectional iterators.
 
 \pnum
-A \tcode{multiset} meets all of the requirements of a container, of a
-reversible container\iref{container.requirements}, of an associative
-container\iref{associative.reqmts}, and of an allocator-aware container
-(\tref{container.alloc.req}).
+A \tcode{multiset} meets all of the requirements
+of a container\iref{container.reqmts},
+of a reversible container\iref{container.rev.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts},
+of an associative container\iref{associative.reqmts}.
 \tcode{multiset}
 also provides most operations described in~\ref{associative.reqmts}
 for duplicate keys.
@@ -10472,7 +10494,11 @@
 supports forward iterators.
 
 \pnum
-An \tcode{unordered_map} meets all of the requirements of a container, of an unordered associative container, and of an allocator-aware container (\tref{container.alloc.req}). It provides the operations described in the preceding requirements table for unique keys; that is, an \tcode{unordered_map} supports the \tcode{a_uniq} operations in that table, not the \tcode{a_eq} operations. For an \tcode{unordered_map<Key, T>} the \tcode{key type} is \tcode{Key}, the mapped type is \tcode{T}, and the value type is \tcode{pair<const Key, T>}.
+An \tcode{unordered_map} meets all of the requirements
+of a container\iref{container.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}, and
+of an unordered associative container\iref{unord.req}.
+It provides the operations described in the preceding requirements table for unique keys; that is, an \tcode{unordered_map} supports the \tcode{a_uniq} operations in that table, not the \tcode{a_eq} operations. For an \tcode{unordered_map<Key, T>} the \tcode{key type} is \tcode{Key}, the mapped type is \tcode{T}, and the value type is \tcode{pair<const Key, T>}.
 
 \pnum
 Subclause~\ref{unord.map} only describes operations on \tcode{unordered_map} that
@@ -11064,9 +11090,11 @@
 supports forward iterators.
 
 \pnum
-An \tcode{unordered_multimap} meets all of the requirements of a container, of an
-unordered associative container, and of an allocator-aware container
-(\tref{container.alloc.req}). It provides the operations described in the
+An \tcode{unordered_multimap} meets all of the requirements
+of a container\iref{container.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}, and
+of an unordered associative container\iref{unord.req}.
+It provides the operations described in the
 preceding requirements table for equivalent keys; that is, an \tcode{unordered_multimap}
 supports the \tcode{a_eq} operations in that table, not the \tcode{a_uniq} operations.
 For an \tcode{unordered_multimap<Key, T>} the \tcode{key type} is \tcode{Key}, the
@@ -11440,7 +11468,11 @@
 supports forward iterators.
 
 \pnum
-An \tcode{unordered_set} meets all of the requirements of a container, of an unordered associative container, and of an allocator-aware container (\tref{container.alloc.req}). It provides the operations described in the preceding requirements table for unique keys; that is, an \tcode{unordered_set} supports the \tcode{a_uniq} operations in that table, not the \tcode{a_eq} operations. For an \tcode{unordered_set<Key>} the \tcode{key type} and the value type are both \tcode{Key}. The \tcode{iterator} and \tcode{const_iterator} types are both constant iterator types. It is unspecified whether they are the same type.
+An \tcode{unordered_set} meets all of the requirements
+of a container\iref{container.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts},
+of an unordered associative container\iref{unord.req}.
+It provides the operations described in the preceding requirements table for unique keys; that is, an \tcode{unordered_set} supports the \tcode{a_uniq} operations in that table, not the \tcode{a_eq} operations. For an \tcode{unordered_set<Key>} the \tcode{key type} and the value type are both \tcode{Key}. The \tcode{iterator} and \tcode{const_iterator} types are both constant iterator types. It is unspecified whether they are the same type.
 
 \pnum
 Subclause~\ref{unord.set} only describes operations on \tcode{unordered_set} that
@@ -11761,9 +11793,11 @@
 supports forward iterators.
 
 \pnum
-An \tcode{unordered_multiset} meets all of the requirements of a container, of an
-unordered associative container, and of an allocator-aware container
-(\tref{container.alloc.req}). It provides the operations described in the
+An \tcode{unordered_multiset} meets all of the requirements
+of a container\iref{container.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}, and
+of an unordered associative container\iref{unord.req}.
+It provides the operations described in the
 preceding requirements table for equivalent keys; that is, an \tcode{unordered_multiset}
 supports the \tcode{a_eq} operations in that table, not the \tcode{a_uniq} operations.
 For an \tcode{unordered_multiset<Key>} the \tcode{key type} and the value type are

source/strings.tex

@@ -1317,7 +1317,7 @@
 \pnum
 \effects
 Constructs a string from the values in the range \range{begin}{end},
-as indicated in \tref{container.seq.req}.
+as specified in \ref{sequence.reqmts}.
 \end{itemdescr}
 
 \indexlibraryctor{basic_string}%

source/utilities.tex

@@ -22986,10 +22986,10 @@
 
 \pnum
 The class template \tcode{basic_stacktrace} satisfies
-the requirements of
-an allocator-aware container (\tref{container.alloc.req}),
-a sequence container\iref{sequence.reqmts}, and
-a reversible container\iref{container.requirements.general}
+the requirements
+of a reversible container\iref{container.rev.reqmts},
+of an allocator-aware container\iref{container.alloc.reqmts}, and
+of a sequence container\iref{sequence.reqmts},
 except that
 \begin{itemize}
 \item