procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

PR libstdc++/89477 constrain deduction guides for maps and sets

Browse source 
The Compare, Hash, and Pred template parameters should be constrained in
the C++17 deduction guides for associative and unordered containers.

The deduction guides for stack, queue and priority_queue are already
constrained, but this patch makes them use the _RequireNotAllocator
helper instead of reproducing the logic each time.

	PR libstdc++/89477
	* include/bits/alloc_traits.h (_RequireNotAllocator): New helper for
	container deduction guides.
	* include/bits/hashtable.h (_RequireNotAllocatorOrIntegral): Likewise.
	* include/bits/stl_map.h (map): Use _RequireNotAllocator to constrain
	parameters in deduction guides.
	* include/bits/stl_multimap.h (multimap): Likewise.
	* include/bits/stl_multiset.h (multiset): Likewise.
	* include/bits/stl_queue.h (queue, priority_queue): Likewise.
	* include/bits/stl_set.h (set): Likewise.
	* include/bits/stl_stack.h (stack): Likewise.
	* include/bits/unordered_map.h (unordered_map, unordered_multimap):
	use _RequireNotAllocator and _RequireNotAllocatorOrIntegral to
	constrain parameters in deduction guides.
	* include/bits/unordered_set.h (unordered_set, unordered_multiset):
	Likewise.
	* testsuite/23_containers/map/cons/deduction.cc: Test additional
	deduction cases.
	* testsuite/23_containers/multiset/cons/deduction.cc: Likewise.
	* testsuite/23_containers/set/cons/deduction.cc: Likewise.
	* testsuite/23_containers/unordered_map/cons/deduction.cc: Likewise.
	* testsuite/23_containers/unordered_multimap/cons/deduction.cc:
	Likewise.
	* testsuite/23_containers/unordered_multiset/cons/deduction.cc:
	Likewise.
	* testsuite/23_containers/unordered_set/cons/deduction.cc: Likewise.

From-SVN: r269234
This commit is contained in:
Jonathan Wakely 2019-02-26 23:12:44 +00:00 • committed by Jonathan Wakely
parent 8735903781
commit 08abbddaaa
18 changed files with 511 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
libstdc++-v3/ChangeLog
View file

@ -1,5 +1,32 @@
2019-02-26 Jonathan Wakely <jwakely@redhat.com>
PR libstdc++/89477
* include/bits/alloc_traits.h (_RequireNotAllocator): New helper for
container deduction guides.
* include/bits/hashtable.h (_RequireNotAllocatorOrIntegral): Likewise.
* include/bits/stl_map.h (map): Use _RequireNotAllocator to constrain
parameters in deduction guides.
* include/bits/stl_multimap.h (multimap): Likewise.
* include/bits/stl_multiset.h (multiset): Likewise.
* include/bits/stl_queue.h (queue, priority_queue): Likewise.
* include/bits/stl_set.h (set): Likewise.
* include/bits/stl_stack.h (stack): Likewise.
* include/bits/unordered_map.h (unordered_map, unordered_multimap):
use _RequireNotAllocator and _RequireNotAllocatorOrIntegral to
constrain parameters in deduction guides.
* include/bits/unordered_set.h (unordered_set, unordered_multiset):
Likewise.
* testsuite/23_containers/map/cons/deduction.cc: Test additional
deduction cases.
* testsuite/23_containers/multiset/cons/deduction.cc: Likewise.
* testsuite/23_containers/set/cons/deduction.cc: Likewise.
* testsuite/23_containers/unordered_map/cons/deduction.cc: Likewise.
* testsuite/23_containers/unordered_multimap/cons/deduction.cc:
Likewise.
* testsuite/23_containers/unordered_multiset/cons/deduction.cc:
Likewise.
* testsuite/23_containers/unordered_set/cons/deduction.cc: Likewise.
PR libstdc++/89416
* include/bits/alloc_traits.h (__is_alloc_insertable_impl): Change
to class template and partial specialization using void_t.

4
libstdc++-v3/include/bits/alloc_traits.h
View file

@ -634,6 +634,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using _RequireAllocator
= typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;
template<typename _Alloc>
using _RequireNotAllocator
= typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11

7
libstdc++-v3/include/bits/hashtable.h
View file

@ -2214,6 +2214,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename, typename, typename> class _Hash_merge_helper { };
#endif // C++17
#if __cpp_deduction_guides >= 201606
// Used to constrain deduction guides
template<typename _Hash>
using _RequireNotAllocatorOrIntegral
= __enable_if_t<!__or_<is_integral<_Hash>, __is_allocator<_Hash>>::value>;
#endif
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

2
libstdc++-v3/include/bits/stl_map.h
View file

@ -1411,6 +1411,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typename _Compare = less<__iter_key_t<_InputIterator>>,
typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocator<_Compare>,
typename = _RequireAllocator<_Allocator>>
map(_InputIterator, _InputIterator,
_Compare = _Compare(), _Allocator = _Allocator())
@ -1419,6 +1420,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
typename _Allocator = allocator<pair<const _Key, _Tp>>,
typename = _RequireNotAllocator<_Compare>,
typename = _RequireAllocator<_Allocator>>
map(initializer_list<pair<_Key, _Tp>>,
_Compare = _Compare(), _Allocator = _Allocator())

2
libstdc++-v3/include/bits/stl_multimap.h
View file

@ -1075,6 +1075,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typename _Compare = less<__iter_key_t<_InputIterator>>,
typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocator<_Compare>,
typename = _RequireAllocator<_Allocator>>
multimap(_InputIterator, _InputIterator,
_Compare = _Compare(), _Allocator = _Allocator())
@ -1083,6 +1084,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
typename _Allocator = allocator<pair<const _Key, _Tp>>,
typename = _RequireNotAllocator<_Compare>,
typename = _RequireAllocator<_Allocator>>
multimap(initializer_list<pair<_Key, _Tp>>,
_Compare = _Compare(), _Allocator = _Allocator())

46
libstdc++-v3/include/bits/stl_multiset.h
View file

@ -917,32 +917,34 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typename _Allocator =
allocator<typename iterator_traits<_InputIterator>::value_type>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocator<_Compare>,
typename = _RequireAllocator<_Allocator>>
multiset(_InputIterator, _InputIterator,
_Compare = _Compare(), _Allocator = _Allocator())
-> multiset<typename iterator_traits<_InputIterator>::value_type,
_Compare, _Allocator>;
multiset(_InputIterator, _InputIterator,
_Compare = _Compare(), _Allocator = _Allocator())
-> multiset<typename iterator_traits<_InputIterator>::value_type,
_Compare, _Allocator>;
template<typename _Key,
typename _Compare = less<_Key>,
typename _Allocator = allocator<_Key>,
typename = _RequireAllocator<_Allocator>>
multiset(initializer_list<_Key>,
_Compare = _Compare(), _Allocator = _Allocator())
-> multiset<_Key, _Compare, _Allocator>;
template<typename _Key,
typename _Compare = less<_Key>,
typename _Allocator = allocator<_Key>,
typename = _RequireNotAllocator<_Compare>,
typename = _RequireAllocator<_Allocator>>
multiset(initializer_list<_Key>,
_Compare = _Compare(), _Allocator = _Allocator())
-> multiset<_Key, _Compare, _Allocator>;
template<typename _InputIterator, typename _Allocator,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireAllocator<_Allocator>>
multiset(_InputIterator, _InputIterator, _Allocator)
-> multiset<typename iterator_traits<_InputIterator>::value_type,
less<typename iterator_traits<_InputIterator>::value_type>,
_Allocator>;
template<typename _InputIterator, typename _Allocator,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireAllocator<_Allocator>>
multiset(_InputIterator, _InputIterator, _Allocator)
-> multiset<typename iterator_traits<_InputIterator>::value_type,
less<typename iterator_traits<_InputIterator>::value_type>,
_Allocator>;
template<typename _Key, typename _Allocator,
typename = _RequireAllocator<_Allocator>>
multiset(initializer_list<_Key>, _Allocator)
-> multiset<_Key, less<_Key>, _Allocator>;
template<typename _Key, typename _Allocator,
typename = _RequireAllocator<_Allocator>>
multiset(initializer_list<_Key>, _Allocator)
-> multiset<_Key, less<_Key>, _Allocator>;
#endif

20
libstdc++-v3/include/bits/stl_queue.h
View file

@ -312,12 +312,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __cpp_deduction_guides >= 201606
template<typename _Container,
typename = enable_if_t<!__is_allocator<_Container>::value>>
typename = _RequireNotAllocator<_Container>>
queue(_Container) -> queue<typename _Container::value_type, _Container>;
template<typename _Container, typename _Allocator,
typename = enable_if_t<!__is_allocator<_Container>::value>,
typename = enable_if_t<__is_allocator<_Allocator>::value>>
typename = _RequireNotAllocator<_Container>,
typename = _RequireAllocator<_Allocator>>
queue(_Container, _Allocator)
-> queue<typename _Container::value_type, _Container>;
#endif
@ -687,8 +687,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __cpp_deduction_guides >= 201606
template<typename _Compare, typename _Container,
typename = enable_if_t<!__is_allocator<_Compare>::value>,
typename = enable_if_t<!__is_allocator<_Container>::value>>
typename = _RequireNotAllocator<_Compare>,
typename = _RequireNotAllocator<_Container>>
priority_queue(_Compare, _Container)
-> priority_queue<typename _Container::value_type, _Container, _Compare>;
@ -697,16 +697,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Compare = less<_ValT>,
typename _Container = vector<_ValT>,
typename = _RequireInputIter<_InputIterator>,
typename = enable_if_t<!__is_allocator<_Compare>::value>,
typename = enable_if_t<!__is_allocator<_Container>::value>>
typename = _RequireNotAllocator<_Compare>,
typename = _RequireNotAllocator<_Container>>
priority_queue(_InputIterator, _InputIterator, _Compare = _Compare(),
_Container = _Container())
-> priority_queue<_ValT, _Container, _Compare>;
template<typename _Compare, typename _Container, typename _Allocator,
typename = enable_if_t<!__is_allocator<_Compare>::value>,
typename = enable_if_t<!__is_allocator<_Container>::value>,
typename = enable_if_t<__is_allocator<_Allocator>::value>>
typename = _RequireNotAllocator<_Compare>,
typename = _RequireNotAllocator<_Container>,
typename = _RequireAllocator<_Allocator>>
priority_queue(_Compare, _Container, _Allocator)
-> priority_queue<typename _Container::value_type, _Container, _Compare>;
#endif

2
libstdc++-v3/include/bits/stl_set.h
View file

@ -934,6 +934,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typename _Allocator =
allocator<typename iterator_traits<_InputIterator>::value_type>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocator<_Compare>,
typename = _RequireAllocator<_Allocator>>
set(_InputIterator, _InputIterator,
_Compare = _Compare(), _Allocator = _Allocator())
@ -942,6 +943,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Key, typename _Compare = less<_Key>,
typename _Allocator = allocator<_Key>,
typename = _RequireNotAllocator<_Compare>,
typename = _RequireAllocator<_Allocator>>
set(initializer_list<_Key>,
_Compare = _Compare(), _Allocator = _Allocator())

6
libstdc++-v3/include/bits/stl_stack.h
View file

@ -286,12 +286,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __cpp_deduction_guides >= 201606
template<typename _Container,
typename = enable_if_t<!__is_allocator<_Container>::value>>
typename = _RequireNotAllocator<_Container>>
stack(_Container) -> stack<typename _Container::value_type, _Container>;
template<typename _Container, typename _Allocator,
typename = enable_if_t<!__is_allocator<_Container>::value>,
typename = enable_if_t<__is_allocator<_Allocator>::value>>
typename = _RequireNotAllocator<_Container>,
typename = _RequireAllocator<_Allocator>>
stack(_Container, _Allocator)
-> stack<typename _Container::value_type, _Container>;
#endif

12
libstdc++-v3/include/bits/unordered_map.h
View file

@ -1145,6 +1145,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireNotAllocator<_Pred>,
typename = _RequireAllocator<_Allocator>>
unordered_map(_InputIterator, _InputIterator,
typename unordered_map<int, int>::size_type = {},
@ -1156,6 +1158,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
typename _Pred = equal_to<_Key>,
typename _Allocator = allocator<pair<const _Key, _Tp>>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireNotAllocator<_Pred>,
typename = _RequireAllocator<_Allocator>>
unordered_map(initializer_list<pair<_Key, _Tp>>,
typename unordered_map<int, int>::size_type = {},
@ -1185,6 +1189,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _InputIterator, typename _Hash, typename _Allocator,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireAllocator<_Allocator>>
unordered_map(_InputIterator, _InputIterator,
typename unordered_map<int, int>::size_type,
@ -1206,6 +1211,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
-> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireAllocator<_Allocator>>
unordered_map(initializer_list<pair<_Key, _Tp>>,
typename unordered_map<int, int>::size_type,
@ -1991,6 +1997,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireNotAllocator<_Pred>,
typename = _RequireAllocator<_Allocator>>
unordered_multimap(_InputIterator, _InputIterator,
unordered_multimap<int, int>::size_type = {},
@ -2003,6 +2011,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
typename _Pred = equal_to<_Key>,
typename _Allocator = allocator<pair<const _Key, _Tp>>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireNotAllocator<_Pred>,
typename = _RequireAllocator<_Allocator>>
unordered_multimap(initializer_list<pair<_Key, _Tp>>,
unordered_multimap<int, int>::size_type = {},
@ -2031,6 +2041,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _InputIterator, typename _Hash, typename _Allocator,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireAllocator<_Allocator>>
unordered_multimap(_InputIterator, _InputIterator,
unordered_multimap<int, int>::size_type, _Hash,
@ -2052,6 +2063,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
-> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireAllocator<_Allocator>>
unordered_multimap(initializer_list<pair<_Key, _Tp>>,
unordered_multimap<int, int>::size_type,

24
libstdc++-v3/include/bits/unordered_set.h
View file

@ -820,12 +820,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _InputIterator,
typename _Hash =
hash<typename iterator_traits<_InputIterator>::value_type>,
hash<typename iterator_traits<_InputIterator>::value_type>,
typename _Pred =
equal_to<typename iterator_traits<_InputIterator>::value_type>,
equal_to<typename iterator_traits<_InputIterator>::value_type>,
typename _Allocator =
allocator<typename iterator_traits<_InputIterator>::value_type>,
allocator<typename iterator_traits<_InputIterator>::value_type>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireNotAllocator<_Pred>,
typename = _RequireAllocator<_Allocator>>
unordered_set(_InputIterator, _InputIterator,
unordered_set<int>::size_type = {},
@ -836,6 +838,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Hash = hash<_Tp>,
typename _Pred = equal_to<_Tp>,
typename _Allocator = allocator<_Tp>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireNotAllocator<_Pred>,
typename = _RequireAllocator<_Allocator>>
unordered_set(initializer_list<_Tp>,
unordered_set<int>::size_type = {},
@ -856,6 +860,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _InputIterator, typename _Hash, typename _Allocator,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireAllocator<_Allocator>>
unordered_set(_InputIterator, _InputIterator,
unordered_set<int>::size_type,
@ -873,6 +878,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
-> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
template<typename _Tp, typename _Hash, typename _Allocator,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireAllocator<_Allocator>>
unordered_set(initializer_list<_Tp>,
unordered_set<int>::size_type, _Hash, _Allocator)
@ -1608,12 +1614,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _InputIterator,
typename _Hash =
hash<typename iterator_traits<_InputIterator>::value_type>,
hash<typename iterator_traits<_InputIterator>::value_type>,
typename _Pred =
equal_to<typename iterator_traits<_InputIterator>::value_type>,
equal_to<typename iterator_traits<_InputIterator>::value_type>,
typename _Allocator =
allocator<typename iterator_traits<_InputIterator>::value_type>,
allocator<typename iterator_traits<_InputIterator>::value_type>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireNotAllocator<_Pred>,
typename = _RequireAllocator<_Allocator>>
unordered_multiset(_InputIterator, _InputIterator,
unordered_multiset<int>::size_type = {},
@ -1625,6 +1633,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Hash = hash<_Tp>,
typename _Pred = equal_to<_Tp>,
typename _Allocator = allocator<_Tp>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireNotAllocator<_Pred>,
typename = _RequireAllocator<_Allocator>>
unordered_multiset(initializer_list<_Tp>,
unordered_multiset<int>::size_type = {},
@ -1646,6 +1656,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _InputIterator, typename _Hash, typename _Allocator,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireAllocator<_Allocator>>
unordered_multiset(_InputIterator, _InputIterator,
unordered_multiset<int>::size_type,
@ -1665,6 +1676,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
-> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
template<typename _Tp, typename _Hash, typename _Allocator,
typename = _RequireNotAllocatorOrIntegral<_Hash>,
typename = _RequireAllocator<_Allocator>>
unordered_multiset(initializer_list<_Tp>,
unordered_multiset<int>::size_type, _Hash, _Allocator)

50
libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc
View file

@ -44,6 +44,23 @@ static_assert(std::is_same_v<
decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}, {}}),
std::map<int, double>>);
/* This is not deducible, ambiguous candidates:
* map(initializer_list<value_type>, const Compare&, const _Allocator& = {})
* map(initializer_list<value_type>, const _Allocator&)
* map(initializer_list<pair<Key, T>>, const _Allocator&) -> map
static_assert(std::is_same_v<
decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
*/
static_assert(std::is_same_v<
decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
static_assert(std::is_same_v<
decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}, SimpleAllocator<value_type>{}}),
@ -79,6 +96,17 @@ void f()
{})),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},
@ -121,6 +149,17 @@ void g()
{})),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},
@ -160,6 +199,17 @@ void h()
{})),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},

81
libstdc++-v3/testsuite/23_containers/multiset/cons/deduction.cc
View file

@ -3,8 +3,10 @@
#include <set>
#include <testsuite_allocator.h>
#include <testsuite_iterators.h>
using __gnu_test::SimpleAllocator;
using value_type = std::multiset<int>::value_type;
static_assert(std::is_same_v<
decltype(std::multiset{1, 2, 3}),
@ -15,20 +17,20 @@ static_assert(std::is_same_v<
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{{1, 2, 3},
std::less<int>{}, {}}),
decltype(std::multiset{{1, 2, 3}, std::less<int>{}, {}}),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{{1, 2, 3},
{}}),
decltype(std::multiset{{1, 2, 3}, {}}),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{{1, 2, 3},
{}, SimpleAllocator<int>{}}),
std::multiset<int, std::less<int>,
SimpleAllocator<int>>>);
decltype(std::multiset{{1, 2, 3}, SimpleAllocator<int>{}}),
std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::multiset{{1, 2, 3}, {}, SimpleAllocator<int>{}}),
std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
void f()
{
@ -54,6 +56,16 @@ void f()
{})),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
std::allocator<int>{}}),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
SimpleAllocator<int>{}}),
std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
{},
@ -66,3 +78,56 @@ void f()
SimpleAllocator<int>{}}),
std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
}
using __gnu_test::test_container;
using __gnu_test::input_iterator_wrapper;
void g()
{
value_type array[1];
test_container<value_type, input_iterator_wrapper> x(array);
static_assert(std::is_same_v<
decltype(std::multiset(x.begin(), x.end())),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
std::less<int>{},
std::allocator<value_type>{}}),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
std::less<int>{}, {}}),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset(x.begin(), x.end(),
{})),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
std::allocator<value_type>{}}),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
SimpleAllocator<value_type>{}}),
std::multiset<int, std::less<int>,
SimpleAllocator<value_type>>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
{},
std::allocator<value_type>{}}),
std::multiset<int>>);
static_assert(std::is_same_v<
decltype(std::multiset{x.begin(), x.end(),
{},
SimpleAllocator<value_type>{}}),
std::multiset<int, std::less<int>,
SimpleAllocator<value_type>>>);
}

66
libstdc++-v3/testsuite/23_containers/set/cons/deduction.cc
View file

@ -3,8 +3,10 @@
#include <set>
#include <testsuite_allocator.h>
#include <testsuite_iterators.h>
using __gnu_test::SimpleAllocator;
using value_type = std::set<int>::value_type;
static_assert(std::is_same_v<
decltype(std::set{1, 2, 3}),
@ -24,6 +26,12 @@ static_assert(std::is_same_v<
{}}),
std::set<int>>);
static_assert(std::is_same_v<
decltype(std::set{{1, 2, 3},
SimpleAllocator<int>{}}),
std::set<int, std::less<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::set{{1, 2, 3},
{}, SimpleAllocator<int>{}}),
@ -60,9 +68,67 @@ void f()
std::allocator<int>{}}),
std::set<int>>);
static_assert(std::is_same_v<
decltype(std::set{x.begin(), x.end(),
SimpleAllocator<int>{}}),
std::set<int, std::less<int>, SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::set{x.begin(), x.end(),
{},
SimpleAllocator<int>{}}),
std::set<int, std::less<int>, SimpleAllocator<int>>>);
}
using __gnu_test::test_container;
using __gnu_test::input_iterator_wrapper;
void g()
{
value_type array[1];
test_container<value_type, input_iterator_wrapper> x(array);
static_assert(std::is_same_v<
decltype(std::set(x.begin(), x.end())),
std::set<int>>);
static_assert(std::is_same_v<
decltype(std::set{x.begin(), x.end(),
std::less<int>{},
std::allocator<value_type>{}}),
std::set<int>>);
static_assert(std::is_same_v<
decltype(std::set{x.begin(), x.end(),
std::less<int>{}, {}}),
std::set<int>>);
static_assert(std::is_same_v<
decltype(std::set(x.begin(), x.end(),
{})),
std::set<int>>);
static_assert(std::is_same_v<
decltype(std::set{x.begin(), x.end(),
std::allocator<value_type>{}}),
std::set<int>>);
static_assert(std::is_same_v<
decltype(std::set{x.begin(), x.end(),
SimpleAllocator<value_type>{}}),
std::set<int, std::less<int>,
SimpleAllocator<value_type>>>);
static_assert(std::is_same_v<
decltype(std::set{x.begin(), x.end(),
{},
std::allocator<value_type>{}}),
std::set<int>>);
static_assert(std::is_same_v<
decltype(std::set{x.begin(), x.end(),
{},
SimpleAllocator<value_type>{}}),
std::set<int, std::less<int>,
SimpleAllocator<value_type>>>);
}

41
libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc
View file

@ -16,6 +16,12 @@ static_assert(std::is_same_v<
{2, 3.0}, {3, 4.0}}}),
std::unordered_map<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_map{
{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
1}),
std::unordered_map<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_map{{std::pair{1, 2.0},
{2, 3.0}, {3, 4.0}},
@ -41,6 +47,7 @@ static_assert(std::is_same_v<
void f()
{
std::unordered_map<int, double> x;
static_assert(std::is_same_v<
decltype(std::unordered_map(x.begin(), x.end())),
std::unordered_map<int, double>>);
@ -58,9 +65,41 @@ void f()
static_assert(std::is_same_v<
decltype(std::unordered_map(x.begin(), x.end(),
{})),
{})),
std::unordered_map<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_map{x.begin(), x.end(), 1}),
std::unordered_map<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_map{x.begin(), x.end(),
1,
std::allocator<std::pair<const int, double>>{}}),
std::unordered_map<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_map{x.begin(), x.end(),
1,
SimpleAllocator<std::pair<const int, double>>{}}),
std::unordered_map<int, double, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<std::pair<const int, double>>>>);
static_assert(std::is_same_v<
decltype(std::unordered_map{x.begin(), x.end(),
1, std::hash<int>{},
std::allocator<std::pair<const int, double>>{}}),
std::unordered_map<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_map{x.begin(), x.end(),
1, std::hash<int>{},
SimpleAllocator<std::pair<const int, double>>{}}),
std::unordered_map<int, double, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<std::pair<const int, double>>>>);
static_assert(std::is_same_v<
decltype(std::unordered_map{x.begin(), x.end(),
{}, {}, {},

56
libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc
View file

@ -29,10 +29,25 @@ static_assert(std::is_same_v<
std::unordered_multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap{{std::pair{1, 2.0},
{2, 3.0}, {3, 4.0}},
{}, {}, {},
SimpleAllocator<std::pair<const int, double>>{}}),
decltype(std::unordered_multimap{
{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
1, std::hash<int>{}}),
std::unordered_multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap{
{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
1, std::hash<int>{},
SimpleAllocator<std::pair<const int, double>>{}}),
std::unordered_multimap<int, double, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<std::pair<const int, double>>>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap{
{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}, {}, {},
SimpleAllocator<std::pair<const int, double>>{}}),
std::unordered_multimap<int, double, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<std::pair<const int, double>>>>);
@ -41,6 +56,7 @@ static_assert(std::is_same_v<
void f()
{
std::unordered_multimap<int, double> x;
static_assert(std::is_same_v<
decltype(std::unordered_multimap(x.begin(), x.end())),
std::unordered_multimap<int, double>>);
@ -61,6 +77,38 @@ void f()
{})),
std::unordered_multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap(x.begin(), x.end(), 1)),
std::unordered_multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap{x.begin(), x.end(),
{},
std::allocator<std::pair<const int, double>>{}}),
std::unordered_multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap{x.begin(), x.end(),
{},
SimpleAllocator<std::pair<const int, double>>{}}),
std::unordered_multimap<int, double, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<std::pair<const int, double>>>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap{x.begin(), x.end(),
1, std::hash<int>{},
std::allocator<std::pair<const int, double>>{}}),
std::unordered_multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap{x.begin(), x.end(),
1, std::hash<int>{},
SimpleAllocator<std::pair<const int, double>>{}}),
std::unordered_multimap<int, double, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<std::pair<const int, double>>>>);
static_assert(std::is_same_v<
decltype(std::unordered_multimap{x.begin(), x.end(),
{}, {}, {},

67
libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc
View file

@ -6,10 +6,6 @@
using __gnu_test::SimpleAllocator;
static_assert(std::is_same_v<
decltype(std::unordered_multiset{1, 2, 3}),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{1, 2, 3}),
std::unordered_multiset<int>>);
@ -24,6 +20,35 @@ static_assert(std::is_same_v<
{}}),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{{1, 2, 3},
1}),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{{1, 2, 3},
1, std::allocator<int>{}}),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{{1, 2, 3},
1, SimpleAllocator<int>{}}),
std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{{1, 2, 3},
1, std::hash<int>{}, std::allocator<int>{}}),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{{1, 2, 3},
1, std::hash<int>{}, SimpleAllocator<int>{}}),
std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{{1, 2, 3},
{}, {}, {}, std::allocator<int>{}}),
@ -59,9 +84,41 @@ void f()
static_assert(std::is_same_v<
decltype(std::unordered_multiset(x.begin(), x.end(),
{})),
{})),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{x.begin(), x.end(), 1}),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{x.begin(), x.end(),
1,
std::allocator<int>{}}),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{x.begin(), x.end(),
1,
SimpleAllocator<int>{}}),
std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{x.begin(), x.end(),
1, std::hash<int>{},
std::allocator<int>{}}),
std::unordered_multiset<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{x.begin(), x.end(),
1, std::hash<int>{},
SimpleAllocator<int>{}}),
std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::unordered_multiset{x.begin(), x.end(),
{}, {}, {},

62
libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc
View file

@ -6,10 +6,6 @@
using __gnu_test::SimpleAllocator;
static_assert(std::is_same_v<
decltype(std::unordered_set{1, 2, 3}),
std::unordered_set<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{1, 2, 3}),
std::unordered_set<int>>);
@ -24,6 +20,30 @@ static_assert(std::is_same_v<
{}}),
std::unordered_set<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{{1, 2, 3},
1, std::allocator<int>{}}),
std::unordered_set<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{{1, 2, 3},
1, SimpleAllocator<int>{}}),
std::unordered_set<int, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{{1, 2, 3},
1, std::hash<int>{}, std::allocator<int>{}}),
std::unordered_set<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{{1, 2, 3},
1, std::hash<int>{}, SimpleAllocator<int>{}}),
std::unordered_set<int, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{{1, 2, 3},
{}, {}, {}, std::allocator<int>{}}),
@ -59,9 +79,41 @@ void f()
static_assert(std::is_same_v<
decltype(std::unordered_set(x.begin(), x.end(),
{})),
{})),
std::unordered_set<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{x.begin(), x.end(), 1}),
std::unordered_set<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{x.begin(), x.end(),
1,
std::allocator<int>{}}),
std::unordered_set<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{x.begin(), x.end(),
1,
SimpleAllocator<int>{}}),
std::unordered_set<int, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{x.begin(), x.end(),
1, std::hash<int>{},
std::allocator<int>{}}),
std::unordered_set<int>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{x.begin(), x.end(),
1, std::hash<int>{},
SimpleAllocator<int>{}}),
std::unordered_set<int, std::hash<int>,
std::equal_to<int>,
SimpleAllocator<int>>>);
static_assert(std::is_same_v<
decltype(std::unordered_set{x.begin(), x.end(),
{}, {}, {},