[container.requirements.general] optional and allocator-aware containers

Author: jensmaurer

source/containers.tex

@@ -808,50 +808,48 @@
 model \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous}.
 
 \pnum
-\tref{container.opt} lists operations that are provided
+The following operations are provided
 for some types of containers but not others. Those containers for which the
-listed operations are provided shall implement the semantics described in
-\tref{container.opt} unless otherwise stated.
+listed operations are provided shall implement the semantics as described
+unless otherwise stated.
 If the iterators passed to \tcode{lexicographical_compare_three_way}
 meet the constexpr iterator requirements\iref{iterator.requirements.general}
-then the operations described in \tref{container.opt}
+then the operations described below
 are implemented by constexpr functions.
 
-\begin{libreqtab5}
-{Optional container operations}
-{container.opt}
-\\ \topline
-\lhdr{Expression}       &   \chdr{Return type}  &   \chdr{Operational}  &
-\chdr{Assertion/note}   &   \rhdr{Complexity}   \\
-    &   &   \chdr{semantics}    &   \chdr{pre-/post-condition}   &      \\ \capsep
-\endfirsthead
-\continuedcaption\\
-\topline
-\lhdr{Expression}       &   \chdr{Return type}  &   \chdr{Operational}  &
-\chdr{Assertion/note}   &   \rhdr{Complexity}   \\
-    &   &   \chdr{semantics}    &   \chdr{pre-/post-condition}   &      \\ \capsep
-\endhead
+\begin{itemdecl}
+a <=> b
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+\tcode{\exposid{synth-three-way-result}<X::value_type>}.
 
-\tcode{a <=> b}                  &
- \tcode{\placeholdernc{synth-three-\brk{}way-result}\brk{}<value_type>} &
- \tcode{lexicographical_compare_three_way(a.begin(), a.end(),
-    b.begin(), b.end(), \placeholdernc{synth-three-way})} &
- \expects
- Either \tcode{<=>} is defined for values of type (possibly const) \tcode{T},
- or \tcode{<} is defined for values of type (possibly const) \tcode{T} and
- \tcode{<} is a total ordering relationship.  &
- linear                         \\
-\end{libreqtab5}
+\pnum
+\expects
+Either \tcode{<=>} is defined for values of type (possibly const) \tcode{T},
+or \tcode{<} is defined for values of type (possibly const) \tcode{T} and
+\tcode{<} is a total ordering relationship.
 
+\pnum
+\cvalue
+\tcode{lexicographical_compare_three_way(a.begin(), a.end(),
+b.begin(), b.end(),\newline \exposidnc{synth-three-way})}
 \begin{note}
 The algorithm \tcode{lexicographical_compare_three_way}
 is defined in \ref{algorithms}.
 \end{note}
 
 \pnum
-All of the containers defined in this Clause and in~\ref{basic.string} except \tcode{array}
-meet the additional requirements of an allocator-aware container, as described in
-\tref{container.alloc.req}.
+\complexity
+Linear.
+\end{itemdescr}
+
+\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},
+as described below.
 
 \pnum
 Given an allocator type \tcode{A}
@@ -940,16 +938,18 @@
 \end{note}
 
 \pnum
-In \tref{container.alloc.req},
+In this subclause,
 \begin{itemize}
 \item
 \tcode{X} denotes an allocator-aware container class
-with a \tcode{value_type} of \tcode{T} using allocator of type \tcode{A},
+with a \tcode{value_type} of \tcode{T} using an allocator of type \tcode{A},
 \item
 \tcode{u} denotes a variable,
 \item
 \tcode{a} and \tcode{b} denote non-const lvalues of type \tcode{X},
 \item
+\tcode{c} denotes an lvalue of type \tcode{\keyword{const} X},
+\item
 \tcode{t} denotes an lvalue or a const rvalue of type \tcode{X},
 \item
 \tcode{rv} denotes a non-const rvalue of type \tcode{X}, and
@@ -974,112 +974,201 @@
 \indexlibrarymemberx{unordered_multimap}{#1}%
 }
 
-\begin{libreqtab4a}
-{Allocator-aware container requirements}
-{container.alloc.req}
-\\ \topline
-\lhdr{Expression}       &   \chdr{Return type}  &
-\chdr{Assertion/note}   &   \rhdr{Complexity}   \\
-    &   &   \chdr{pre-/post-condition}   &      \\ \capsep
-\endfirsthead
-\continuedcaption\\
-\hline
-
-\lhdr{Expression}       &   \chdr{Return type}  &
-\chdr{Assertion/note}   &   \rhdr{Complexity}   \\
-    &   &   \chdr{pre-/post-condition}   &      \\ \capsep
-\endhead
+A type \tcode{X} meets the allocator-aware container requirements
+if \tcode{X} meets the container requirements and
+the following types, statements, and expressions are well-formed and have
+the specified semantics.
 
 \indexcont{allocator_type}%
-\tcode{allocator_type}		&
-  \tcode{A}								&
-  \mandates \tcode{allocator_type::value_type} is the same as \tcode{X::value_type}.					&
-  compile time										\\ \rowsep
+\begin{itemdecl}
+typename X::allocator_type
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+\tcode{A}
+
+\pnum
+\expects
+\tcode{allocator_type::value_type} is the same as \tcode{X::value_type}.
+\end{itemdescr}
 
 \indexcont{get_allocator}%
-\tcode{get_-} \tcode{allocator()}	&
-  \tcode{A}								&
-																				&
-  constant												\\ \rowsep
-
-\tcode{X()}\br
-\tcode{X u;}							&
-													&
-  \expects \tcode{A} meets the \oldconcept{DefaultConstructible} requirements.\br
-  \ensures \tcode{u.empty()} returns \tcode{true},
-  \tcode{u.get_allocator() == A()} &
-  constant												\\ \rowsep
-
-\tcode{X(m)}							&
-																				&
-  \ensures
-  \tcode{u.empty()} returns \tcode{true}, &
-  constant												\\
-\tcode{X u(m);}					&
-																				&
-\tcode{u.get_allocator() == m} &
-																				\\ \rowsep
-
-\tcode{X(t, m)}\br
-\tcode{X u(t, m);}				&
-                          &
-  \expects
-  \tcode{T} is \oldconcept{CopyInsertable} into \tcode{X}.\br
-  \ensures
-  \tcode{u == t}, \tcode{u.get_allocator() == m} &
-  linear													\\ \rowsep
-
-\tcode{X(rv)}\br
-\tcode{X u(rv);}
-           &
-           &
-  \ensures \tcode{u} has the same elements as \tcode{rv} had before this
-  construction; the value of \tcode{u.get_allocator()} is the same as the
-  value of \tcode{rv.get_allocator()} before this construction. &
-  constant                            \\ \rowsep
-
-\tcode{X(rv, m)}\br
-\tcode{X u(rv, m);}			&
-												&
-  \expects \tcode{T} is
-  \oldconcept{MoveInsertable} into \tcode{X}.\br
-  \ensures \tcode{u} has the same elements,
-  or copies of the elements, that \tcode{rv} had before
-  this construction, \tcode{u.get_allocator() == m}												&
-  constant if \tcode{m ==} \tcode{rv.get_allocator()}, otherwise linear	\\ \rowsep
-
-\tcode{a = t}             &
-  \tcode{X\&}             &
-  \expects \tcode{T} is
-  \oldconcept{CopyInsertable} into \tcode{X}
-  and \oldconcept{CopyAssignable}.\br
-  \ensures \tcode{a == t}    &
-  linear                  \\ \rowsep
+\begin{itemdecl}
+c.get_allocator()
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+\tcode{A}
+
+\pnum
+\complexity
+Constant.
+\end{itemdescr}
+
+\begin{itemdecl}
+X u;
+X u = X();
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\expects
+\tcode{A} meets the \oldconcept{DefaultConstructible} requirements.
+
+\pnum
+\ensures
+\tcode{u.empty()} returns \tcode{true}, \tcode{u.get_allocator() == A()}.
+
+\pnum
+\complexity
+Constant.
+\end{itemdescr}
+
+\begin{itemdecl}
+X u(m);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\ensures
+\tcode{u.empty()} returns \tcode{true}, \tcode{u.get_allocator() == m}.
+
+\pnum
+\complexity
+Constant.
+\end{itemdescr}
+
+\begin{itemdecl}
+X u(t, m);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\expects
+\tcode{T} is \oldconcept{CopyInsertable} into \tcode{X}.
+
+\pnum
+\ensures
+\tcode{u == t}, \tcode{u.get_allocator() == m}
+
+\pnum
+\complexity
+Linear.
+\end{itemdescr}
+
+\begin{itemdecl}
+X u(rv);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\ensures
+\tcode{u} has the same elements as \tcode{rv} had before this construction;
+the value of \tcode{u.get_allocator()} is the same as
+the value of \tcode{rv.get_allocator()} before this construction.
+
+\pnum
+\complexity
+Constant.
+\end{itemdescr}
+
+\begin{itemdecl}
+X u(rv, m);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\expects
+\tcode{T} is \oldconcept{MoveInsertable} into \tcode{X}.
+
+\pnum
+\ensures
+\tcode{u} has the same elements, or copies of the elements,
+that \tcode{rv} had before this construction,
+\tcode{u.get_allocator() == m}.
+
+\pnum
+\complexity
+Constant if \tcode{m == rv.get_allocator()}, otherwise linear.
+\end{itemdescr}
+
+\begin{itemdecl}
+a = t
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+\tcode{X\&}.
+
+\pnum
+\expects
+\tcode{T} is \oldconcept{CopyInsertable} into \tcode{X} and
+\oldconcept{CopyAssignable}.
+
+\pnum
+\ensures
+\tcode{a == t} is \tcode{true}.
+
+\pnum
+\complexity
+Linear.
+\end{itemdescr}
 
 \indexcont{operator=}%
-\tcode{a = rv}          &
-  \tcode{X\&}           &
-  \expects If \tcode{allocator_-}\br
-  \tcode{traits<allocator_type>}\br
-  \tcode{::propagate_on_container_-}\br
-  \tcode{move_assignment::value} is\br
-  \tcode{false}, \tcode{T} is
-  \oldconcept{MoveInsertable} into \tcode{X} and
-  \oldconcept{MoveAssignable}.\br
-  \effects All existing elements of \tcode{a}
-  are either move assigned to or destroyed.\br
-  \ensures If \tcode{a} and \tcode{rv} do not refer to the same object,
-  \tcode{a} is equal to the value that \tcode{rv} had before
-  this assignment.      &
-  linear                \\ \rowsep
+\begin{itemdecl}
+a = rv
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\result
+\tcode{X\&}.
+
+\pnum
+\expects
+If
+\tcode{allocator_traits<allocator_type>::propagate_on_container_move_assign\-ment::value}
+is \tcode{false},
+\tcode{T} is \oldconcept{MoveInsertable} into \tcode{X} and
+\oldconcept{MoveAssignable}.
+
+\pnum
+\effects
+All existing elements of \tcode{a} are either move assigned to or destroyed.
+
+\pnum
+\ensures
+If \tcode{a} and \tcode{rv} do not refer to the same object,
+\tcode{a} is equal to the value that \tcode{rv} had before this assignment.
+
+\pnum
+\complexity
+Linear.
+\end{itemdescr}
 
 \indexcont{swap}%
-\tcode{a.swap(b)}       &
-  \keyword{void}          &
-  \effects exchanges the contents of \tcode{a} and \tcode{b} &
-  constant      \\ \rowsep
+\begin{itemdecl}
+a.swap(b)
+\end{itemdecl}
 
-\end{libreqtab4a}
+\begin{itemdescr}
+\pnum
+\result
+\keyword{void}
+
+\pnum
+\effects
+Exchanges the contents of \tcode{a} and \tcode{b}.
+
+\pnum
+\complexity
+Constant.
+\end{itemdescr}
 
 \pnum
 The behavior of certain container member functions and deduction guides