boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-31 20:04:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

Replace uses of boost::enable_if_t in deduction guides with std::enable_if_t

Browse Source
This commit is contained in:
Peter Dimov
2023-10-12 13:13:56 +03:00
parent 8ee48fe909
commit 0e19223e5b
8 changed files with 180 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
include/boost/unordered/concurrent_flat_map.hpp
View File

@@ -772,10 +772,10 @@ namespace boost {
std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >, std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
class Allocator = std::allocator< class Allocator = std::allocator<
boost::unordered::detail::iter_to_alloc_t<InputIterator> >, boost::unordered::detail::iter_to_alloc_t<InputIterator> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_map(InputIterator, InputIterator, concurrent_flat_map(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -788,9 +788,9 @@ namespace boost {
class Hash = boost::hash<std::remove_const_t<Key> >, class Hash = boost::hash<std::remove_const_t<Key> >,
class Pred = std::equal_to<std::remove_const_t<Key> >, class Pred = std::equal_to<std::remove_const_t<Key> >,
class Allocator = std::allocator<std::pair<const Key, T> >, class Allocator = std::allocator<std::pair<const Key, T> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_map(std::initializer_list<std::pair<Key, T> >, concurrent_flat_map(std::initializer_list<std::pair<Key, T> >,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -798,8 +798,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_map(InputIterator, InputIterator, std::size_t, Allocator) concurrent_flat_map(InputIterator, InputIterator, std::size_t, Allocator)
-> concurrent_flat_map< -> concurrent_flat_map<
boost::unordered::detail::iter_key_t<InputIterator>, boost::unordered::detail::iter_key_t<InputIterator>,
@@ -809,8 +809,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_map(InputIterator, InputIterator, Allocator) concurrent_flat_map(InputIterator, InputIterator, Allocator)
-> concurrent_flat_map< -> concurrent_flat_map<
boost::unordered::detail::iter_key_t<InputIterator>, boost::unordered::detail::iter_key_t<InputIterator>,
@@ -820,9 +820,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_map( concurrent_flat_map(
InputIterator, InputIterator, std::size_t, Hash, Allocator) InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> concurrent_flat_map< -> concurrent_flat_map<
@@ -832,22 +832,22 @@ namespace boost {
Allocator>; Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_map(std::initializer_list<std::pair<Key, T> >, std::size_t, concurrent_flat_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
Allocator) -> concurrent_flat_map<std::remove_const_t<Key>, T, Allocator) -> concurrent_flat_map<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_map(std::initializer_list<std::pair<Key, T> >, Allocator) concurrent_flat_map(std::initializer_list<std::pair<Key, T> >, Allocator)
-> concurrent_flat_map<std::remove_const_t<Key>, T, -> concurrent_flat_map<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Hash, class Allocator, template <class Key, class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_map(std::initializer_list<std::pair<Key, T> >, std::size_t, concurrent_flat_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
Hash, Allocator) -> concurrent_flat_map<std::remove_const_t<Key>, T, Hash, Allocator) -> concurrent_flat_map<std::remove_const_t<Key>, T,
Hash, std::equal_to<std::remove_const_t<Key> >, Allocator>; Hash, std::equal_to<std::remove_const_t<Key> >, Allocator>;

36
include/boost/unordered/concurrent_flat_set.hpp
View File

@@ -640,10 +640,10 @@ namespace boost {
std::equal_to<typename std::iterator_traits<InputIterator>::value_type>, std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
class Allocator = std::allocator< class Allocator = std::allocator<
typename std::iterator_traits<InputIterator>::value_type>, typename std::iterator_traits<InputIterator>::value_type>,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_set(InputIterator, InputIterator, concurrent_flat_set(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -653,17 +653,17 @@ namespace boost {
template <class T, class Hash = boost::hash<T>, template <class T, class Hash = boost::hash<T>,
class Pred = std::equal_to<T>, class Allocator = std::allocator<T>, class Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_set(std::initializer_list<T>, concurrent_flat_set(std::initializer_list<T>,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-> concurrent_flat_set< T, Hash, Pred, Allocator>; -> concurrent_flat_set< T, Hash, Pred, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_set(InputIterator, InputIterator, std::size_t, Allocator) concurrent_flat_set(InputIterator, InputIterator, std::size_t, Allocator)
-> concurrent_flat_set< -> concurrent_flat_set<
typename std::iterator_traits<InputIterator>::value_type, typename std::iterator_traits<InputIterator>::value_type,
@@ -672,8 +672,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_set(InputIterator, InputIterator, Allocator) concurrent_flat_set(InputIterator, InputIterator, Allocator)
-> concurrent_flat_set< -> concurrent_flat_set<
typename std::iterator_traits<InputIterator>::value_type, typename std::iterator_traits<InputIterator>::value_type,
@@ -682,9 +682,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_set( concurrent_flat_set(
InputIterator, InputIterator, std::size_t, Hash, Allocator) InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> concurrent_flat_set< -> concurrent_flat_set<
@@ -693,18 +693,18 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_set(std::initializer_list<T>, std::size_t, Allocator) concurrent_flat_set(std::initializer_list<T>, std::size_t, Allocator)
-> concurrent_flat_set<T, boost::hash<T>,std::equal_to<T>, Allocator>; -> concurrent_flat_set<T, boost::hash<T>,std::equal_to<T>, Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_set(std::initializer_list<T >, Allocator) concurrent_flat_set(std::initializer_list<T >, Allocator)
-> concurrent_flat_set<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> concurrent_flat_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
template <class T, class Hash, class Allocator, template <class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
concurrent_flat_set(std::initializer_list<T >, std::size_t,Hash, Allocator) concurrent_flat_set(std::initializer_list<T >, std::size_t,Hash, Allocator)
-> concurrent_flat_set<T, Hash, std::equal_to<T>, Allocator>; -> concurrent_flat_set<T, Hash, std::equal_to<T>, Allocator>;

36
include/boost/unordered/unordered_flat_map.hpp
View File

@@ -717,10 +717,10 @@ namespace boost {
std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >, std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
class Allocator = std::allocator< class Allocator = std::allocator<
boost::unordered::detail::iter_to_alloc_t<InputIterator> >, boost::unordered::detail::iter_to_alloc_t<InputIterator> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_map(InputIterator, InputIterator, unordered_flat_map(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -732,9 +732,9 @@ namespace boost {
class Hash = boost::hash<std::remove_const_t<Key> >, class Hash = boost::hash<std::remove_const_t<Key> >,
class Pred = std::equal_to<std::remove_const_t<Key> >, class Pred = std::equal_to<std::remove_const_t<Key> >,
class Allocator = std::allocator<std::pair<const Key, T> >, class Allocator = std::allocator<std::pair<const Key, T> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_map(std::initializer_list<std::pair<Key, T> >, unordered_flat_map(std::initializer_list<std::pair<Key, T> >,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -742,8 +742,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_map(InputIterator, InputIterator, std::size_t, Allocator) unordered_flat_map(InputIterator, InputIterator, std::size_t, Allocator)
-> unordered_flat_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_flat_map<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, boost::unordered::detail::iter_val_t<InputIterator>,
@@ -752,8 +752,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_map(InputIterator, InputIterator, Allocator) unordered_flat_map(InputIterator, InputIterator, Allocator)
-> unordered_flat_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_flat_map<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, boost::unordered::detail::iter_val_t<InputIterator>,
@@ -762,9 +762,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_map( unordered_flat_map(
InputIterator, InputIterator, std::size_t, Hash, Allocator) InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> unordered_flat_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_flat_map<boost::unordered::detail::iter_key_t<InputIterator>,
@@ -773,22 +773,22 @@ namespace boost {
Allocator>; Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_map(std::initializer_list<std::pair<Key, T> >, std::size_t, unordered_flat_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
Allocator) -> unordered_flat_map<std::remove_const_t<Key>, T, Allocator) -> unordered_flat_map<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_map(std::initializer_list<std::pair<Key, T> >, Allocator) unordered_flat_map(std::initializer_list<std::pair<Key, T> >, Allocator)
-> unordered_flat_map<std::remove_const_t<Key>, T, -> unordered_flat_map<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Hash, class Allocator, template <class Key, class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_map(std::initializer_list<std::pair<Key, T> >, std::size_t, unordered_flat_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
Hash, Allocator) -> unordered_flat_map<std::remove_const_t<Key>, T, Hash, Allocator) -> unordered_flat_map<std::remove_const_t<Key>, T,
Hash, std::equal_to<std::remove_const_t<Key> >, Allocator>; Hash, std::equal_to<std::remove_const_t<Key> >, Allocator>;

36
include/boost/unordered/unordered_flat_set.hpp
View File

@@ -535,10 +535,10 @@ namespace boost {
std::equal_to<typename std::iterator_traits<InputIterator>::value_type>, std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
class Allocator = std::allocator< class Allocator = std::allocator<
typename std::iterator_traits<InputIterator>::value_type>, typename std::iterator_traits<InputIterator>::value_type>,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_set(InputIterator, InputIterator, unordered_flat_set(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -548,17 +548,17 @@ namespace boost {
template <class T, class Hash = boost::hash<T>, template <class T, class Hash = boost::hash<T>,
class Pred = std::equal_to<T>, class Allocator = std::allocator<T>, class Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_set(std::initializer_list<T>, unordered_flat_set(std::initializer_list<T>,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-> unordered_flat_set<T, Hash, Pred, Allocator>; -> unordered_flat_set<T, Hash, Pred, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_set(InputIterator, InputIterator, std::size_t, Allocator) unordered_flat_set(InputIterator, InputIterator, std::size_t, Allocator)
-> unordered_flat_set< -> unordered_flat_set<
typename std::iterator_traits<InputIterator>::value_type, typename std::iterator_traits<InputIterator>::value_type,
@@ -567,9 +567,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_set( unordered_flat_set(
InputIterator, InputIterator, std::size_t, Hash, Allocator) InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> unordered_flat_set< -> unordered_flat_set<
@@ -578,19 +578,19 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_set(std::initializer_list<T>, std::size_t, Allocator) unordered_flat_set(std::initializer_list<T>, std::size_t, Allocator)
-> unordered_flat_set<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> unordered_flat_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
template <class T, class Hash, class Allocator, template <class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_set(std::initializer_list<T>, std::size_t, Hash, Allocator) unordered_flat_set(std::initializer_list<T>, std::size_t, Hash, Allocator)
-> unordered_flat_set<T, Hash, std::equal_to<T>, Allocator>; -> unordered_flat_set<T, Hash, std::equal_to<T>, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_set(InputIterator, InputIterator, Allocator) unordered_flat_set(InputIterator, InputIterator, Allocator)
-> unordered_flat_set< -> unordered_flat_set<
typename std::iterator_traits<InputIterator>::value_type, typename std::iterator_traits<InputIterator>::value_type,
@@ -599,7 +599,7 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_flat_set(std::initializer_list<T>, Allocator) unordered_flat_set(std::initializer_list<T>, Allocator)
-> unordered_flat_set<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> unordered_flat_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
#endif #endif

72
include/boost/unordered/unordered_map.hpp
View File

@@ -605,10 +605,10 @@ namespace boost {
std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >, std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
class Allocator = std::allocator< class Allocator = std::allocator<
boost::unordered::detail::iter_to_alloc_t<InputIterator> >, boost::unordered::detail::iter_to_alloc_t<InputIterator> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_map(InputIterator, InputIterator, unordered_map(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::default_bucket_count, std::size_t = boost::unordered::detail::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -620,17 +620,17 @@ namespace boost {
class Hash = boost::hash<std::remove_const_t<Key> >, class Hash = boost::hash<std::remove_const_t<Key> >,
class Pred = std::equal_to<std::remove_const_t<Key> >, class Pred = std::equal_to<std::remove_const_t<Key> >,
class Allocator = std::allocator<std::pair<const Key, T> >, class Allocator = std::allocator<std::pair<const Key, T> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_map(std::initializer_list<std::pair<Key, T> >, unordered_map(std::initializer_list<std::pair<Key, T> >,
std::size_t = boost::unordered::detail::default_bucket_count, std::size_t = boost::unordered::detail::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-> unordered_map<std::remove_const_t<Key>, T, Hash, Pred, Allocator>; -> unordered_map<std::remove_const_t<Key>, T, Hash, Pred, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_map(InputIterator, InputIterator, std::size_t, Allocator) unordered_map(InputIterator, InputIterator, std::size_t, Allocator)
-> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, boost::unordered::detail::iter_val_t<InputIterator>,
@@ -639,8 +639,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_map(InputIterator, InputIterator, Allocator) unordered_map(InputIterator, InputIterator, Allocator)
-> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, boost::unordered::detail::iter_val_t<InputIterator>,
@@ -649,9 +649,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_map(InputIterator, InputIterator, std::size_t, Hash, Allocator) unordered_map(InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, Hash, boost::unordered::detail::iter_val_t<InputIterator>, Hash,
@@ -659,22 +659,22 @@ namespace boost {
Allocator>; Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_map(std::initializer_list<std::pair<Key, T> >, std::size_t, unordered_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
Allocator) -> unordered_map<std::remove_const_t<Key>, T, Allocator) -> unordered_map<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_map(std::initializer_list<std::pair<Key, T> >, Allocator) unordered_map(std::initializer_list<std::pair<Key, T> >, Allocator)
-> unordered_map<std::remove_const_t<Key>, T, -> unordered_map<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Hash, class Allocator, template <class Key, class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_map(std::initializer_list<std::pair<Key, T> >, std::size_t, Hash, unordered_map(std::initializer_list<std::pair<Key, T> >, std::size_t, Hash,
Allocator) -> unordered_map<std::remove_const_t<Key>, T, Hash, Allocator) -> unordered_map<std::remove_const_t<Key>, T, Hash,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
@@ -1124,10 +1124,10 @@ namespace boost {
std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >, std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
class Allocator = std::allocator< class Allocator = std::allocator<
boost::unordered::detail::iter_to_alloc_t<InputIterator> >, boost::unordered::detail::iter_to_alloc_t<InputIterator> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multimap(InputIterator, InputIterator, unordered_multimap(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::default_bucket_count, std::size_t = boost::unordered::detail::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -1139,17 +1139,17 @@ namespace boost {
class Hash = boost::hash<std::remove_const_t<Key> >, class Hash = boost::hash<std::remove_const_t<Key> >,
class Pred = std::equal_to<std::remove_const_t<Key> >, class Pred = std::equal_to<std::remove_const_t<Key> >,
class Allocator = std::allocator<std::pair<const Key, T> >, class Allocator = std::allocator<std::pair<const Key, T> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multimap(std::initializer_list<std::pair<Key, T> >, unordered_multimap(std::initializer_list<std::pair<Key, T> >,
std::size_t = boost::unordered::detail::default_bucket_count, std::size_t = boost::unordered::detail::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-> unordered_multimap<std::remove_const_t<Key>, T, Hash, Pred, Allocator>; -> unordered_multimap<std::remove_const_t<Key>, T, Hash, Pred, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multimap(InputIterator, InputIterator, std::size_t, Allocator) unordered_multimap(InputIterator, InputIterator, std::size_t, Allocator)
-> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, boost::unordered::detail::iter_val_t<InputIterator>,
@@ -1158,8 +1158,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multimap(InputIterator, InputIterator, Allocator) unordered_multimap(InputIterator, InputIterator, Allocator)
-> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, boost::unordered::detail::iter_val_t<InputIterator>,
@@ -1168,9 +1168,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multimap( unordered_multimap(
InputIterator, InputIterator, std::size_t, Hash, Allocator) InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
@@ -1179,22 +1179,22 @@ namespace boost {
Allocator>; Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multimap(std::initializer_list<std::pair<Key, T> >, std::size_t, unordered_multimap(std::initializer_list<std::pair<Key, T> >, std::size_t,
Allocator) -> unordered_multimap<std::remove_const_t<Key>, T, Allocator) -> unordered_multimap<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multimap(std::initializer_list<std::pair<Key, T> >, Allocator) unordered_multimap(std::initializer_list<std::pair<Key, T> >, Allocator)
-> unordered_multimap<std::remove_const_t<Key>, T, -> unordered_multimap<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Hash, class Allocator, template <class Key, class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multimap(std::initializer_list<std::pair<Key, T> >, std::size_t, unordered_multimap(std::initializer_list<std::pair<Key, T> >, std::size_t,
Hash, Allocator) -> unordered_multimap<std::remove_const_t<Key>, T, Hash, Hash, Allocator) -> unordered_multimap<std::remove_const_t<Key>, T, Hash,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;

36
include/boost/unordered/unordered_node_map.hpp
View File

@@ -810,10 +810,10 @@ namespace boost {
std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >, std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
class Allocator = std::allocator< class Allocator = std::allocator<
boost::unordered::detail::iter_to_alloc_t<InputIterator> >, boost::unordered::detail::iter_to_alloc_t<InputIterator> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_map(InputIterator, InputIterator, unordered_node_map(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -825,9 +825,9 @@ namespace boost {
class Hash = boost::hash<std::remove_const_t<Key> >, class Hash = boost::hash<std::remove_const_t<Key> >,
class Pred = std::equal_to<std::remove_const_t<Key> >, class Pred = std::equal_to<std::remove_const_t<Key> >,
class Allocator = std::allocator<std::pair<const Key, T> >, class Allocator = std::allocator<std::pair<const Key, T> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_map(std::initializer_list<std::pair<Key, T> >, unordered_node_map(std::initializer_list<std::pair<Key, T> >,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -835,8 +835,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_map(InputIterator, InputIterator, std::size_t, Allocator) unordered_node_map(InputIterator, InputIterator, std::size_t, Allocator)
-> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, boost::unordered::detail::iter_val_t<InputIterator>,
@@ -845,8 +845,8 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_map(InputIterator, InputIterator, Allocator) unordered_node_map(InputIterator, InputIterator, Allocator)
-> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>,
boost::unordered::detail::iter_val_t<InputIterator>, boost::unordered::detail::iter_val_t<InputIterator>,
@@ -855,9 +855,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_map( unordered_node_map(
InputIterator, InputIterator, std::size_t, Hash, Allocator) InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>, -> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>,
@@ -866,22 +866,22 @@ namespace boost {
Allocator>; Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_map(std::initializer_list<std::pair<Key, T> >, std::size_t, unordered_node_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
Allocator) -> unordered_node_map<std::remove_const_t<Key>, T, Allocator) -> unordered_node_map<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Allocator, template <class Key, class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_map(std::initializer_list<std::pair<Key, T> >, Allocator) unordered_node_map(std::initializer_list<std::pair<Key, T> >, Allocator)
-> unordered_node_map<std::remove_const_t<Key>, T, -> unordered_node_map<std::remove_const_t<Key>, T,
boost::hash<std::remove_const_t<Key> >, boost::hash<std::remove_const_t<Key> >,
std::equal_to<std::remove_const_t<Key> >, Allocator>; std::equal_to<std::remove_const_t<Key> >, Allocator>;
template <class Key, class T, class Hash, class Allocator, template <class Key, class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_map(std::initializer_list<std::pair<Key, T> >, std::size_t, unordered_node_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
Hash, Allocator) -> unordered_node_map<std::remove_const_t<Key>, T, Hash, Allocator) -> unordered_node_map<std::remove_const_t<Key>, T,
Hash, std::equal_to<std::remove_const_t<Key> >, Allocator>; Hash, std::equal_to<std::remove_const_t<Key> >, Allocator>;

36
include/boost/unordered/unordered_node_set.hpp
View File

@@ -622,10 +622,10 @@ namespace boost {
std::equal_to<typename std::iterator_traits<InputIterator>::value_type>, std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
class Allocator = std::allocator< class Allocator = std::allocator<
typename std::iterator_traits<InputIterator>::value_type>, typename std::iterator_traits<InputIterator>::value_type>,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_set(InputIterator, InputIterator, unordered_node_set(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -635,17 +635,17 @@ namespace boost {
template <class T, class Hash = boost::hash<T>, template <class T, class Hash = boost::hash<T>,
class Pred = std::equal_to<T>, class Allocator = std::allocator<T>, class Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_set(std::initializer_list<T>, unordered_node_set(std::initializer_list<T>,
std::size_t = boost::unordered::detail::foa::default_bucket_count, std::size_t = boost::unordered::detail::foa::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-> unordered_node_set<T, Hash, Pred, Allocator>; -> unordered_node_set<T, Hash, Pred, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_set(InputIterator, InputIterator, std::size_t, Allocator) unordered_node_set(InputIterator, InputIterator, std::size_t, Allocator)
-> unordered_node_set< -> unordered_node_set<
typename std::iterator_traits<InputIterator>::value_type, typename std::iterator_traits<InputIterator>::value_type,
@@ -654,9 +654,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_set( unordered_node_set(
InputIterator, InputIterator, std::size_t, Hash, Allocator) InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> unordered_node_set< -> unordered_node_set<
@@ -665,19 +665,19 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_set(std::initializer_list<T>, std::size_t, Allocator) unordered_node_set(std::initializer_list<T>, std::size_t, Allocator)
-> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
template <class T, class Hash, class Allocator, template <class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_set(std::initializer_list<T>, std::size_t, Hash, Allocator) unordered_node_set(std::initializer_list<T>, std::size_t, Hash, Allocator)
-> unordered_node_set<T, Hash, std::equal_to<T>, Allocator>; -> unordered_node_set<T, Hash, std::equal_to<T>, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_set(InputIterator, InputIterator, Allocator) unordered_node_set(InputIterator, InputIterator, Allocator)
-> unordered_node_set< -> unordered_node_set<
typename std::iterator_traits<InputIterator>::value_type, typename std::iterator_traits<InputIterator>::value_type,
@@ -686,7 +686,7 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_node_set(std::initializer_list<T>, Allocator) unordered_node_set(std::initializer_list<T>, Allocator)
-> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
#endif #endif

72
include/boost/unordered/unordered_set.hpp
View File

@@ -462,10 +462,10 @@ namespace boost {
std::equal_to<typename std::iterator_traits<InputIterator>::value_type>, std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
class Allocator = std::allocator< class Allocator = std::allocator<
typename std::iterator_traits<InputIterator>::value_type>, typename std::iterator_traits<InputIterator>::value_type>,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_set(InputIterator, InputIterator, unordered_set(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::default_bucket_count, std::size_t = boost::unordered::detail::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -474,17 +474,17 @@ namespace boost {
template <class T, class Hash = boost::hash<T>, template <class T, class Hash = boost::hash<T>,
class Pred = std::equal_to<T>, class Allocator = std::allocator<T>, class Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_set(std::initializer_list<T>, unordered_set(std::initializer_list<T>,
std::size_t = boost::unordered::detail::default_bucket_count, std::size_t = boost::unordered::detail::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-> unordered_set<T, Hash, Pred, Allocator>; -> unordered_set<T, Hash, Pred, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_set(InputIterator, InputIterator, std::size_t, Allocator) unordered_set(InputIterator, InputIterator, std::size_t, Allocator)
-> unordered_set<typename std::iterator_traits<InputIterator>::value_type, -> unordered_set<typename std::iterator_traits<InputIterator>::value_type,
boost::hash<typename std::iterator_traits<InputIterator>::value_type>, boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
@@ -492,9 +492,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_set(InputIterator, InputIterator, std::size_t, Hash, Allocator) unordered_set(InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> unordered_set<typename std::iterator_traits<InputIterator>::value_type, -> unordered_set<typename std::iterator_traits<InputIterator>::value_type,
Hash, Hash,
@@ -502,19 +502,19 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_set(std::initializer_list<T>, std::size_t, Allocator) unordered_set(std::initializer_list<T>, std::size_t, Allocator)
-> unordered_set<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> unordered_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
template <class T, class Hash, class Allocator, template <class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_set(std::initializer_list<T>, std::size_t, Hash, Allocator) unordered_set(std::initializer_list<T>, std::size_t, Hash, Allocator)
-> unordered_set<T, Hash, std::equal_to<T>, Allocator>; -> unordered_set<T, Hash, std::equal_to<T>, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_set(InputIterator, InputIterator, Allocator) unordered_set(InputIterator, InputIterator, Allocator)
-> unordered_set<typename std::iterator_traits<InputIterator>::value_type, -> unordered_set<typename std::iterator_traits<InputIterator>::value_type,
boost::hash<typename std::iterator_traits<InputIterator>::value_type>, boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
@@ -522,7 +522,7 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_set(std::initializer_list<T>, Allocator) unordered_set(std::initializer_list<T>, Allocator)
-> unordered_set<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> unordered_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
@@ -925,10 +925,10 @@ namespace boost {
std::equal_to<typename std::iterator_traits<InputIterator>::value_type>, std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
class Allocator = std::allocator< class Allocator = std::allocator<
typename std::iterator_traits<InputIterator>::value_type>, typename std::iterator_traits<InputIterator>::value_type>,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multiset(InputIterator, InputIterator, unordered_multiset(InputIterator, InputIterator,
std::size_t = boost::unordered::detail::default_bucket_count, std::size_t = boost::unordered::detail::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
@@ -938,17 +938,17 @@ namespace boost {
template <class T, class Hash = boost::hash<T>, template <class T, class Hash = boost::hash<T>,
class Pred = std::equal_to<T>, class Allocator = std::allocator<T>, class Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_pred_v<Pred> >, class = std::enable_if_t<detail::is_pred_v<Pred> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multiset(std::initializer_list<T>, unordered_multiset(std::initializer_list<T>,
std::size_t = boost::unordered::detail::default_bucket_count, std::size_t = boost::unordered::detail::default_bucket_count,
Hash = Hash(), Pred = Pred(), Allocator = Allocator()) Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-> unordered_multiset<T, Hash, Pred, Allocator>; -> unordered_multiset<T, Hash, Pred, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multiset(InputIterator, InputIterator, std::size_t, Allocator) unordered_multiset(InputIterator, InputIterator, std::size_t, Allocator)
-> unordered_multiset< -> unordered_multiset<
typename std::iterator_traits<InputIterator>::value_type, typename std::iterator_traits<InputIterator>::value_type,
@@ -957,9 +957,9 @@ namespace boost {
Allocator>; Allocator>;
template <class InputIterator, class Hash, class Allocator, template <class InputIterator, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multiset( unordered_multiset(
InputIterator, InputIterator, std::size_t, Hash, Allocator) InputIterator, InputIterator, std::size_t, Hash, Allocator)
-> unordered_multiset< -> unordered_multiset<
@@ -968,19 +968,19 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multiset(std::initializer_list<T>, std::size_t, Allocator) unordered_multiset(std::initializer_list<T>, std::size_t, Allocator)
-> unordered_multiset<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> unordered_multiset<T, boost::hash<T>, std::equal_to<T>, Allocator>;
template <class T, class Hash, class Allocator, template <class T, class Hash, class Allocator,
class = boost::enable_if_t<detail::is_hash_v<Hash> >, class = std::enable_if_t<detail::is_hash_v<Hash> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multiset(std::initializer_list<T>, std::size_t, Hash, Allocator) unordered_multiset(std::initializer_list<T>, std::size_t, Hash, Allocator)
-> unordered_multiset<T, Hash, std::equal_to<T>, Allocator>; -> unordered_multiset<T, Hash, std::equal_to<T>, Allocator>;
template <class InputIterator, class Allocator, template <class InputIterator, class Allocator,
class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >, class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multiset(InputIterator, InputIterator, Allocator) unordered_multiset(InputIterator, InputIterator, Allocator)
-> unordered_multiset< -> unordered_multiset<
typename std::iterator_traits<InputIterator>::value_type, typename std::iterator_traits<InputIterator>::value_type,
@@ -989,7 +989,7 @@ namespace boost {
Allocator>; Allocator>;
template <class T, class Allocator, template <class T, class Allocator,
class = boost::enable_if_t<detail::is_allocator_v<Allocator> > > class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
unordered_multiset(std::initializer_list<T>, Allocator) unordered_multiset(std::initializer_list<T>, Allocator)
-> unordered_multiset<T, boost::hash<T>, std::equal_to<T>, Allocator>; -> unordered_multiset<T, boost::hash<T>, std::equal_to<T>, Allocator>;