OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

c++config (_GLIBCXX_NOEXCEPT_IF): Define. 

* include/bits/c++config (_GLIBCXX_NOEXCEPT_IF): Define.
	* include/bits/forward_list.h (forward_list::swap): Make noexcept
	unconditional.
	* include/bits/hashtable.h (_Hashtable::swap): Do not use
	_S_nothrow_swap().
	* include/bits/stl_bvector.h (vector<bool>::swap): Make noexcept
	unconditional.
	* include/bits/stl_deque.h (deque::swap): Likewise.
	(swap(deque&, deque&)): Use _GLIBCXX_NOEXCEPT_IF.
	* include/bits/stl_list.h (list::swap): Make noexcept unconditional.
	(swap(list&, list&)): Use _GLIBCXX_NOEXCEPT_IF.
	* include/bits/stl_map.h (map::swap, swap(map&, map&)): Use
	_GLIBCXX_NOEXCEPT_IF, do not depend on _S_nothrow_swap.
	* include/bits/stl_multimap.h (multimap::swap,
	swap(multimap&, multimap&)): Likewise.
	* include/bits/stl_multiset.h (multiset::swap,
	swap(multiset&, multiset&)): Likewise.
	* include/bits/stl_set.h (set::swap, swap(set&, set&)): Likewise.
	* include/bits/stl_tree.h (_Rb_tree::swap,
	swap(_Rb_tree&, _Rb_tree&)): Likewise.
	* include/bits/stl_vector.h (vector::swap): Make noexcept
	unconditional.
	(swap(vector&, vector&)): Use _GLIBCXX_NOEXCEPT_IF.
	* include/debug/deque (deque::swap, swap): Likewise.
	* include/debug/forward_list (swap): Add noexcept.
	* include/debug/list (list::swap, swap): Use _GLIBCXX_NOEXCEPT_IF.
	* include/debug/map.h (map::swap, swap): Likewise.
	* include/debug/multimap.h (multimap::swap, swap): Likewise.
	* include/debug/multiset.h (multiset::Swap, swap): Likewise.
	* include/debug/set.h (set::swap, swap): Likewise.
	* include/debug/unordered_map (unordered_map::swap,
	unordered_multimap::swap, swap): Likewise.
	* include/debug/unordered_set (unordered_set::swap,
	unordered_multiset::swap, swap): Likewise.
	* include/debug/vector (vector::swap, swap): Likewise.
	* include/ext/alloc_traits.h (__alloc_traits::_S_nothrow_swap()):
	Remove.
	* include/profile/deque (deque::swap, swap): Use _GLIBCXX_NOEXCEPT_IF.
	* include/profile/forward_list (swap): Add noexcept.
	* include/profile/list (list::swap, swap) : Use _GLIBCXX_NOEXCEPT_IF.
	* include/profile/map.h (map::swap, swap): Likewise.
	* include/profile/multimap.h (multimap::swap, swap): Likewise.
	* include/profile/multiset.h (multiset::swap, swap): Likewise.
	* include/profile/set.h (set::swap, swap): Likewise.
	* include/profile/unordered_map (swap): Likewise.
	* include/profile/unordered_set (swap): Likewise.
	* include/profile/vector (vector::swap, swap): Likewise. Remove
	overloads for swapping rvalues.
	* testsuite/23_containers/deque/allocator/noexcept.cc: Update tests
	for noexcept on swap.
	* testsuite/23_containers/forward_list/allocator/noexcept.cc:
	Likewise.
	* testsuite/23_containers/list/allocator/noexcept.cc: Likewise.
	* testsuite/23_containers/map/allocator/noexcept.cc: Likewise.
	* testsuite/23_containers/multimap/allocator/noexcept.cc: Likewise.
	* testsuite/23_containers/multiset/allocator/noexcept.cc: Likewise.
	* testsuite/23_containers/set/allocator/noexcept.cc: Likewise.
	* testsuite/23_containers/unordered_map/allocator/noexcept.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/noexcept.cc:
	Likewise.
	* testsuite/23_containers/unordered_multiset/allocator/noexcept.cc:
	Likewise.
	* testsuite/23_containers/unordered_set/allocator/noexcept.cc:
	Likewise.
	* testsuite/23_containers/vector/allocator/noexcept.cc: Likewise.
	* testsuite/23_containers/vector/bool/allocator/noexcept.cc: Likewise.
	* testsuite/ext/profile/mutex_extensions_neg.cc: Adjust dg-error line
	number.

From-SVN: r225744
This commit is contained in:
Jonathan Wakely 2015-07-13 18:15:48 +01:00 committed by Jonathan Wakely
parent 474d4bbe1d
commit c5d9ec5670
48 changed files with 323 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,75 @@
2015-07-13 Jonathan Wakely <jwakely@redhat.com>
* include/bits/c++config (_GLIBCXX_NOEXCEPT_IF): Define.
* include/bits/forward_list.h (forward_list::swap): Make noexcept
unconditional.
* include/bits/hashtable.h (_Hashtable::swap): Do not use
_S_nothrow_swap().
* include/bits/stl_bvector.h (vector<bool>::swap): Make noexcept
unconditional.
* include/bits/stl_deque.h (deque::swap): Likewise.
(swap(deque&, deque&)): Use _GLIBCXX_NOEXCEPT_IF.
* include/bits/stl_list.h (list::swap): Make noexcept unconditional.
(swap(list&, list&)): Use _GLIBCXX_NOEXCEPT_IF.
* include/bits/stl_map.h (map::swap, swap(map&, map&)): Use
_GLIBCXX_NOEXCEPT_IF, do not depend on _S_nothrow_swap.
* include/bits/stl_multimap.h (multimap::swap,
swap(multimap&, multimap&)): Likewise.
* include/bits/stl_multiset.h (multiset::swap,
swap(multiset&, multiset&)): Likewise.
* include/bits/stl_set.h (set::swap, swap(set&, set&)): Likewise.
* include/bits/stl_tree.h (_Rb_tree::swap,
swap(_Rb_tree&, _Rb_tree&)): Likewise.
* include/bits/stl_vector.h (vector::swap): Make noexcept
unconditional.
(swap(vector&, vector&)): Use _GLIBCXX_NOEXCEPT_IF.
* include/debug/deque (deque::swap, swap): Likewise.
* include/debug/forward_list (swap): Add noexcept.
* include/debug/list (list::swap, swap): Use _GLIBCXX_NOEXCEPT_IF.
* include/debug/map.h (map::swap, swap): Likewise.
* include/debug/multimap.h (multimap::swap, swap): Likewise.
* include/debug/multiset.h (multiset::Swap, swap): Likewise.
* include/debug/set.h (set::swap, swap): Likewise.
* include/debug/unordered_map (unordered_map::swap,
unordered_multimap::swap, swap): Likewise.
* include/debug/unordered_set (unordered_set::swap,
unordered_multiset::swap, swap): Likewise.
* include/debug/vector (vector::swap, swap): Likewise.
* include/ext/alloc_traits.h (__alloc_traits::_S_nothrow_swap()):
Remove.
* include/profile/deque (deque::swap, swap): Use _GLIBCXX_NOEXCEPT_IF.
* include/profile/forward_list (swap): Add noexcept.
* include/profile/list (list::swap, swap) : Use _GLIBCXX_NOEXCEPT_IF.
* include/profile/map.h (map::swap, swap): Likewise.
* include/profile/multimap.h (multimap::swap, swap): Likewise.
* include/profile/multiset.h (multiset::swap, swap): Likewise.
* include/profile/set.h (set::swap, swap): Likewise.
* include/profile/unordered_map (swap): Likewise.
* include/profile/unordered_set (swap): Likewise.
* include/profile/vector (vector::swap, swap): Likewise. Remove
overloads for swapping rvalues.
* testsuite/23_containers/deque/allocator/noexcept.cc: Update tests
for noexcept on swap.
* testsuite/23_containers/forward_list/allocator/noexcept.cc:
Likewise.
* testsuite/23_containers/list/allocator/noexcept.cc: Likewise.
* testsuite/23_containers/map/allocator/noexcept.cc: Likewise.
* testsuite/23_containers/multimap/allocator/noexcept.cc: Likewise.
* testsuite/23_containers/multiset/allocator/noexcept.cc: Likewise.
* testsuite/23_containers/set/allocator/noexcept.cc: Likewise.
* testsuite/23_containers/unordered_map/allocator/noexcept.cc:
Likewise.
* testsuite/23_containers/unordered_multimap/allocator/noexcept.cc:
Likewise.
* testsuite/23_containers/unordered_multiset/allocator/noexcept.cc:
Likewise.
* testsuite/23_containers/unordered_set/allocator/noexcept.cc:
Likewise.
* testsuite/23_containers/vector/allocator/noexcept.cc: Likewise.
* testsuite/23_containers/vector/bool/allocator/noexcept.cc: Likewise.
* testsuite/ext/profile/mutex_extensions_neg.cc: Adjust dg-error line
number.
2015-07-13 John Marino <gnugcc@marino.st>
* config/os/bsd/dragonfly/os_defines.h (_GLIBCXX_USE_C99_CHECK,

2
libstdc++-v3/include/bits/c++config
View File

@ -115,10 +115,12 @@
#ifndef _GLIBCXX_NOEXCEPT
# if __cplusplus >= 201103L
# define _GLIBCXX_NOEXCEPT noexcept
# define _GLIBCXX_NOEXCEPT_IF(_COND) noexcept(_COND)
# define _GLIBCXX_USE_NOEXCEPT noexcept
# define _GLIBCXX_THROW(_EXC)
# else
# define _GLIBCXX_NOEXCEPT
# define _GLIBCXX_NOEXCEPT_IF(_COND)
# define _GLIBCXX_USE_NOEXCEPT throw()
# define _GLIBCXX_THROW(_EXC) throw(_EXC)
# endif

3
libstdc++-v3/include/bits/forward_list.h
View File

@ -992,8 +992,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
* function.
*/
void
swap(forward_list& __list)
noexcept(_Node_alloc_traits::_S_nothrow_swap())
swap(forward_list& __list) noexcept
{
std::swap(this->_M_impl._M_head._M_next,
__list._M_impl._M_head._M_next);

6
libstdc++-v3/include/bits/hashtable.h
View File

@ -475,8 +475,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
void
swap(_Hashtable&)
noexcept(__node_alloc_traits::_S_nothrow_swap()
&& __is_nothrow_swappable<_H1>::value
noexcept(__is_nothrow_swappable<_H1>::value
&& __is_nothrow_swappable<_Equal>::value);
// Basic container operations
@ -1237,8 +1236,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, _Traits>::
swap(_Hashtable& __x)
noexcept(__node_alloc_traits::_S_nothrow_swap()
&& __is_nothrow_swappable<_H1>::value
noexcept(__is_nothrow_swappable<_H1>::value
&& __is_nothrow_swappable<_Equal>::value)
{
// The only base class with member variables is hash_code_base.

5
libstdc++-v3/include/bits/stl_bvector.h
View File

@ -927,10 +927,7 @@ template<typename _Alloc>
}
void
swap(vector& __x)
#if __cplusplus >= 201103L
noexcept(_Bit_alloc_traits::_S_nothrow_swap())
#endif
swap(vector& __x) _GLIBCXX_NOEXCEPT
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);

9
libstdc++-v3/include/bits/stl_deque.h
View File

@ -1777,10 +1777,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
* std::swap(d1,d2) will feed to this function.
*/
void
swap(deque& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap())
#endif
swap(deque& __x) _GLIBCXX_NOEXCEPT
{
_M_impl._M_swap_data(__x._M_impl);
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
@ -2271,9 +2268,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Alloc>
inline void
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
#if __cplusplus >= 201103L
noexcept(noexcept(__x.swap(__y)))
#endif
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
#undef _GLIBCXX_DEQUE_BUF_SIZE

9
libstdc++-v3/include/bits/stl_list.h
View File

@ -1350,10 +1350,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
* function.
*/
void
swap(list& __x)
#if __cplusplus >= 201103L
noexcept(_Node_alloc_traits::_S_nothrow_swap())
#endif
swap(list& __x) _GLIBCXX_NOEXCEPT
{
__detail::_List_node_base::swap(this->_M_impl._M_node,
__x._M_impl._M_node);
@ -1919,9 +1916,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
template<typename _Tp, typename _Alloc>
inline void
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
#if __cplusplus >= 201103L
noexcept(noexcept(__x.swap(__y)))
#endif
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER

9
libstdc++-v3/include/bits/stl_map.h
View File

@ -794,10 +794,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
*/
void
swap(map& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap()
&& __is_nothrow_swappable<_Compare>::value)
#endif
_GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
{ _M_t.swap(__x._M_t); }
/**
@ -1125,9 +1122,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
inline void
swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
map<_Key, _Tp, _Compare, _Alloc>& __y)
#if __cplusplus >= 201103L
noexcept(noexcept(__x.swap(__y)))
#endif
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER

9
libstdc++-v3/include/bits/stl_multimap.h
View File

@ -704,10 +704,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
*/
void
swap(multimap& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap()
&& __is_nothrow_swappable<_Compare>::value)
#endif
_GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
{ _M_t.swap(__x._M_t); }
/**
@ -1026,9 +1023,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
inline void
swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
multimap<_Key, _Tp, _Compare, _Alloc>& __y)
#if __cplusplus >= 201103L
noexcept(noexcept(__x.swap(__y)))
#endif
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER

9
libstdc++-v3/include/bits/stl_multiset.h
View File

@ -406,10 +406,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
*/
void
swap(multiset& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap()
&& __is_nothrow_swappable<_Compare>::value)
#endif
_GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
{ _M_t.swap(__x._M_t); }
// insert/erase
@ -875,9 +872,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
inline void
swap(multiset<_Key, _Compare, _Alloc>& __x,
multiset<_Key, _Compare, _Alloc>& __y)
#if __cplusplus >= 201103L
noexcept(noexcept(__x.swap(__y)))
#endif
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER

9
libstdc++-v3/include/bits/stl_set.h
View File

@ -410,10 +410,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
*/
void
swap(set& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap()
&& __is_nothrow_swappable<_Compare>::value)
#endif
_GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
{ _M_t.swap(__x._M_t); }
// insert/erase
@ -891,9 +888,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Key, typename _Compare, typename _Alloc>
inline void
swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
#if __cplusplus >= 201103L
noexcept(noexcept(__x.swap(__y)))
#endif
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER

13
libstdc++-v3/include/bits/stl_tree.h
View File

@ -920,11 +920,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return _Alloc_traits::max_size(_M_get_Node_allocator()); }
void
#if __cplusplus >= 201103L
swap(_Rb_tree& __t) noexcept(_Alloc_traits::_S_nothrow_swap());
#else
swap(_Rb_tree& __t);
#endif
swap(_Rb_tree& __t)
_GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value);
// Insert/erase.
#if __cplusplus >= 201103L
@ -1747,10 +1744,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Compare, typename _Alloc>
void
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap())
#endif
swap(_Rb_tree& __t)
_GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
{
if (_M_root() == 0)
{

9
libstdc++-v3/include/bits/stl_vector.h
View File

@ -1190,10 +1190,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
* std::swap(v1,v2) will feed to this function.
*/
void
swap(vector& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap())
#endif
swap(vector& __x) _GLIBCXX_NOEXCEPT
{
this->_M_impl._M_swap_data(__x._M_impl);
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
@ -1556,9 +1553,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
#if __cplusplus >= 201103L
noexcept(noexcept(__x.swap(__y)))
#endif
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER

5
libstdc++-v3/include/debug/deque
View File

@ -588,9 +588,7 @@ namespace __debug
void
swap(deque& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -649,6 +647,7 @@ namespace __debug
template<typename _Tp, typename _Alloc>
inline void
swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __debug

6
libstdc++-v3/include/debug/forward_list
View File

@ -473,7 +473,7 @@ namespace __debug
void
swap(forward_list& __list)
noexcept( noexcept(declval<_Base>().swap(__list)) )
noexcept( noexcept(declval<_Base&>().swap(__list)) )
{
_Safe::_M_swap(__list);
_Base::swap(__list);
@ -814,8 +814,8 @@ namespace __debug
/// See std::forward_list::swap().
template<typename _Tp, typename _Alloc>
inline void
swap(forward_list<_Tp, _Alloc>& __lx,
forward_list<_Tp, _Alloc>& __ly)
swap(forward_list<_Tp, _Alloc>& __lx, forward_list<_Tp, _Alloc>& __ly)
noexcept(noexcept(__lx.swap(__ly)))
{ __lx.swap(__ly); }
} // namespace __debug

5
libstdc++-v3/include/debug/list
View File

@ -525,9 +525,7 @@ namespace __debug
void
swap(list& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -808,6 +806,7 @@ namespace __debug
template<typename _Tp, typename _Alloc>
inline void
swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __debug

5
libstdc++-v3/include/debug/map.h
View File

@ -393,9 +393,7 @@ namespace __debug
void
swap(map& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -589,6 +587,7 @@ namespace __debug
inline void
swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs,
map<_Key, _Tp, _Compare, _Allocator>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __debug

5
libstdc++-v3/include/debug/multimap.h
View File

@ -374,9 +374,7 @@ namespace __debug
void
swap(multimap& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -570,6 +568,7 @@ namespace __debug
inline void
swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __debug

5
libstdc++-v3/include/debug/multiset.h
View File

@ -361,9 +361,7 @@ namespace __debug
void
swap(multiset& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -550,6 +548,7 @@ namespace __debug
void
swap(multiset<_Key, _Compare, _Allocator>& __x,
multiset<_Key, _Compare, _Allocator>& __y)
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ return __x.swap(__y); }
} // namespace __debug

5
libstdc++-v3/include/debug/set.h
View File

@ -368,9 +368,7 @@ namespace __debug
void
swap(set& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -557,6 +555,7 @@ namespace __debug
void
swap(set<_Key, _Compare, _Allocator>& __x,
set<_Key, _Compare, _Allocator>& __y)
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ return __x.swap(__y); }
} // namespace __debug

6
libstdc++-v3/include/debug/unordered_map
View File

@ -185,7 +185,7 @@ namespace __debug
void
swap(unordered_map& __x)
noexcept( noexcept(declval<_Base>().swap(__x)) )
noexcept( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -486,6 +486,7 @@ namespace __debug
inline void
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _Key, typename _Tp, typename _Hash,
@ -641,7 +642,7 @@ namespace __debug
void
swap(unordered_multimap& __x)
noexcept( noexcept(declval<_Base>().swap(__x)) )
noexcept( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -938,6 +939,7 @@ namespace __debug
inline void
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _Key, typename _Tp, typename _Hash,

6
libstdc++-v3/include/debug/unordered_set
View File

@ -182,7 +182,7 @@ namespace __debug
void
swap(unordered_set& __x)
noexcept( noexcept(declval<_Base>().swap(__x)) )
noexcept( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -480,6 +480,7 @@ namespace __debug
inline void
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
@ -634,7 +635,7 @@ namespace __debug
void
swap(unordered_multiset& __x)
noexcept( noexcept(declval<_Base>().swap(__x)) )
noexcept( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -920,6 +921,7 @@ namespace __debug
inline void
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>

5
libstdc++-v3/include/debug/vector
View File

@ -674,9 +674,7 @@ namespace __debug
void
swap(vector& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Safe::_M_swap(__x);
_Base::swap(__x);
@ -744,6 +742,7 @@ namespace __debug
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __debug

6
libstdc++-v3/include/ext/alloc_traits.h
View File

@ -112,12 +112,6 @@ template<typename _Alloc>
static constexpr bool _S_nothrow_move()
{ return _S_propagate_on_move_assign() || _S_always_equal(); }
static constexpr bool _S_nothrow_swap()
{
return !_S_propagate_on_swap()
|| std::__is_nothrow_swappable<_Alloc>::value;
}
template<typename _Tp>
struct rebind
{ typedef typename _Base_type::template rebind_alloc<_Tp> other; };

5
libstdc++-v3/include/profile/deque
View File

@ -130,9 +130,7 @@ namespace __profile
void
swap(deque& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{ _Base::swap(__x); }
_Base&
@ -181,6 +179,7 @@ namespace __profile
template<typename _Tp, typename _Alloc>
inline void
swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __profile

3
libstdc++-v3/include/profile/forward_list
View File

@ -108,7 +108,7 @@ namespace __profile
void
swap(forward_list& __fl)
noexcept( noexcept(declval<_Base>().swap(__fl)) )
noexcept( noexcept(declval<_Base&>().swap(__fl)) )
{ _Base::swap(__fl); }
void
@ -208,6 +208,7 @@ namespace __profile
inline void
swap(forward_list<_Tp, _Alloc>& __lx,
forward_list<_Tp, _Alloc>& __ly)
noexcept(noexcept(__lx.swap(__ly)))
{ __lx.swap(__ly); }
} // namespace __profile

5
libstdc++-v3/include/profile/list
View File

@ -411,9 +411,7 @@ namespace __profile
void
swap(list& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Base::swap(__x);
this->_M_swap(__x);
@ -643,6 +641,7 @@ namespace __profile
template<typename _Tp, typename _Alloc>
inline void
swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __profile

5
libstdc++-v3/include/profile/map.h
View File

@ -405,9 +405,7 @@ namespace __profile
void
swap(map& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Base::swap(__x);
this->_M_swap(__x);
@ -698,6 +696,7 @@ namespace __profile
inline void
swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs,
map<_Key, _Tp, _Compare, _Allocator>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __profile

5
libstdc++-v3/include/profile/multimap.h
View File

@ -364,9 +364,7 @@ namespace __profile
void
swap(multimap& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
std::swap(this->_M_map2umap_info, __x._M_map2umap_info);
_Base::swap(__x);
@ -656,6 +654,7 @@ namespace __profile
inline void
swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
} // namespace __profile

5
libstdc++-v3/include/profile/multiset.h
View File

@ -226,9 +226,7 @@ namespace __profile
void
swap(multiset& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Base::swap(__x);
this->_M_swap(__x);
@ -640,6 +638,7 @@ namespace __profile
void
swap(multiset<_Key, _Compare, _Allocator>& __x,
multiset<_Key, _Compare, _Allocator>& __y)
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ return __x.swap(__y); }
} // namespace __profile

5
libstdc++-v3/include/profile/set.h
View File

@ -223,9 +223,7 @@ namespace __profile
void
swap(set& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
{
_Base::swap(__x);
this->_M_swap(__x);
@ -621,6 +619,7 @@ namespace __profile
void
swap(set<_Key, _Compare, _Allocator>& __x,
set<_Key, _Compare, _Allocator>& __y)
_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
{ return __x.swap(__y); }
} // namespace __profile

2
libstdc++-v3/include/profile/unordered_map
View File

@ -299,6 +299,7 @@ namespace __profile
inline void
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _Key, typename _Tp, typename _Hash,
@ -557,6 +558,7 @@ namespace __profile
inline void
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _Key, typename _Tp, typename _Hash,

2
libstdc++-v3/include/profile/unordered_set
View File

@ -279,6 +279,7 @@ namespace __profile
inline void
swap(unordered_set<_Key, _Hash, _Pred, _Alloc>& __x,
unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
@ -534,6 +535,7 @@ namespace __profile
inline void
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>

13
libstdc++-v3/include/profile/vector
View File

@ -547,20 +547,9 @@ namespace __profile
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
#if __cplusplus >= 201103L
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs)
{ __lhs.swap(__rhs); }
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs)
{ __lhs.swap(__rhs); }
#endif
} // namespace __profile
#if __cplusplus >= 201103L

12
libstdc++-v3/testsuite/23_containers/deque/allocator/noexcept.cc
View File

@ -23,15 +23,6 @@
struct T { int i; };
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
using __gnu_test::propagating_allocator;
void test01()
@ -62,6 +53,5 @@ void test03()
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
// static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
// noexcept spec of deque::swap depends on swap overload at top of this file
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}

11
libstdc++-v3/testsuite/23_containers/forward_list/allocator/noexcept.cc
View File

@ -23,15 +23,6 @@
struct T { int i; };
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
using __gnu_test::propagating_allocator;
void test01()
@ -62,5 +53,5 @@ void test03()
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}

11
libstdc++-v3/testsuite/23_containers/list/allocator/noexcept.cc
View File

@ -23,15 +23,6 @@
struct T { int i; };
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
using __gnu_test::propagating_allocator;
void test01()
@ -62,5 +53,5 @@ void test03()
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}

26
libstdc++-v3/testsuite/23_containers/map/allocator/noexcept.cc
View File

@ -27,16 +27,10 @@ bool operator<(T l, T r) { return l.i < r.i; }
using Cmp = std::less<T>;
struct U { };
struct CmpThrow : Cmp { };
void swap(CmpThrow&, CmpThrow&) noexcept(false) { }
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
struct U { };
using __gnu_test::propagating_allocator;
@ -52,6 +46,16 @@ void test01()
}
void test02()
{
typedef std::allocator<std::pair<const T, U>> alloc_type;
typedef std::map<T, U, CmpThrow, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test03()
{
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
@ -61,12 +65,12 @@ void test02()
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test03()
void test04()
{
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}

32
libstdc++-v3/testsuite/23_containers/multimap/allocator/noexcept.cc
View File

@ -27,16 +27,10 @@ bool operator<(T l, T r) { return l.i < r.i; }
using Cmp = std::less<T>;
struct U { };
struct CmpThrow : Cmp { };
void swap(CmpThrow&, CmpThrow&) noexcept(false) { }
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
struct U { };
using __gnu_test::propagating_allocator;
@ -52,6 +46,16 @@ void test01()
}
void test02()
{
typedef std::allocator<std::pair<const T, U>> alloc_type;
typedef std::multimap<T, U, CmpThrow, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test03()
{
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
@ -60,13 +64,3 @@ void test02()
static_assert( !noexcept( v1 = std::move(v2) ), "Move assign can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test03()
{
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}

24
libstdc++-v3/testsuite/23_containers/multiset/allocator/noexcept.cc
View File

@ -28,14 +28,8 @@ bool operator<(T l, T r) { return l.i < r.i; }
using Cmp = std::less<T>;
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
struct CmpThrow : Cmp { };
void swap(CmpThrow&, CmpThrow&) noexcept(false) { }
using __gnu_test::propagating_allocator;
@ -51,6 +45,16 @@ void test01()
}
void test02()
{
typedef std::allocator<T> alloc_type;
typedef std::multiset<T, CmpThrow, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test03()
{
typedef propagating_allocator<T, false> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
@ -60,12 +64,12 @@ void test02()
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test03()
void test04()
{
typedef propagating_allocator<T, true> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}

24
libstdc++-v3/testsuite/23_containers/set/allocator/noexcept.cc
View File

@ -27,14 +27,8 @@ bool operator<(T l, T r) { return l.i < r.i; }
using Cmp = std::less<T>;
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
struct CmpThrow : Cmp { };
void swap(CmpThrow&, CmpThrow&) noexcept(false) { }
using __gnu_test::propagating_allocator;
@ -50,6 +44,16 @@ void test01()
}
void test02()
{
typedef std::allocator<T> alloc_type;
typedef std::set<T, CmpThrow, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test03()
{
typedef propagating_allocator<T, false> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
@ -59,12 +63,12 @@ void test02()
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test03()
void test04()
{
typedef propagating_allocator<T, true> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}

43
libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc
View File

@ -35,14 +35,11 @@ struct equal_to
{ return lhs.i == rhs.i; }
};
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
// Versions of the function objects without nothrow swap.
struct hash_t : hash { };
void swap(hash_t&, hash_t&) noexcept(false) { }
struct equal_to_t : equal_to { };
void swap(equal_to_t&, equal_to_t&) noexcept(false) { }
using __gnu_test::propagating_allocator;
@ -58,6 +55,26 @@ void test01()
}
void test02()
{
typedef std::allocator<T> alloc_type;
typedef std::unordered_map<T, T, hash_t, equal_to, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test03()
{
typedef std::allocator<T> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to_t, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test04()
{
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
@ -67,19 +84,19 @@ void test02()
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test03()
void test05()
{
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test04()
void test06()
{
typedef std::unordered_map<int, int> test_type;
static_assert( noexcept( test_type() ), "Default constructor do not throw" );
static_assert( noexcept( test_type(test_type()) ), "Move constructor do not throw" );
static_assert( noexcept( test_type() ), "Default constructor does not throw" );
static_assert( noexcept( test_type(test_type()) ), "Move constructor does not throw" );
}

44
libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc
View File

@ -35,14 +35,11 @@ struct equal_to
{ return lhs.i == rhs.i; }
};
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
// Versions of the function objects without nothrow swap.
struct hash_t : hash { };
void swap(hash_t&, hash_t&) noexcept(false) { }
struct equal_to_t : equal_to { };
void swap(equal_to_t&, equal_to_t&) noexcept(false) { }
using __gnu_test::propagating_allocator;
@ -58,6 +55,27 @@ void test01()
}
void test02()
{
typedef std::allocator<T> alloc_type;
typedef std::unordered_multimap<T, T, hash_t, equal_to, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test03()
{
typedef std::allocator<T> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to_t, alloc_type>
test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test04()
{
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
@ -67,19 +85,19 @@ void test02()
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test03()
void test05()
{
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test04()
void test06()
{
typedef std::unordered_multimap<int, int> test_type;
static_assert( noexcept( test_type() ), "Default constructor do not throw" );
static_assert( noexcept( test_type(test_type()) ), "Move constructor do not throw" );
static_assert( noexcept( test_type() ), "Default constructor does not throw" );
static_assert( noexcept( test_type(test_type()) ), "Move constructor does not throw" );
}

43
libstdc++-v3/testsuite/23_containers/unordered_multiset/allocator/noexcept.cc
View File

@ -35,14 +35,11 @@ struct equal_to
{ return lhs.i == rhs.i; }
};
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
// Versions of the function objects without nothrow swap.
struct hash_t : hash { };
void swap(hash_t&, hash_t&) noexcept(false) { }
struct equal_to_t : equal_to { };
void swap(equal_to_t&, equal_to_t&) noexcept(false) { }
using __gnu_test::propagating_allocator;
@ -58,6 +55,26 @@ void test01()
}
void test02()
{
typedef std::allocator<T> alloc_type;
typedef std::unordered_multiset<T, hash_t, equal_to, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test03()
{
typedef std::allocator<T> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to_t, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test04()
{
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
@ -67,19 +84,19 @@ void test02()
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test03()
void test05()
{
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test04()
void test06()
{
typedef std::unordered_multiset<int> test_type;
static_assert( noexcept( test_type() ), "Default constructor do not throw" );
static_assert( noexcept( test_type(test_type()) ), "Move constructor do not throw" );
static_assert( noexcept( test_type() ), "Default constructor does not throw" );
static_assert( noexcept( test_type(test_type()) ), "Move constructor does not throw" );
}

43
libstdc++-v3/testsuite/23_containers/unordered_set/allocator/noexcept.cc
View File

@ -35,14 +35,11 @@ struct equal_to
{ return lhs.i == rhs.i; }
};
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
// Versions of the function objects without nothrow swap.
struct hash_t : hash { };
void swap(hash_t&, hash_t&) noexcept(false) { }
struct equal_to_t : equal_to { };
void swap(equal_to_t&, equal_to_t&) noexcept(false) { }
using __gnu_test::propagating_allocator;
@ -58,6 +55,26 @@ void test01()
}
void test02()
{
typedef std::allocator<T> alloc_type;
typedef std::unordered_set<T, hash_t, equal_to, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test03()
{
typedef std::allocator<T> alloc_type;
typedef std::unordered_set<T, hash, equal_to_t, alloc_type> test_type;
test_type v1;
test_type v2;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
void test04()
{
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
@ -67,19 +84,19 @@ void test02()
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test03()
void test05()
{
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}
void test04()
void test06()
{
typedef std::unordered_set<int> test_type;
static_assert( noexcept( test_type() ), "Default constructor do not throw" );
static_assert( noexcept( test_type(test_type()) ), "Move constructor do not throw" );
static_assert( noexcept( test_type() ), "Default constructor does not throw" );
static_assert( noexcept( test_type(test_type()) ), "Move constructor does not throw" );
}

11
libstdc++-v3/testsuite/23_containers/vector/allocator/noexcept.cc
View File

@ -23,15 +23,6 @@
struct T { int i; };
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
using __gnu_test::propagating_allocator;
void test01()
@ -62,5 +53,5 @@ void test03()
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}

11
libstdc++-v3/testsuite/23_containers/vector/bool/allocator/noexcept.cc
View File

@ -23,15 +23,6 @@
using T = bool;
namespace __gnu_test
{
template<typename U>
inline void
swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
noexcept(false)
{ }
}
using __gnu_test::propagating_allocator;
void test01()
@ -62,5 +53,5 @@ void test03()
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
}

2
libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc
View File

@ -25,7 +25,7 @@
#include <vector>
// { dg-error "multiple inlined namespaces" "" { target *-*-* } 322 }
// { dg-error "multiple inlined namespaces" "" { target *-*-* } 324 }
// "template argument 1 is invalid"
// { dg-prune-output "tuple:993" }