From c322cc56217af40500140eb46ff79f3b28b2fcea Mon Sep 17 00:00:00 2001
From: Christian Mazakas <christian.mazakas@gmail.com>
Date: Tue, 22 Feb 2022 15:14:14 -0800
Subject: [PATCH] Implement `erase_if()` for Unordered via function template in
 `detail` namespace

---
 .../boost/unordered/detail/implementation.hpp | 19 +++++++++++++++++++
 include/boost/unordered/unordered_map.hpp     | 14 ++++++++++++++
 include/boost/unordered/unordered_map_fwd.hpp |  8 ++++++++
 include/boost/unordered/unordered_set.hpp     | 14 ++++++++++++++
 include/boost/unordered/unordered_set_fwd.hpp |  8 ++++++++
 5 files changed, 63 insertions(+)

diff --git a/include/boost/unordered/detail/implementation.hpp b/include/boost/unordered/detail/implementation.hpp
index 02ae8fc2..668a5984 100644
--- a/include/boost/unordered/detail/implementation.hpp
+++ b/include/boost/unordered/detail/implementation.hpp
@@ -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());
+      }
     }
   }
 }
diff --git a/include/boost/unordered/unordered_map.hpp b/include/boost/unordered/unordered_map.hpp
index a7815d87..d5b75cd0 100644
--- a/include/boost/unordered/unordered_map.hpp
+++ b/include/boost/unordered/unordered_map.hpp
@@ -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)
diff --git a/include/boost/unordered/unordered_map_fwd.hpp b/include/boost/unordered/unordered_map_fwd.hpp
index 794b7042..4f45841b 100644
--- a/include/boost/unordered/unordered_map_fwd.hpp
+++ b/include/boost/unordered/unordered_map_fwd.hpp
@@ -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;
   }
diff --git a/include/boost/unordered/unordered_set.hpp b/include/boost/unordered/unordered_set.hpp
index 57133eda..ab096b04 100644
--- a/include/boost/unordered/unordered_set.hpp
+++ b/include/boost/unordered/unordered_set.hpp
@@ -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)
diff --git a/include/boost/unordered/unordered_set_fwd.hpp b/include/boost/unordered/unordered_set_fwd.hpp
index 35e2820f..10a29ac6 100644
--- a/include/boost/unordered/unordered_set_fwd.hpp
+++ b/include/boost/unordered/unordered_set_fwd.hpp
@@ -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;
   }