boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-30 03:17:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Implement erase_if() for Unordered via function template in detail namespace

Browse Source
This commit is contained in:
Christian Mazakas
2022-02-22 15:14:14 -08:00
parent d943283f80
commit c322cc5621
5 changed files with 63 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
include/boost/unordered/detail/implementation.hpp
View File

@ -4360,6 +4360,25 @@ namespace boost {
typedef typename pick::bucket bucket;
typedef typename pick::link_pointer link_pointer;
};
template <class Container, class Predicate>
typename Container::size_type erase_if(Container& c, Predicate& pred)
{
typedef typename Container::size_type size_type;
typedef typename Container::iterator iterator;
size_type const size = c.size();
for (iterator pos = c.begin(), end = c.end(); pos != end;) {
if (pred(*pos)) {
pos = c.erase(pos);
} else {
++pos;
}
}
return (size - c.size());
}
}
}
}

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

@ -2168,6 +2168,13 @@ namespace boost {
m1.swap(m2);
}
template <class K, class T, class H, class P, class A, class Predicate>
typename unordered_map<K, T, H, P, A>::size_type erase_if(
unordered_map<K, T, H, P, A>& c, Predicate pred)
{
return detail::erase_if(c, pred);
}
////////////////////////////////////////////////////////////////////////////
template <class K, class T, class H, class P, class A>
@ -2613,6 +2620,13 @@ namespace boost {
m1.swap(m2);
}
template <class K, class T, class H, class P, class A, class Predicate>
typename unordered_multimap<K, T, H, P, A>::size_type erase_if(
unordered_multimap<K, T, H, P, A>& c, Predicate pred)
{
return detail::erase_if(c, pred);
}
template <typename N, class K, class T, class A> class node_handle_map
{
BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_map)

8
include/boost/unordered/unordered_map_fwd.hpp
View File

@ -34,6 +34,10 @@ namespace boost {
unordered_map<K, T, H, P, A>& m1, unordered_map<K, T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
template <class K, class T, class H, class P, class A, class Predicate>
typename unordered_map<K, T, H, P, A>::size_type erase_if(
unordered_map<K, T, H, P, A>& c, Predicate pred);
template <class K, class T, class H = boost::hash<K>,
class P = std::equal_to<K>,
class A = std::allocator<std::pair<const K, T> > >
@ -50,6 +54,10 @@ namespace boost {
unordered_multimap<K, T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
template <class K, class T, class H, class P, class A, class Predicate>
typename unordered_multimap<K, T, H, P, A>::size_type erase_if(
unordered_multimap<K, T, H, P, A>& c, Predicate pred);
template <class N, class K, class T, class A> class node_handle_map;
template <class N, class K, class T, class A> struct insert_return_type_map;
}

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

@ -1676,6 +1676,13 @@ namespace boost {
m1.swap(m2);
}
template <class K, class H, class P, class A, class Predicate>
typename unordered_set<K, H, P, A>::size_type erase_if(
unordered_set<K, H, P, A>& c, Predicate pred)
{
return detail::erase_if(c, pred);
}
////////////////////////////////////////////////////////////////////////////
template <class T, class H, class P, class A>
@ -2079,6 +2086,13 @@ namespace boost {
m1.swap(m2);
}
template <class K, class H, class P, class A, class Predicate>
typename unordered_multiset<K, H, P, A>::size_type erase_if(
unordered_multiset<K, H, P, A>& c, Predicate pred)
{
return detail::erase_if(c, pred);
}
template <typename N, typename T, typename A> class node_handle_set
{
BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_set)

8
include/boost/unordered/unordered_set_fwd.hpp
View File

@ -33,6 +33,10 @@ namespace boost {
unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
template <class K, class H, class P, class A, class Predicate>
typename unordered_set<K, H, P, A>::size_type erase_if(
unordered_set<K, H, P, A>& c, Predicate pred);
template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
class A = std::allocator<T> >
class unordered_multiset;
@ -48,6 +52,10 @@ namespace boost {
unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
template <class K, class H, class P, class A, class Predicate>
typename unordered_multiset<K, H, P, A>::size_type erase_if(
unordered_multiset<K, H, P, A>& c, Predicate pred);
template <class N, class T, class A> class node_handle_set;
template <class N, class T, class A> struct insert_return_type_set;
}