|
|
Boost-Commit : |
From: dgregor_at_[hidden]
Date: 2008-05-18 17:26:17
Author: dgregor
Date: 2008-05-18 17:26:16 EDT (Sun, 18 May 2008)
New Revision: 45499
URL: http://svn.boost.org/trac/boost/changeset/45499
Log:
Allocator support for containers
Text files modified:
sandbox/committee/concepts/stdlib/clib-containers.tex | 1658 ++++++++++++++++++++-------------------
1 files changed, 853 insertions(+), 805 deletions(-)
Modified: sandbox/committee/concepts/stdlib/clib-containers.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-containers.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-containers.tex 2008-05-18 17:26:16 EDT (Sun, 18 May 2008)
@@ -1169,27 +1169,27 @@
\begin{codeblock}
namespace std {
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+ template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
@\addedConcepts{requires Destructible<T>}@
class deque;
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>&& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>&& y);
}
\end{codeblock}
@@ -1198,23 +1198,23 @@
\begin{codeblock}
namespace std {
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+ template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
@\addedConcepts{requires Destructible<T>}@
class forward_list;
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator==(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator< (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator!=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator> (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
}
\end{codeblock}
@@ -1223,27 +1223,27 @@
\begin{codeblock}
namespace std {
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+ template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
@\addedConcepts{requires Destructible<T>}@
class list;
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>& x, list<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>&& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>&& y);
}
\end{codeblock}
@@ -1268,24 +1268,24 @@
bool operator>=(const queue<T, Cont@\removedConcepts{ainer}@>& x,const queue<T, Cont@\removedConcepts{ainer}@>& y);
template <class T, @\changedConcepts{class}{LessThanComparable}@ Cont@\removedConcepts{ainer}@>
bool operator<=(const queue<T, Cont@\removedConcepts{ainer}@>& x,const queue<T, Cont@\removedConcepts{ainer}@>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(queue<T,Allocator>& x, queue<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(queue<T,Allocator>&& x, queue<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(queue<T,Allocator>& x, queue<T,Allocator>&& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(queue<T,Alloc@\removedConcepts{ator}@>& x, queue<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(queue<T,Alloc@\removedConcepts{ator}@>&& x, queue<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(queue<T,Alloc@\removedConcepts{ator}@>& x, queue<T,Alloc@\removedConcepts{ator}@>&& y);
template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{BackInsertionSequence}@ Cont@\removedConcepts{ainer}@ = vector<T>,
@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare = less<typename Cont@\removedConcepts{ainer}@::value_type> >
@\addedConcepts{requires SameType<Cont::value_type, T> \&\& MutableRandomAccessIterator<Cont::iterator>}@
@\addedConcepts{\&\& SwappableIterator<Cont::iterator> \&\& CopyConstructible<Compare>}@
class priority_queue;
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator@\addedConcepts{, Swappable Compare}@>
- void swap(priority_queue<T,Allocator>& x, priority_queue<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator@\addedConcepts{, Swappable Compare}@>
- void swap(priority_queue<T,Allocator>&& x, priority_queue<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator@\addedConcepts{, Swappable Compare}@>
- void swap(priority_queue<T,Allocator>& x, priority_queue<T,Allocator>&& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@@\addedConcepts{, Swappable Compare}@>
+ void swap(priority_queue<T,Alloc@\removedConcepts{ator}@>& x, priority_queue<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@@\addedConcepts{, Swappable Compare}@>
+ void swap(priority_queue<T,Alloc@\removedConcepts{ator}@>&& x, priority_queue<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@@\addedConcepts{, Swappable Compare}@>
+ void swap(priority_queue<T,Alloc@\removedConcepts{ator}@>& x, priority_queue<T,Alloc@\removedConcepts{ator}@>&& y);
}
\end{codeblock}
@@ -1309,12 +1309,12 @@
bool operator>=(const stack<T, Cont@\removedConcepts{ainer}@>& x,const stack<T, Cont@\removedConcepts{ainer}@>& y);
template <@\changedConcepts{class}{LessThanComparable}@ T, class Cont@\removedConcepts{ainer}@>
bool operator<=(const stack<T, Cont@\removedConcepts{ainer}@>& x,const stack<T, Cont@\removedConcepts{ainer}@>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(stack<T,Allocator>& x, stack<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(stack<T,Allocator>&& x, stack<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(stack<T,Allocator>& x, stack<T,Allocator>&& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(stack<T,Alloc@\removedConcepts{ator}@>& x, stack<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(stack<T,Alloc@\removedConcepts{ator}@>&& x, stack<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(stack<T,Alloc@\removedConcepts{ator}@>& x, stack<T,Alloc@\removedConcepts{ator}@>&& y);
}
\end{codeblock}
@@ -1323,29 +1323,29 @@
\begin{codeblock}
namespace std {
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+ template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
@\addedConcepts{requires Destructible<T>}@
class vector;
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator==(const vector<T,Allocator>& x,const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator< (const vector<T,Allocator>& x,const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator!=(const vector<T,Allocator>& x,const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator> (const vector<T,Allocator>& x,const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>=(const vector<T,Allocator>& x,const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<=(const vector<T,Allocator>& x,const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>&& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>&& y);
- template <class Allocator> class vector<bool,Allocator>;
+ template <@\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@> class vector<bool,Alloc@\removedConcepts{ator}@>;
\end{codeblock}
\rSec2[array]{\marktr{}Class template \tcode{array}}
@@ -1606,44 +1606,44 @@
\begin{codeblock}
namespace std {
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+ template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
@\addedConcepts{requires Destructible<T>}@
class deque {
public:
// types:
- typedef typename Allocator::reference reference;
- typedef typename Allocator::const_reference const_reference;
+ typedef typename Alloc@\removedConcepts{ator}@::reference reference;
+ typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference;
typedef @\impdef@ iterator; // See \ref{container.requirements}
typedef @\impdef@ const_iterator; // See \ref{container.requirements}
typedef @\impdef@ size_type; // See \ref{container.requirements}
typedef @\impdef@ difference_type;// See \ref{container.requirements}
typedef T value_type;
- typedef Allocator allocator_type;
- typedef typename Allocator::pointer pointer;
- typedef typename Allocator::const_pointer const_pointer;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
+ typedef typename Alloc@\removedConcepts{ator}@::pointer pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// \ref{deque.cons} construct/copy/destroy:
- explicit deque(const Allocator& = Allocator());
+ explicit deque(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
@\addedConcepts{requires DefaultConstructible<T>}@ explicit deque(size_type n);
- @\addedConcepts{requires CopyConstructible<T>}@ deque(size_type n, const T& value,const Allocator& = Allocator());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ deque(size_type n, const T& value,const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference>}@
- deque(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,const Allocator& = Allocator());
- @\addedConcepts{requires CopyConstructible<T>}@ deque(const deque<T,Allocator>& x);
+ deque(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ deque(const deque<T,Alloc@\removedConcepts{ator}@>& x);
deque(deque&&);
- @\addedConcepts{requires CopyConstructible<T>}@ deque(const deque&, const Allocator&);
- deque(deque&&, const Allocator&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ deque(const deque&, const Alloc@\removedConcepts{ator}@&);
+ deque(deque&&, const Alloc@\removedConcepts{ator}@&);
~deque();
- @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
- deque<T,Allocator>& operator=(const deque<T,Allocator>& x);
- deque<T,Allocator>& operator=(const deque<T,Allocator>&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
+ deque<T,Alloc@\removedConcepts{ator}@>& operator=(const deque<T,Alloc@\removedConcepts{ator}@>& x);
+ deque<T,Alloc@\removedConcepts{ator}@>& operator=(const deque<T,Alloc@\removedConcepts{ator}@>&& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& CopyAssignable<T, Iter::reference>}@
void assign(InputIterator first, InputIterator last);
- @\addedConcepts{requires CopyAssignable<T> \&\& CopyConstructible<T>}@ void assign(size_type n, const T& t);
+ @\addedConcepts{requires CopyAssignable<T> \&\& ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T& t);
allocator_type get_allocator() const;
// iterators:
@@ -1666,7 +1666,7 @@
size_type max_size() const;
@\addedConcepts{requires DefaultConstructible<T> \&\& MoveAssignable<T>}@
void resize(size_type sz);
- @\addedConcepts{requires CopyConstructible<T> \&\& MoveAssignable<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& MoveAssignable<T>}@
void resize(size_type sz, const T& c);
bool empty() const;
@@ -1692,11 +1692,11 @@
@\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveAssignable<T>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
iterator insert(const_iterator position, const T& x);
- @\addedConcepts{requires MoveConstructible<T> \&\& MoveAssignable<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
iterator insert(const_iterator position, T&& x);
- @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
void insert(const_iterator position, size_type n, const T& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasCopyAssign<T, Iter::reference> \&\& HasConstructor<T, Iter::reference>}@
@@ -1708,41 +1708,41 @@
@\addedConcepts{requires MoveAssignable<T>}@ iterator erase(const_iterator position);
@\addedConcepts{requires MoveAssignable<T>}@ iterator erase(const_iterator first, const_iterator last);
- void swap(deque<T,Allocator>&&);
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>&&);
void clear();
};
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
// specialized algorithms:
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
-
- template <class T, class Alloc
- struct constructible_with_allocator_suffix<deque<T, Alloc> >
- : true_type { };
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>&& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>&& y);
+
+ @\removedConcepts{template <class T, class Alloc}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<deque<T, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
\rSec3[deque.cons]{\tcode{deque}\ constructors, copy, and assignment}
\begin{itemdecl}
-explicit deque(const Allocator& = Allocator());
+explicit deque(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -1774,9 +1774,9 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
deque(size_type @\farg{n}@, const T& @\farg{value}@,
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -1799,7 +1799,7 @@
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference>}@
deque(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@,
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -1833,7 +1833,7 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
void assign(size_type n, const T& t);
\end{itemdecl}
@@ -1868,7 +1868,7 @@
\index{resize@\tcode{resize}!\tcode{deque}}%
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& MoveAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& MoveAssignable<T>}@
void resize(size_type sz, const T& c);
\end{itemdecl}
@@ -1896,11 +1896,11 @@
\index{insert@\tcode{push_back}!\tcode{deque}}%
\index{insert@\tcode{emplace}!\tcode{deque}}%
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
iterator insert(const_iterator position, const T& x);
-@\addedConcepts{requires MoveConstructible<T> \&\& MoveAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
iterator insert(const_iterator position, T&& x);
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
void insert(const_iterator position, size_type n, const T& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasCopyAssign<T, Iter::reference> \&\& HasConstructor<T, Iter::reference>}@
@@ -1973,12 +1973,12 @@
\rSec3[deque.special]{\tcode{deque}\ specialized algorithms}
\begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>&& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>&& y);
\end{itemdecl}
\begin{itemdescr}
@@ -1999,42 +1999,42 @@
\begin{codeblock}
namespace std {
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+ template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
@\addedConcepts{requires Destructible<T>}@
class forward_list {
public:
// types:
- typedef typename Allocator::reference reference;
- typedef typename Allocator::const_reference const_reference;
+ typedef typename Alloc@\removedConcepts{ator}@::reference reference;
+ typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference;
typedef @\impdef@ iterator; // See 23.1
typedef @\impdef@ const_iterator; // See 23.1
typedef @\impdef@ size_type; // See 23.1
typedef @\impdef@ difference_type;// See 23.1
typedef T value_type;
- typedef Allocator allocator_type;
- typedef typename Allocator::pointer pointer;
- typedef typename Allocator::const_pointer const_pointer;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
+ typedef typename Alloc@\removedConcepts{ator}@::pointer pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer;
// \ref{forwardlist.cons} construct/copy/destroy:
- explicit forward_list(const Allocator& = Allocator());
+ explicit forward_list(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
@\addedConcepts{requires DefaultConstructible<T>}@ explicit forward_list(size_type n);
- @\addedConcepts{requires CopyConstructible<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
forward_list(size_type n, const T& value,
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{HasConstructor<T, Iter::reference>}@
forward_list(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Allocator& = Allocator());
- @\addedConcepts{requires CopyConstructible<T>}@ forward_list(const forward_list<T,Allocator>& x);
- forward_list(forward_list<T,Allocator>&& x);
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ forward_list(const forward_list<T,Alloc@\removedConcepts{ator}@>& x);
+ forward_list(forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
~forward_list();
@\addedConcepts{requires CopyAssignable<T>}@
- forward_list<T,Allocator>& operator=(const forward_list<T,Allocator>& x);
- forward_list<T,Allocator>& operator=(forward_list<T,Allocator>&& x);
+ forward_list<T,Alloc@\removedConcepts{ator}@>& operator=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x);
+ forward_list<T,Alloc@\removedConcepts{ator}@>& operator=(forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference>}@
void assign(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
- @\addedConcepts{CopyConstructible<T>}@ void assign(size_type n, const T& t);
+ @\addedConcepts{ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T& t);
allocator_type get_allocator() const;
// \ref{forwardlist.iter} iterators:
@@ -2066,10 +2066,10 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<T, Args\&\&...>}@
iterator emplace_after(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<T>}@ iterator insert_after(const_iterator position, const T& x);
- @\addedConcepts{requires MoveConstructible<T>}@ iterator insert_after(const_iterator position, T&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ iterator insert_after(const_iterator position, const T& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ iterator insert_after(const_iterator position, T&& x);
- @\addedConcepts{requires CopyConstructible<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
void insert_after(const_iterator position, size_type n, const T& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference>}@
@@ -2077,17 +2077,17 @@
iterator erase_after(const_iterator position);
iterator erase_after(const_iterator position, iterator last);
- void swap(forward_list<T,Allocator>&&);
+ void swap(forward_list<T,Alloc@\removedConcepts{ator}@>&&);
@\addedConcepts{requires DefaultConstructible<T>}@ void resize(size_type sz);
- @\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, value_type c);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, value_type c);
void clear();
// \ref{forwardlist.ops} forward_list operations:
- void splice_after(const_iterator position, forward_list<T,Allocator>&& x);
- void splice_after(const_iterator position, forward_list<T,Allocator>&& x,
+ void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
+ void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x,
const_iterator i);
- void splice_after(const_iterator position, forward_list<T,Allocator>&& x,
+ void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x,
const_iterator first, const_iterator last);
@\addedConcepts{requires EqualityComparable<T>}@ void remove(const T& value);
@@ -2097,9 +2097,9 @@
template <@\changedConcepts{class}{Predicate<auto, T, T>}@ BinaryPredicate>
void unique(BinaryPredicate binary_pred);
- @\addedConcepts{requires LessThanComparable<T>}@ void merge(forward_list<T,Allocator>&& x);
+ @\addedConcepts{requires LessThanComparable<T>}@ void merge(forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare>
- void merge(forward_list<T,Allocator>&& x, Compare comp);
+ void merge(forward_list<T,Alloc@\removedConcepts{ator}@>&& x, Compare comp);
@\addedConcepts{requires LessThanComparable<T>}@ void sort();
template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare> void sort(Compare comp);
@@ -2108,33 +2108,33 @@
};
// Comparison operators
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator==(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator< (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator!=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator> (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y);
// \ref{forwardlist.spec} specialized algorithms:
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(forward_list<T,Alloc@\removedConcepts{ator}@>&& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>&& y);
}
\end{codeblock}
\rSec3[forwardlist.cons]{\tcode{forward_list} constructors, copy, assignment}
\begin{itemdecl}
-explicit forward_list(const Allocator& = Allocator());
+explicit forward_list(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -2161,8 +2161,8 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@
- forward_list(size_type n, const T& value, const Allocator& = Allocator());
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
+ forward_list(size_type n, const T& value, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -2180,7 +2180,7 @@
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{HasConstructor<T, Iter::reference>}@
forward_list(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -2203,7 +2203,7 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{CopyConstructible<T>}@ void assign(size_type n, const T\& t);
+@\addedConcepts{ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T\& t);
\end{itemdecl}
\begin{itemdescr}
@@ -2263,8 +2263,8 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ iterator insert_after(const_iterator position, const T& x);
-@\addedConcepts{requires MoveConstructible<T>}@ iterator insert_after(const_iterator position, T&& x);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ iterator insert_after(const_iterator position, const T& x);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ iterator insert_after(const_iterator position, T&& x);
\end{itemdecl}
\begin{itemdescr}
@@ -2279,7 +2279,7 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
void insert_after(const_iterator position, size_type n, const T& x);
\end{itemdecl}
@@ -2351,7 +2351,7 @@
\begin{itemdecl}
@\addedConcepts{requires DefaultConstructible<T>}@ void resize(size_type sz);
-@\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, value_type c);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, value_type c);
\end{itemdecl}
\begin{itemdescr}
@@ -2371,7 +2371,7 @@
\rSec3[forwardlist.ops]{\tcode{forward_list} operations}
\begin{itemdecl}
-void splice_after(const_iterator position, forward_list<T,Allocator>&& x);
+void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
\end{itemdecl}
\begin{itemdescr}
@@ -2389,7 +2389,7 @@
\end{itemdescr}
\begin{itemdecl}
-void splice_after(const_iterator position, forward_list<T,Allocator>&& x, const_iterator i);
+void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x, const_iterator i);
\end{itemdecl}
\begin{itemdescr}
@@ -2407,7 +2407,7 @@
\end{itemdescr}
\begin{itemdecl}
-void splice_after(const_iterator position, forward_list<T,Allocator>&& x, const_iterator first, const_iterator last);
+void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x, const_iterator first, const_iterator last);
\end{itemdecl}
\begin{itemdescr}
@@ -2452,9 +2452,9 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires LessThanComparable<T>}@ void merge(forward_list<T,Allocator>&& x);
+@\addedConcepts{requires LessThanComparable<T>}@ void merge(forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare>
- void merge(forward_list<T,Allocator>&& x, Compare comp)
+ void merge(forward_list<T,Alloc@\removedConcepts{ator}@>&& x, Compare comp)
\end{itemdecl}
\begin{itemdescr}
@@ -2502,12 +2502,12 @@
\rSec3[forwardlist.spec]{\tcode{forward_list} specialized algorithms}
\begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(forward_list<T,Alloc@\removedConcepts{ator}@>&& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>&& y);
\end{itemdecl}
\begin{itemdescr}
@@ -2550,43 +2550,43 @@
\begin{codeblock}
namespace std {
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+ template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
@\addedConcepts{requires Destructible<T>}@
class list {
public:
// types:
- typedef typename Allocator::reference reference;
- typedef typename Allocator::const_reference const_reference;
+ typedef typename Alloc@\removedConcepts{ator}@::reference reference;
+ typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference;
typedef @\impdef@ iterator; // See \ref{container.requirements}
typedef @\impdef@ const_iterator; // See \ref{container.requirements}
typedef @\impdef@ size_type; // See \ref{container.requirements}
typedef @\impdef@ difference_type;// See \ref{container.requirements}
typedef T value_type;
- typedef Allocator allocator_type;
- typedef typename Allocator::pointer pointer;
- typedef typename Allocator::const_pointer const_pointer;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
+ typedef typename Alloc@\removedConcepts{ator}@::pointer pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// \ref{list.cons} construct/copy/destroy:
- explicit list(const Allocator& = Allocator());
+ explicit list(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
@\addedConcepts{requires DefaultConstructible<T>}@ explicit list(size_type n);
- @\addedConcepts{requires CopyConstructible<T>}@
- list(size_type @\farg{n}@, const T& @\farg{value}@, const Allocator& = Allocator());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
+ list(size_type @\farg{n}@, const T& @\farg{value}@, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference>}@
- list(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@, const Allocator& = Allocator());
- @\addedConcepts{requires CopyConstructible<T>}@ list(const list<T,Allocator>& @\farg{x}@);
+ list(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ list(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@);
list(list&& x);
- @\addedConcepts{requires CopyConstructible<T>}@ list(const list&, const Allocator&);
- list(list&&, const Allocator&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ list(const list&, const Alloc@\removedConcepts{ator}@&);
+ list(list&&, const Alloc@\removedConcepts{ator}@&);
~list();
- @\addedConcepts{requires CopyAssignable<T>}@ list<T,Allocator>& operator=(const list<T,Allocator>& @\farg{x}@);
- list<T,Allocator>& operator=(list<T,Allocator>&& x);
+ @\addedConcepts{requires CopyAssignable<T>}@ list<T,Alloc@\removedConcepts{ator}@>& operator=(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@);
+ list<T,Alloc@\removedConcepts{ator}@>& operator=(list<T,Alloc@\removedConcepts{ator}@>&& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasCopyAssign<T, Iter::reference> \&\& HasConstructor<T, Iter::reference>}@
void assign(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
- @\addedConcepts{requires CopyAssignable<T> \&\& CopyConstructible<T>}@ void assign(size_type n, const T& t);
+ @\addedConcepts{requires CopyAssignable<T> \&\& ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T& t);
allocator_type get_allocator() const;
// iterators:
@@ -2609,7 +2609,7 @@
size_type size() const;
size_type max_size() const;
@\addedConcepts{requires DefaultConstructible<T>}@ void resize(size_type sz);
- @\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, const T& c);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, const T& c);
// element access:
reference front();
@@ -2630,9 +2630,9 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<T, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<T>}@ iterator insert(const_iterator @\farg{position}@, const T& @\farg{x}@);
- @\addedConcepts{requires MoveConstructible<T>}@ iterator insert(const_iterator position, T&& x);
- @\addedConcepts{requires CopyConstructible<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ iterator insert(const_iterator @\farg{position}@, const T& @\farg{x}@);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ iterator insert(const_iterator position, T&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
void insert(const_iterator @\farg{position}@, size_type @\farg{n}@, const T& @\farg{x}@);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference>}@
@@ -2641,13 +2641,13 @@
iterator erase(const_iterator @\farg{position}@);
iterator erase(const_iterator @\farg{position}@, const_iterator @\farg{last}@);
- void swap(list<T,Allocator>&&);
+ void swap(list<T,Alloc@\removedConcepts{ator}@>&&);
void clear();
// \ref{list.ops} list operations:
- void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@);
- void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@, const_iterator @\farg{i}@);
- void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@,
+ void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@);
+ void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, const_iterator @\farg{i}@);
+ void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@,
const_iterator @\farg{first}@, const_iterator @\farg{last}@);
@\addedConcepts{requires EqualityComparable<T>}@ void remove(const T& @\farg{value}@);
@@ -2657,9 +2657,9 @@
template <@\changedConcepts{class}{Predicate<auto, T, T>}@ BinaryPredicate>
void unique(BinaryPredicate @\farg{binary_pred}@);
- @\addedConcepts{requires LessThanComparable<T>}@ void merge(list<T,Allocator>&& @\farg{x}@);
+ @\addedConcepts{requires LessThanComparable<T>}@ void merge(list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@);
template <@\changedConcepts{class}{BinaryPredicate<auto, T, T>}@ Compare>
- void merge(list<T,Allocator>&& @\farg{x}@, Compare @\farg{comp}@);
+ void merge(list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, Compare @\farg{comp}@);
@\addedConcepts{requires LessThanComparable<T>}@ void sort();
template <@\changedConcepts{class}{BinaryPredicate<auto, T, T>}@ Compare> void sort(Compare @\farg{comp}@);
@@ -2667,37 +2667,37 @@
void reverse();
};
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator==(const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator< (const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator!=(const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator> (const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>=(const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<=(const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
// specialized algorithms:
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>& x, list<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
-
- template <class T, class Alloc>
- struct constructible_with_allocator_suffix<list<T, Alloc> >
- : true_type { };
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>&& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>&& y);
+
+ @\removedConcepts{template <class T, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<list<T, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
\rSec3[list.cons]{\tcode{list}\ constructors, copy, and assignment}
\begin{itemdecl}
-explicit list(const Allocator& = Allocator());
+explicit list(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -2729,9 +2729,9 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
list(size_type @\farg{n}@, const T& @\farg{value}@,
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -2757,7 +2757,7 @@
\begin{itemdecl}
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference>}@
- list(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@, const Allocator& = Allocator());
+ list(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -2795,7 +2795,7 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires CopyAssignable<T> \&\& CopyConstructible<T>}@ void assign(size_type n, const T& t);
+@\addedConcepts{requires CopyAssignable<T> \&\& ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T& t);
\end{itemdecl}
\begin{itemdescr}
@@ -2827,7 +2827,7 @@
\index{resize@\tcode{resize}!\tcode{list}}%
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, const T& c);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, const T& c);
\end{itemdecl}
\begin{itemdescr}
@@ -2853,9 +2853,9 @@
\index{insert@\tcode{insert}!\tcode{list}}%
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ iterator insert(const_iterator position, const T& x);
-@\addedConcepts{requires MoveConstructible<T>}@ iterator insert(const_iterator position, T&& x);
-@\addedConcepts{requires CopyConstructible<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ iterator insert(const_iterator position, const T& x);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ iterator insert(const_iterator position, T&& x);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
void insert(const_iterator @\farg{position}@, size_type @\farg{n}@, const T& @\farg{x}@);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference>}@
@@ -2933,7 +2933,7 @@
\index{splice@\tcode{splice}!\tcode{list}}%
\begin{itemdecl}
-void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@);
+void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@);
\end{itemdecl}
\begin{itemdescr}
@@ -2970,7 +2970,7 @@
\end{itemdescr}
\begin{itemdecl}
-void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@, iterator @\farg{i}@);
+void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, iterator @\farg{i}@);
\end{itemdecl}
\begin{itemdescr}
@@ -3016,7 +3016,7 @@
\end{itemdescr}
\begin{itemdecl}
-void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@, iterator @\farg{first}@,
+void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, iterator @\farg{first}@,
iterator @\farg{last}@);
\end{itemdecl}
@@ -3137,8 +3137,8 @@
\index{merge@\tcode{merge}!\tcode{list}}%
\begin{itemdecl}
-@\addedConcepts{requires LessThanComparable<T>}@ void merge(list<T,Allocator>&& @\farg{x}@);
-template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare> void merge(list<T,Allocator>&& @\farg{x}@, Compare @\farg{comp}@);
+@\addedConcepts{requires LessThanComparable<T>}@ void merge(list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@);
+template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare> void merge(list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, Compare @\farg{comp}@);
\end{itemdecl}
\begin{itemdescr}
@@ -3237,12 +3237,12 @@
\rSec3[list.special]{\tcode{list}\ specialized algorithms}
\begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>& x, list<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>&& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>&& y);
\end{itemdecl}
\begin{itemdescr}
@@ -3471,9 +3471,9 @@
struct uses_allocator<queue<T, Container>, Alloc>
: uses_allocator<Container, Alloc>::type { };
- template <class T, class Container>
- struct constructible_with_allocator_suffix<queue<T, Container> >
- : true_type { };
+ @\removedConcepts{template <class T, class Container>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<queue<T, Container> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
@@ -3665,10 +3665,10 @@
struct uses_allocator<priority_queue<T, Cont@\removedConcepts{ainer}@, Compare>, Alloc>
: uses_allocator<Cont@\removedConcepts{ainer}@, Alloc>::type { };
- template <class T, class Cont@\removedConcepts{ainer}@, class Compare>
- struct constructible_with_allocator_suffix<
- priority_queue<T, Cont@\removedConcepts{ainer}@, Compare> >
- : true_type { };
+ @\removedConcepts{template <class T, class Container, class Compare>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{priority_queue<T, Container, Compare> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
@@ -3864,20 +3864,20 @@
bool operator>=(const stack<T, Cont@\removedConcepts{ainer}@>& x, const stack<T, Cont@\removedConcepts{ainer}@>& y);
template <@\changedConcepts{class}{LessThanComparable}@ T, class Cont@\removedConcepts{ainer}@>
bool operator<=(const stack<T, Cont@\removedConcepts{ainer}@>& x, const stack<T, Cont@\removedConcepts{ainer}@>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(stack<T,Allocator>& x, stack<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(stack<T,Allocator>&& x, stack<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(stack<T,Allocator>& x, stack<T,Allocator>&& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(stack<T,Alloc@\removedConcepts{ator}@>& x, stack<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(stack<T,Alloc@\removedConcepts{ator}@>&& x, stack<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(stack<T,Alloc@\removedConcepts{ator}@>& x, stack<T,Alloc@\removedConcepts{ator}@>&& y);
template <class T, class Cont@\removedConcepts{ainer}@, class Alloc>
struct uses_allocator<stack<T, Cont@\removedConcepts{ainer}@>, Alloc>
: uses_allocator<Cont@\removedConcepts{ainer}@, Alloc>::type { };
- template <class T, class Cont@\removedConcepts{ainer}@>
- struct constructible_with_allocator_suffix<stack<T, Cont@\removedConcepts{ainer}@> >
- : true_type { };
+ @\removedConcepts{template <class T, class Container>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<stack<T, Container> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
@@ -3992,7 +3992,7 @@
The elements of a vector are stored contiguously, meaning that if
\tcode{v}\
is a
-\tcode{vector<T, Allocator>}\
+\tcode{vector<T, Alloc@\removedConcepts{ator}@>}\
where
\tcode{T}\
is some type other than
@@ -4007,43 +4007,43 @@
\begin{codeblock}
namespace std {
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+ template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
@\addedConcepts{requires Destructible<T>}@
class vector {
public:
// types:
- typedef typename Allocator::reference reference;
- typedef typename Allocator::const_reference const_reference;
+ typedef typename Alloc@\removedConcepts{ator}@::reference reference;
+ typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference;
typedef @\impdef@ iterator; // See \ref{container.requirements}
typedef @\impdef@ const_iterator; // See \ref{container.requirements}
typedef @\impdef@ size_type; // See \ref{container.requirements}
typedef @\impdef@ difference_type;// See \ref{container.requirements}
typedef T value_type;
- typedef Allocator allocator_type;
- typedef typename Allocator::pointer pointer;
- typedef typename Allocator::const_pointer const_pointer;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
+ typedef typename Alloc@\removedConcepts{ator}@::pointer pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// \ref{vector.cons} construct/copy/destroy:
- explicit vector(const Allocator& = Allocator());
+ explicit vector(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
@\addedConcepts{requires DefaultConstructible<T>}@ explicit vector(size_type n);
- @\addedConcepts{requires CopyConstructible<T>}@ vector(size_type n, const T& value, const Allocator& = Allocator());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ vector(size_type n, const T& value, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
- @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& MoveConstructible<T>}@
+ @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
vector(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Allocator& = Allocator());
- @\addedConcepts{requires CopyConstructible<T>}@ vector(const vector<T,Allocator>& x);
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ vector(const vector<T,Alloc@\removedConcepts{ator}@>& x);
vector(vector&&);
- @\addedConcepts{requires CopyConstructible<T>}@ vector(const vector&, const Allocator&);
- vector(vector&&, const Allocator&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ vector(const vector&, const Alloc@\removedConcepts{ator}@&);
+ vector(vector&&, const Alloc@\removedConcepts{ator}@&);
~vector();
- @\addedConcepts{requires CopyAssignable<T>}@ vector<T,Allocator>& operator=(const vector<T,Allocator>& x);
- vector<T,Allocator>& operator=(vector<T,Allocator>&& x);
+ @\addedConcepts{requires CopyAssignable<T>}@ vector<T,Alloc@\removedConcepts{ator}@>& operator=(const vector<T,Alloc@\removedConcepts{ator}@>& x);
+ vector<T,Alloc@\removedConcepts{ator}@>& operator=(vector<T,Alloc@\removedConcepts{ator}@>&& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& HasCopyAssign<T, Iter::reference>}@
void assign(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
- @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@ void assign(size_type n, const T& u);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@ void assign(size_type n, const T& u);
allocator_type get_allocator() const;
// iterators:
@@ -4064,11 +4064,11 @@
// \ref{vector.capacity} capacity:
size_type size() const;
size_type max_size() const;
- @\addedConcepts{requires DefaultConstructible<T> \&\& MoveConstructible<T>}@ void resize(size_type sz);
- @\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, const T& c);
+ @\addedConcepts{requires DefaultConstructible<T> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@ void resize(size_type sz);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, const T& c);
size_type capacity() const;
bool empty() const;
- @\addedConcepts{requires MoveConstructible<T>}@ void reserve(size_type n);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ void reserve(size_type n);
// element access:
reference operator[](size_type n);
@@ -4086,54 +4086,54 @@
// \ref{vector.modifiers} modifiers:
template <class... Args>
- @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveConstructible<T>}@
+ @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
void push_back(Args&&... args);
void pop_back();
template <class... Args>
- @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveConstructible<T>}@
+ @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
iterator insert(const_iterator position, const T& x);
- @\addedConcepts{requires MoveConstructible<T> \&\& MoveAssignable<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
void insert(const_iterator position, T&& x);
- @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
void insert(const_iterator position, size_type n, const T& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& HasCopyAssign<T, Iter::reference>}@
- @\addedConcepts{\&\& MoveConstructible<T> \&\& MoveAssignable<T>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
void insert(const_iterator position,
@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@\addedConcepts{requires MoveAssignable<T>}@ iterator erase(const_iterator position);
@\addedConcepts{requires MoveAssignable<T>}@ iterator erase(const_iterator first, const_iterator last);
- void swap(vector<T,Allocator>&&);
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>&&);
void clear();
};
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
- bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
- bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
// specialized algorithms:
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
-
- template <class T, class Alloc>
- struct constructible_with_allocator_suffix<vector<T, Alloc> >
- : true_type { };
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>&& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>&& y);
+
+ @\removedConcepts{template <class T, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<vector<T, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}%
\index{vector@\tcode{vector}!\tcode{operator==}}%
@@ -4143,7 +4143,7 @@
\index{vector@\tcode{vector}!\tcode{vector}}
\begin{itemdecl}
-vector(const Allocator& = Allocator());
+vector(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -4174,9 +4174,9 @@
\index{vector@\tcode{vector}!\tcode{vector}}
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
explicit vector(size_type n, const T& value,
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -4194,9 +4194,9 @@
\index{vector@\tcode{vector}!\tcode{vector}}
\begin{itemdecl}
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
- @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& MoveConstructible<T>}@
+ @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
vector(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -4242,7 +4242,7 @@
\end{itemdescr}
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
void assign(size_type n, const T& t);
\end{itemdecl}
@@ -4271,7 +4271,7 @@
\index{reserve@\tcode{reserve}!\tcode{vector}}%
\begin{itemdecl}
-@\addedConcepts{requires MoveConstructible<T>}@ void reserve(size_type n);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ void reserve(size_type n);
\end{itemdecl}
\pnum
@@ -4309,7 +4309,7 @@
\footnote{
\tcode{reserve()}\
uses
-\tcode{Allocator::allocate()}\
+\tcode{Alloc@\removedConcepts{ator}@::allocate()}\
which may throw an appropriate exception.
}
@@ -4327,7 +4327,7 @@
\index{swap@\tcode{swap}!\tcode{vector}}%
\begin{itemdecl}
-void swap(vector<T,Allocator>&& x);
+void swap(vector<T,Alloc@\removedConcepts{ator}@>&& x);
\end{itemdecl}
\begin{itemdescr}
@@ -4346,7 +4346,7 @@
\index{resize@\tcode{resize}!\tcode{vector}}%
\begin{itemdecl}
-@\addedConcepts{requires DefaultConstructible<T> \&\& MoveConstructible<T>}@ void resize(size_type sz);
+@\addedConcepts{requires DefaultConstructible<T> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@ void resize(size_type sz);
\end{itemdecl}
\begin{itemdescr}
@@ -4363,7 +4363,7 @@
\index{resize@\tcode{resize}!\tcode{vector}}%
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, const T& c);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, const T& c);
\end{itemdecl}
\begin{itemdescr}
@@ -4409,23 +4409,23 @@
\index{insert@\tcode{insert}!\tcode{vector}}%
\begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
iterator insert(const_iterator position, const T& x);
-@\addedConcepts{requires MoveConstructible<T> \&\& MoveAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
iterator insert(const_iterator position, T&& x);
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
void insert(const_iterator position, size_type n, const T& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& HasCopyAssign<T, Iter::reference>}@
- @\addedConcepts{\&\& MoveConstructible<T> \&\& MoveAssignable<T>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
void insert(const_iterator position,
@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
template <class... Args>
- @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveConstructible<T>}@
+ @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
void push_back(Args&&... args);
template <class... Args>
- @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveConstructible<T>}@
+ @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
iterator emplace(const_iterator position, Args&&... args);
\end{itemdecl}
@@ -4477,12 +4477,12 @@
\rSec3[vector.special]{\tcode{vector}\ specialized algorithms}
\begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
- void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>&& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+ void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>&& y);
\end{itemdecl}
\begin{itemdescr}
@@ -4503,7 +4503,7 @@
\begin{codeblock}
namespace std {
- template <class Allocator> class vector<bool, Allocator> {
+ template <@\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@> class vector<bool, Alloc@\removedConcepts{ator}@> {
public:
// types:
typedef bool const_reference;
@@ -4512,7 +4512,7 @@
typedef @\impdef@ size_type; // See \ref{container.requirements}
typedef @\impdef@ difference_type;// See \ref{container.requirements}
typedef bool value_type;
- typedef Allocator allocator_type;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
typedef @\impdef@ pointer;
typedef @\impdef@ const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
@@ -4531,20 +4531,20 @@
};
// construct/copy/destroy:
- explicit vector(const Allocator& = Allocator());
+ explicit vector(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
explicit vector(size_type n, const bool& value = bool(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires Convertible<Iter::reference, bool>}@
vector(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Allocator& = Allocator());
- vector(const vector<bool,Allocator>& x);
- vector(vector<bool,Allocator>&& x);
- vector(const vector&, const Allocator&);
- vector(vector&&, const Allocator&);
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ vector(const vector<bool,Alloc@\removedConcepts{ator}@>& x);
+ vector(vector<bool,Alloc@\removedConcepts{ator}@>&& x);
+ vector(const vector&, const Alloc@\removedConcepts{ator}@&);
+ vector(vector&&, const Alloc@\removedConcepts{ator}@&);
~vector();
- vector<bool,Allocator>& operator=(const vector<bool,Allocator>& x);
- vector<bool,Allocator>& operator=(vector<bool,Allocator>&& x);
+ vector<bool,Alloc@\removedConcepts{ator}@>& operator=(const vector<bool,Alloc@\removedConcepts{ator}@>& x);
+ vector<bool,Alloc@\removedConcepts{ator}@>& operator=(vector<bool,Alloc@\removedConcepts{ator}@>&& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires Convertible<Iter::reference, bool>}@
void assign(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@@ -4596,7 +4596,7 @@
iterator erase(const_iterator position);
iterator erase(const_iterator first, const_iterator last);
- void swap(vector<bool,Allocator>&&);
+ void swap(vector<bool,Alloc@\removedConcepts{ator}@>&&);
static void swap(reference x, reference y);
void flip(); // flips all bits
void clear();
@@ -4646,69 +4646,73 @@
namespace std {
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T,
@\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
- class Allocator = allocator<pair<const Key, T> > >
+ @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<pair<const Key, T> > >
@\addedConcepts{requires Destructible<Key> \&\& Destructible<T> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
class map;
- template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
- bool operator==(const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator< (const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
- bool operator!=(const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator> (const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator>=(const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator<=(const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator>& x,
- map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator&& x,
- map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator& x,
- map<Key,T,Compare,Allocator>&& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T,
@\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
- class Allocator = allocator<pair<const Key, T> > >
+ @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<pair<const Key, T> > >
@\addedConcepts{requires Destructible<Key> \&\& Destructible<T> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
class multimap;
- template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
- bool operator==(const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator< (const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
- bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator> (const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator>& x,
- multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator&& x,
- multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator& x,
- multimap<Key,T,Compare,Allocator>&& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
}
\end{codeblock}
@@ -4718,68 +4722,72 @@
\begin{codeblock}
namespace std {
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
- class Allocator = allocator<Key> >
+ @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<Key> >
@\addedConcepts{requires Destructible<Key> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
class set;
- template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
- bool operator==(const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator< (const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
- bool operator!=(const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator> (const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator>=(const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator<=(const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(set<Key,Compare,Allocator>& x,
- set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Allocator>
- void swap(set<Key,T,Compare,Allocator&& x,
- set<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Allocator>
- void swap(set<Key,T,Compare,Allocator& x,
- set<Key,T,Compare,Allocator>&& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+ set<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+ set<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
- class Allocator = allocator<Key> >
+ @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<Key> >
@\addedConcepts{requires Destructible<Key> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
class multiset;
- template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
- bool operator==(const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator< (const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
- bool operator!=(const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator> (const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator>=(const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator<=(const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(multiset<Key,Compare,Allocator>& x,
- multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Allocator>
- void swap(multiset<Key,T,Compare,Allocator&& x,
- multiset<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Allocator>
- void swap(multiset<Key,T,Compare,Allocator& x,
- multiset<Key,T,Compare,Allocator>&& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+ multiset<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+ multiset<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
}
\end{codeblock}
@@ -4829,8 +4837,10 @@
namespace std {
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T,
@\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
- class Allocator = allocator<pair<const Key, T> > >
+ @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<pair<const Key, T> > >
@\addedConcepts{requires Destructible<Key> \&\& Destructible<T> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
class map {
public:
// types:
@@ -4838,15 +4848,15 @@
typedef T mapped_type;
typedef pair<const Key, T> value_type;
typedef Compare key_compare;
- typedef Allocator allocator_type;
- typedef typename Allocator::reference reference;
- typedef typename Allocator::const_reference const_reference;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
+ typedef typename Alloc@\removedConcepts{ator}@::reference reference;
+ typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference;
typedef @\impdef@ iterator; // See \ref{container.requirements}
typedef @\impdef@ const_iterator; // See \ref{container.requirements}
typedef @\impdef@ size_type; // See \ref{container.requirements}
typedef @\impdef@ difference_type;// See \ref{container.requirements}
- typedef typename Allocator::pointer pointer;
- typedef typename Allocator::const_pointer const_pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::pointer pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -4864,21 +4874,21 @@
// \ref{map.cons} construct/copy/destroy:
explicit map(const Compare& comp = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
map(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Compare& comp = Compare(), const Allocator& = Allocator());
- @\addedConcepts{requires CopyConstructible<value_type>}@ map(const map<Key,T,Compare,Allocator>& x);
- map(map<Key,T,Compare,Allocator>&& x);
- map(const Allocator&);
- @\addedConcepts{requires CopyConstructible<value_type>}@ map(const map&, const Allocator&);
- map(map&&, const Allocator&);
+ const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ map(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x);
+ map(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x);
+ map(const Alloc@\removedConcepts{ator}@&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ map(const map&, const Alloc@\removedConcepts{ator}@&);
+ map(map&&, const Alloc@\removedConcepts{ator}@&);
~map();
- @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
- map<Key,T,Compare,Allocator>& operator=(const map<Key,T,Compare,Allocator>& x);
- map<Key,T,Compare,Allocator>&
- operator=(map<Key,T,Compare,Allocator>&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& operator=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x);
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&
+ operator=(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x);
allocator_type get_allocator() const;
// iterators:
@@ -4915,11 +4925,11 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<value_type>}@ pair<iterator, bool> insert(const value_type& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ pair<iterator, bool> insert(const value_type& x);
template <class P>
@\addedConcepts{requires HasConstructor<value_type, P\&\&> \&\& Convertible<P, value_type>}@
pair<iterator, bool> insert(P&& x);
- @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const_iterator position, const value_type& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const_iterator position, const value_type& x);
template <class P>
@\addedConcepts{requires HasConstructor<value_type, P\&\&> \&\& Convertible<P, value_type>}@
iterator insert(const_iterator position, P&&);
@@ -4930,7 +4940,7 @@
iterator erase(const_iterator position);
size_type erase(const key_type& x);
iterator erase(const_iterator first, const_iterator last);
- void swap(map<Key,T,Compare,Allocator>&&);
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&&);
void clear();
// observers:
@@ -4953,40 +4963,40 @@
equal_range(const key_type& x) const;
};
- template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
- bool operator==(const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator< (const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
- bool operator!=(const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator> (const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator>=(const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator<=(const map<Key,T,Compare,Allocator>& x,
- const map<Key,T,Compare,Allocator>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
// specialized algorithms:
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator>& x,
- map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator&& x,
- map<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator& x,
- map<Key,T,Compare,Allocator>&& y);
-
- template <class Key, class T, class Compare, class Alloc>
- struct constructible_with_allocator_suffix<
- map<Key, T, Compare, Alloc> >
- : true_type { };
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
+
+ @\removedConcepts{template <class Key, class T, class Compare, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{map<Key, T, Compare, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}%
@@ -4997,7 +5007,7 @@
\begin{itemdecl}
explicit map(const Compare& comp = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -5016,7 +5026,7 @@
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
map(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Compare& comp = Compare(), const Allocator& = Allocator());
+ const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -5198,15 +5208,15 @@
\rSec3[map.special]{\tcode{map}\ specialized algorithms}
\begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator>& x,
- map<Key,T,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator>&& x,
- map<Key,T,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(map<Key,T,Compare,Allocator>& x,
- map<Key,T,Compare,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
\end{itemdecl}
\begin{itemdescr}
@@ -5270,8 +5280,10 @@
namespace std {
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T,
@\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
- class Allocator = allocator<pair<const Key, T> > >
+ @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<pair<const Key, T> > >
@\addedConcepts{requires Destructible<Key> \&\& Destructible<T> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
class multimap {
public:
// types:
@@ -5279,15 +5291,15 @@
typedef T mapped_type;
typedef pair<const Key,T> value_type;
typedef Compare key_compare;
- typedef Allocator allocator_type;
- typedef typename Allocator::reference reference;
- typedef typename Allocator::const_reference const_reference;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
+ typedef typename Alloc@\removedConcepts{ator}@::reference reference;
+ typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference;
typedef @\impdef@ iterator; // See \ref{container.requirements}
typedef @\impdef@ const_iterator; // See \ref{container.requirements}
typedef @\impdef@ size_type; // See \ref{container.requirements}
typedef @\impdef@ difference_type;// See \ref{container.requirements}
- typedef typename Allocator::pointer pointer;
- typedef typename Allocator::const_pointer const_pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::pointer pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -5305,21 +5317,21 @@
// construct/copy/destroy:
explicit multimap(const Compare& comp = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
multimap(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Compare& comp = Compare(), const Allocator& = Allocator());
- @\addedConcepts{requires CopyConstructible<value_type>}@ multimap(const multimap<Key,T,Compare,Allocator>& x);
- multimap(multimap<Key,T,Compare,Allocator>&& x);
- multimap(const Allocator&);
- @\addedConcepts{requires CopyConstructible<value_type>}@ multimap(const multimap&, const Allocator&);
- multimap(multimap&&, const Allocator&);
+ const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ multimap(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x);
+ multimap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x);
+ multimap(const Alloc@\removedConcepts{ator}@&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ multimap(const multimap&, const Alloc@\removedConcepts{ator}@&);
+ multimap(multimap&&, const Alloc@\removedConcepts{ator}@&);
~multimap();
- @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
- multimap<Key,T,Compare,Allocator>& operator=(const multimap<Key,T,Compare,Allocator>& x);
- multimap<Key,T,Compare,Allocator>&
- operator=(const multimap<Key,T,Compare,Allocator>&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& operator=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x);
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&
+ operator=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x);
allocator_type get_allocator() const;
// iterators:
@@ -5350,11 +5362,11 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const value_type& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const value_type& x);
template <class P>
@\addedConcepts{requires HasConstructor<value_type, P\&\&> \&\& Convertible<P, value_type>}@
iterator insert(P&& x);
- @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const_iterator position, const value_type& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const_iterator position, const value_type& x);
template <class P>
@\addedConcepts{requires HasConstructor<value_type, P\&\&> \&\& Convertible<P, value_type>}@
iterator insert(const_iterator position, P&& x);
@@ -5365,7 +5377,7 @@
iterator erase(const_iterator position);
size_type erase(const key_type& x);
iterator erase(const_iterator first, const_iterator last);
- void swap(multimap<Key,T,Compare,Allocator>&&);
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&&);
void clear();
// observers:
@@ -5388,40 +5400,40 @@
equal_range(const key_type& x) const;
};
- template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
- bool operator==(const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator< (const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
- bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator> (const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
- bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
- const multimap<Key,T,Compare,Allocator>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
// specialized algorithms:
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator>& x,
- multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator&& x,
- multimap<Key,T,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator& x,
- multimap<Key,T,Compare,Allocator>&& y);
-
- template <class Key, class T, class Compare, class Alloc>
- struct constructible_with_allocator_suffix<
- multimap<Key, T, Compare, Alloc> >
- : true_type { };
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
+
+ @\removedConcepts{template <class Key, class T, class Compare, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{multimap<Key, T, Compare, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}%
\index{multimap@\tcode{multimap}!\tcode{operator==}}%
@@ -5431,7 +5443,7 @@
\begin{itemdecl}
explicit multimap(const Compare& comp = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -5450,7 +5462,7 @@
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
multimap(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Compare& comp = Compare(), const Allocator& = Allocator());
+ const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -5549,15 +5561,15 @@
\rSec3[multimap.special]{\tcode{multimap}\ specialized algorithms}
\begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator>& x,
- multimap<Key,T,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator>&& x,
- multimap<Key,T,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
- void swap(multimap<Key,T,Compare,Allocator>& x,
- multimap<Key,T,Compare,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+ multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
\end{itemdecl}
\begin{itemdescr}
@@ -5614,8 +5626,10 @@
\begin{codeblock}
namespace std {
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
- class Allocator = allocator<Key> >
+ @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<Key> >
@\addedConcepts{requires Destructible<Key> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
class set {
public:
// types:
@@ -5623,35 +5637,35 @@
typedef Key value_type;
typedef Compare key_compare;
typedef Compare value_compare;
- typedef Allocator allocator_type;
- typedef typename Allocator::reference reference;
- typedef typename Allocator::const_reference const_reference;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
+ typedef typename Alloc@\removedConcepts{ator}@::reference reference;
+ typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference;
typedef @\impdef@ iterator; // See \ref{container.requirements}
typedef @\impdef@ const_iterator; // See \ref{container.requirements}
typedef @\impdef@ size_type; // See \ref{container.requirements}
typedef @\impdef@ difference_type;// See \ref{container.requirements}
- typedef typename Allocator::pointer pointer;
- typedef typename Allocator::const_pointer const_pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::pointer pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// \ref{set.cons} construct/copy/destroy:
explicit set(const Compare& comp = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
set(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
- const Compare& comp = Compare(), const Allocator& = Allocator());
- @\addedConcepts{requires CopyConstructible<value_type>}@ set(const set<Key,Compare,Allocator>& x);
- set(set<Key,Compare,Allocator>&& x);
- set(const Allocator&);
- @\addedConcepts{requires CopyConstructible<value_type>}@ set(const set&, const Allocator&);
- set(set&&, const Allocator&);
+ const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ set(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x);
+ set(set<Key,Compare,Alloc@\removedConcepts{ator}@>&& x);
+ set(const Alloc@\removedConcepts{ator}@&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ set(const set&, const Alloc@\removedConcepts{ator}@&);
+ set(set&&, const Alloc@\removedConcepts{ator}@&);
~set();
- @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
- set<Key,Compare,Allocator>& operator=(const set<Key,Compare,Allocator>& x);
- set<Key,Compare,Allocator>& operator=(set<Key,Compare,Allocator>&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>& operator=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x);
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>& operator=(set<Key,Compare,Alloc@\removedConcepts{ator}@>&& x);
allocator_type get_allocator() const;
// iterators:
@@ -5682,10 +5696,10 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<value_type>}@ pair<iterator,bool> insert(const value_type& x);
- @\addedConcepts{requires MoveConstructible<value_type>}@ pair<iterator,bool> insert(value_type&& x);
- @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const_iterator position, const value_type& x);
- @\addedConcepts{requires MoveConstructible<value_type>}@ iterator insert(const_iterator position, value_type&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ pair<iterator,bool> insert(const value_type& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ pair<iterator,bool> insert(value_type&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const_iterator position, const value_type& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ iterator insert(const_iterator position, value_type&& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
void insert(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@@ -5693,7 +5707,7 @@
iterator erase(const_iterator position);
size_type erase(const key_type& x);
iterator erase(const_iterator first, const_iterator last);
- void swap(set<Key,Compare,Allocator>&);
+ void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>&);
void clear();
// observers:
@@ -5716,40 +5730,40 @@
pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
};
- template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
- bool operator==(const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator< (const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
- bool operator!=(const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator> (const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator>=(const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator<=(const set<Key,Compare,Allocator>& x,
- const set<Key,Compare,Allocator>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
// specialized algorithms:
- template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(set<Key,Compare,Allocator>& x,
- set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(set<Key,Compare,Allocator&& x,
- set<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(set<Key,Compare,Allocator& x,
- set<Key,Compare,Allocator>&& y);
-
- template <class Key, class Compare, class Alloc>
- struct constructible_with_allocator_suffix<
- set<Key, Compare, Alloc> >
- : true_type { };
+ template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@&& x,
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@& x,
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>&& y);
+
+ @\removedConcepts{template <class Key, class Compare, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{set<Key, Compare, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}%
\index{set@\tcode{set}!\tcode{operator==}}%
@@ -5759,7 +5773,7 @@
\begin{itemdecl}
explicit set(const Compare& comp = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -5776,7 +5790,7 @@
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
set(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@,
- const Compare& @\farg{comp}@ = Compare(), const Allocator& = Allocator());
+ const Compare& @\farg{comp}@ = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -5806,15 +5820,15 @@
\rSec3[set.special]{\tcode{set}\ specialized algorithms}
\begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(set<Key,Compare,Allocator>& x,
- set<Key,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(set<Key,Compare,Allocator>&& x,
- set<Key,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(set<Key,Compare,Allocator>& x,
- set<Key,Compare,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>&& x,
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ set<Key,Compare,Alloc@\removedConcepts{ator}@>&& y);
\end{itemdecl}
\begin{itemdescr}
@@ -5872,8 +5886,10 @@
\begin{codeblock}
namespace std {
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
- class Allocator = allocator<Key> >
+ @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<Key> >
@\addedConcepts{requires Destructible<Key> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
class multiset {
public:
// types:
@@ -5881,35 +5897,35 @@
typedef Key value_type;
typedef Compare key_compare;
typedef Compare value_compare;
- typedef Allocator allocator_type;
- typedef typename Allocator::reference reference;
- typedef typename Allocator::const_reference const_reference;
+ typedef Alloc@\removedConcepts{ator}@ allocator_type;
+ typedef typename Alloc@\removedConcepts{ator}@::reference reference;
+ typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference;
typedef @\impdef@ iterator; // See \ref{container.requirements}
typedef @\impdef@ const_iterator; // See \ref{container.requirements}
typedef @\impdef@ size_type; // See \ref{container.requirements}
typedef @\impdef@ difference_type;// See \ref{container.requirements}
- typedef typename Allocator::pointer pointer;
- typedef typename Allocator::const_pointer const_pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::pointer pointer;
+ typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// construct/copy/destroy:
explicit multiset(const Compare& comp = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
multiset(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
const Compare& comp = Compare(),
- const Allocator& = Allocator());
- @\addedConcepts{requires CopyConstructible<value_type>}@ multiset(const multiset<Key,Compare,Allocator>& x);
- multiset(multiset<Key,Compare,Allocator>&& x);
- multiset(const Allocator&);
- @\addedConcepts{requires CopyConstructible<value_type>}@ multiset(const multiset&, const Allocator&);
- multiset(multiset&&, const Allocator&);
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ multiset(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x);
+ multiset(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& x);
+ multiset(const Alloc@\removedConcepts{ator}@&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ multiset(const multiset&, const Alloc@\removedConcepts{ator}@&);
+ multiset(multiset&&, const Alloc@\removedConcepts{ator}@&);
~multiset();
- @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
- multiset<Key,Compare,Allocator>& operator=(const multiset<Key,Compare,Allocator>& x);
- multiset<Key,Compare,Allocator>& operator=(multiset<Key,Compare,Allocator>&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& operator=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x);
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& operator=(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& x);
allocator_type get_allocator() const;
// iterators:
@@ -5940,10 +5956,10 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const value_type& x);
- @\addedConcepts{requires MoveConstructible<value_type>}@ iterator insert(value_type&& x);
- @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const_iterator position, const value_type& x);
- @\addedConcepts{requires MoveConstructible<value_type>}@ iterator insert(const_iterator position, value_type&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const value_type& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ iterator insert(value_type&& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const_iterator position, const value_type& x);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ iterator insert(const_iterator position, value_type&& x);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
void insert(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@@ -5951,7 +5967,7 @@
iterator erase(const_iterator position);
size_type erase(const key_type& x);
iterator erase(const_iterator first, const_iterator last);
- void swap(multiset<Key,Compare,Allocator>&&);
+ void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&&);
void clear();
// observers:
@@ -5974,40 +5990,40 @@
pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
};
- template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
- bool operator==(const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator< (const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
- bool operator!=(const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator> (const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator>=(const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
- bool operator<=(const multiset<Key,Compare,Allocator>& x,
- const multiset<Key,Compare,Allocator>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator==(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator< (const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator!=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator> (const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator>=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ bool operator<=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
// specialized algorithms:
- template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(multiset<Key,Compare,Allocator>& x,
- multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(multiset<Key,Compare,Allocator&& x,
- multiset<Key,Compare,Allocator>& y);
- template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(multiset<Key,Compare,Allocator& x,
- multiset<Key,Compare,Allocator>&& y);
-
- template <class Key, class Compare, class Alloc>
- struct constructible_with_allocator_suffix<
- multiset<Key, Compare, Alloc> >
- : true_type { };
+ template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@&& x,
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+ template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@& x,
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& y);
+
+ @\removedConcepts{template <class Key, class Compare, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{multiset<Key, Compare, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}%
\index{multiset@\tcode{multiset}!\tcode{operator==}}%
@@ -6017,7 +6033,7 @@
\begin{itemdecl}
explicit multiset(const Compare& @\farg{comp}@ = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -6035,7 +6051,7 @@
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
multiset(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@,
const Compare& @\farg{comp}@ = Compare(),
- const Allocator& = Allocator());
+ const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
\end{itemdecl}
\begin{itemdescr}
@@ -6065,15 +6081,15 @@
\rSec3[multiset.special]{\tcode{multiset}\ specialized algorithms}
\begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(multiset<Key,Compare,Allocator>& x,
- multiset<Key,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(multiset<Key,Compare,Allocator>&& x,
- multiset<Key,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
- void swap(multiset<Key,Compare,Allocator>& x,
- multiset<Key,Compare,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& x,
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+ void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+ multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& y);
\end{itemdecl}
\begin{itemdescr}
@@ -6100,9 +6116,13 @@
@\changedConcepts{class}{ObjectType}@ T,
@\changedConcepts{class}{Callable<auto, Key>}@ Hash = hash<Key>,
@\changedConcepts{class}{Predicate<auto, Key, Key>}@ Pred = std::equal_to<Key>,
- class Alloc = std::allocator<std::pair<const Key, T> > >
+ @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<std::pair<const Key, T> > >
@\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
@\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
class unordered_map;
// \ref{unord.multimap}, class template unordered_multimap:
@@ -6110,9 +6130,13 @@
@\changedConcepts{class}{ObjectType}@ T,
@\changedConcepts{class}{Callable<auto, Key>}@ Hash = hash<Key>,
@\changedConcepts{class}{Predicate<auto, Key, Key>}@ Pred = std::equal_to<Key>,
- class Alloc = std::allocator<std::pair<const Key, T> > >
+ @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<std::pair<const Key, T> > >
@\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
@\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
class unordered_multimap;
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Hash, class Pred, class Alloc>
@@ -6135,18 +6159,26 @@
template <@\changedConcepts{class}{ObjectType}@ Value,
@\changedConcepts{class}{Callable<auto, Value>}@ Hash = hash<Value>,
@\changedConcepts{class}{Predicate<auto, Value, Value>}@ class Pred = std::equal_to<Value>,
- class Alloc = std::allocator<Value> >
+ @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<Value> >
@\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
@\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
class unordered_set;
// \ref{unord.multiset}, class template unordered_multiset:
template <@\changedConcepts{class}{ObjectType}@ Value,
@\changedConcepts{class}{Callable<auto, Value>}@ Hash = hash<Value>,
@\changedConcepts{class}{Predicate<auto, Value, Value>}@ class Pred = std::equal_to<Value>,
- class Alloc = std::allocator<Value> >
+ @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<Value> >
@\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
@\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
class unordered_multiset;
template <@\changedConcepts{class}{ObjectType}@ Value, class Hash, class Pred, class Alloc>
@@ -6186,9 +6218,13 @@
@\changedConcepts{class}{ObjectType}@ T,
@\changedConcepts{class}{Callable<auto, Key>}@ Hash = hash<Key>,
@\changedConcepts{class}{Predicate<auto, Key, Key>}@ Pred = std::equal_to<Key>,
- class Alloc = std::allocator<std::pair<const Key, T> > >
+ @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<std::pair<const Key, T> > >
@\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
@\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
class unordered_map
{
public:
@@ -6223,12 +6259,12 @@
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
- @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_map(const unordered_map&);
- unordered_map(const Allocator&);
- @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_map(const unordered_map&, const Allocator&);
- unordered_map(unordered_map&&, const Allocator&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_map(const unordered_map&);
+ unordered_map(const Alloc@\removedConcepts{ator}@&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_map(const unordered_map&, const Alloc@\removedConcepts{ator}@&);
+ unordered_map(unordered_map&&, const Alloc@\removedConcepts{ator}@&);
~unordered_map();
- @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
unordered_map& operator=(const unordered_map&);
allocator_type get_allocator() const;
@@ -6252,9 +6288,9 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
std::pair<iterator, bool> insert(const value_type& obj);
- @\addedConcepts{requires CopyConstructible<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
iterator insert(const_iterator hint, const value_type& obj);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
@@ -6278,7 +6314,7 @@
std::pair<iterator, iterator> equal_range(const key_type& k);
std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
- @\addedConcepts{requires DefaultConstructible<T> \&\& CopyConstructible<key_type>}@ mapped_type& operator[](const key_type& k);
+ @\addedConcepts{requires DefaultConstructible<T> \&\& CopyConstructible<Key>}@ mapped_type& operator[](const key_type& k);
// bucket interface
size_type bucket_count() const;
@@ -6294,17 +6330,17 @@
float load_factor() const;
float max_load_factor() const;
void max_load_factor(float z);
- @\addedConcepts{requires MoveConstructible<value_type>}@ void rehash(size_type n);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ void rehash(size_type n);
};
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Hash, class Pred, class Alloc>
void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
unordered_map<Key, T, Hash, Pred, Alloc>& y);
- template <class Key, class T, class Hash, class Pred, class Alloc>
- struct constructible_with_allocator_suffix<
- unordered_map<Key, T, Hash, Pred, Compare, Alloc> >
- : true_type { };
+ @\removedConcepts{template <class Key, class T, class Hash, class Pred, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{unordered_map<Key, T, Hash, Pred, Compare, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
@@ -6360,7 +6396,7 @@
\index{operator[]@\tcode{operator[]}!unordered_map@\tcode{unordered_map}}%
\index{unordered_map@\tcode{unordered_map}!element access}%
\begin{itemdecl}
-@\addedConcepts{requires DefaultConstructible<T> \&\& CopyConstructible<key_type>}@ mapped_type& operator[](const key_type& k);
+@\addedConcepts{requires DefaultConstructible<T> \&\& CopyConstructible<Key>}@ mapped_type& operator[](const key_type& k);
\end{itemdecl}
\begin{itemdescr}
@@ -6416,9 +6452,13 @@
@\changedConcepts{class}{ObjectType}@ T,
@\changedConcepts{class}{Callable<auto, Key>}@ Hash = hash<Key>,
@\changedConcepts{class}{Predicate<auto, Key, Key>}@ Pred = std::equal_to<Key>,
- class Alloc = std::allocator<std::pair<const Key, T> > >
+ @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<std::pair<const Key, T> > >
@\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
@\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
class unordered_multimap
{
public:
@@ -6453,13 +6493,13 @@
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
- @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_multimap(const unordered_multimap&);
- unordered_multimap(const Allocator&);
- @\addedConcepts{requires CopyConstructible<value_type>}@
- unordered_multimap(const unordered_multimap&, const Allocator&);
- unordered_multimap(unordered_multimap&&, const Allocator&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_multimap(const unordered_multimap&);
+ unordered_multimap(const Alloc@\removedConcepts{ator}@&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
+ unordered_multimap(const unordered_multimap&, const Alloc@\removedConcepts{ator}@&);
+ unordered_multimap(unordered_multimap&&, const Alloc@\removedConcepts{ator}@&);
~unordered_multimap();
- @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
unordered_multimap& operator=(const unordered_multimap&);
allocator_type get_allocator() const;
@@ -6483,8 +6523,8 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const value_type& obj);
- @\addedConcepts{requires CopyConstructible<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const value_type& obj);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
iterator insert(const_iterator hint, const value_type& obj);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
void insert(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@@ -6521,17 +6561,17 @@
float load_factor() const;
float max_load_factor() const;
void max_load_factor(float z);
- @\addedConcepts{requires MoveConstructible<value_type>}@ void rehash(size_type n);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ void rehash(size_type n);
};
template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Hash, class Pred, class Alloc>
void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
- template <class Key, class T, class Hash, class Pred, class Alloc>
- struct constructible_with_allocator_suffix<
- unordered_multimap<Key, T, Hash, Pred, Alloc> >
- : true_type { };
+ @\removedConcepts{template <class Key, class T, class Hash, class Pred, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{unordered_multimap<Key, T, Hash, Pred, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
@@ -6622,9 +6662,13 @@
template <@\changedConcepts{class}{ObjectType}@ Value,
@\changedConcepts{class}{Callable<auto, Value>}@ Hash = hash<Value>,
@\changedConcepts{class}{Predicate<auto, Value, Value>}@ class Pred = std::equal_to<Value>,
- class Alloc = std::allocator<Value> >
+ @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<Value> >
@\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
@\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
class unordered_set
{
public:
@@ -6658,12 +6702,12 @@
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
- @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_set(const unordered_set&);
- unordered_set(const Allocator&);
- @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_set(const unordered_set&, const Allocator&);
- unordered_set(unordered_set&&, const Allocator&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_set(const unordered_set&);
+ unordered_set(const Alloc@\removedConcepts{ator}@&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_set(const unordered_set&, const Alloc@\removedConcepts{ator}@&);
+ unordered_set(unordered_set&&, const Alloc@\removedConcepts{ator}@&);
~unordered_set();
- @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
unordered_set& operator=(const unordered_set&);
allocator_type get_allocator() const;
@@ -6687,8 +6731,8 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<value_type>}@ std::pair<iterator, bool> insert(const value_type& obj);
- @\addedConcepts{requires CopyConstructible<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ std::pair<iterator, bool> insert(const value_type& obj);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
iterator insert(const_iterator hint, const value_type& obj);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
@@ -6726,17 +6770,17 @@
float load_factor() const;
float max_load_factor() const;
void max_load_factor(float z);
- @\addedConcepts{requires MoveConstructible<value_type>}@ void rehash(size_type n);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ void rehash(size_type n);
};
template <@\changedConcepts{class}{ObjectType}@ Value, class Hash, class Pred, class Alloc>
void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
unordered_set<Value, Hash, Pred, Alloc>& y);
- template <class Value, class Hash, class Pred, class Alloc>
- struct constructible_with_allocator_suffix<
- map<Value, Hash, Pred, Alloc> >
- : true_type { };
+ @\removedConcepts{template <class Value, class Hash, class Pred, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{map<Value, Hash, Pred, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
@@ -6826,9 +6870,13 @@
template <@\changedConcepts{class}{ObjectType}@ Value,
@\changedConcepts{class}{Callable<auto, Value>}@ Hash = hash<Value>,
@\changedConcepts{class}{Predicate<auto, Value, Value>}@ class Pred = std::equal_to<Value>,
- class Alloc = std::allocator<Value> >
+ @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<Value> >
@\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
@\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+ @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
class unordered_multiset
{
public:
@@ -6862,12 +6910,12 @@
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
- @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_multiset(const unordered_multiset&);
- unordered_multiset(const Allocator&);
- @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_multiset(const unordered_multiset&, const Allocator&);
- unordered_multiset(unordered_multiset&&, const Allocator&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_multiset(const unordered_multiset&);
+ unordered_multiset(const Alloc@\removedConcepts{ator}@&);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_multiset(const unordered_multiset&, const Alloc@\removedConcepts{ator}@&);
+ unordered_multiset(unordered_multiset&&, const Alloc@\removedConcepts{ator}@&);
~unordered_multiset();
- @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
unordered_multiset& operator=(const unordered_multiset&);
allocator_type get_allocator() const;
@@ -6891,8 +6939,8 @@
template <class... Args>
@\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
iterator emplace(const_iterator position, Args&&... args);
- @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const value_type& obj);
- @\addedConcepts{requires CopyConstructible<value_type>}@
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const value_type& obj);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
iterator insert(const_iterator hint, const value_type& obj);
template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
@\addedConcepts{requires HasConstructor<value_type, Iter::value_type>}@
@@ -6930,17 +6978,17 @@
float load_factor() const;
float max_load_factor() const;
void max_load_factor(float z);
- @\addedConcepts{requires MoveConstructible<value_type>}@ void rehash(size_type n);
+ @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ void rehash(size_type n);
};
template <@\changedConcepts{class}{ObjectType}@ Value, class Hash, class Pred, class Alloc>
void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
unordered_multiset<Value, Hash, Pred, Alloc>& y);
- template <class Value, class Hash, class Pred, class Alloc>
- struct constructible_with_allocator_suffix<
- unordered_multiset<Value, Hash, Pred, Alloc> >
- : true_type { };
+ @\removedConcepts{template <class Value, class Hash, class Pred, class Alloc>}@
+ @\removedConcepts{struct constructible_with_allocator_suffix<}@
+ @\removedConcepts{unordered_multiset<Value, Hash, Pred, Alloc> >}@
+ @\removedConcepts{: true_type \{ \};}@
}
\end{codeblock}
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk