Implement erase_if for map and flat_map

Author: igaztanaga

include/boost/container/detail/compare_functors.hpp

@@ -43,6 +43,24 @@ class equal_to_value
    }
 };
 
+template<class ValueType>
+class equal_to_value_first
+{
+   typedef ValueType value_type;
+   const value_type &t_;
+
+   public:
+   inline explicit equal_to_value_first(const value_type &t)
+      :  t_(t)
+   {}
+
+   template <class U>
+   inline bool operator()(const U &t)const
+   {
+      return t_ == t.first;
+   }
+};
+
 template<class Node, class Pred, class Ret = bool>
 struct value_to_node_compare
    :  Pred

include/boost/container/flat_map.hpp

@@ -1717,6 +1717,15 @@ class flat_map
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class M, class C, class A, class Pred>
+inline typename flat_map<K, M, C, A>::size_type erase_if(flat_map<K, M, C, A>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>
@@ -3074,6 +3083,15 @@ class flat_multimap
 #pragma GCC pop_options
 #endif
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class M, class C, class A, class Pred>
+inline typename flat_multimap<K, M, C, A>::size_type erase_if(flat_multimap<K, M, C, A>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>

include/boost/container/map.hpp

@@ -32,6 +32,7 @@
 #include <boost/container/detail/value_init.hpp>
 #include <boost/container/detail/pair.hpp>
 #include <boost/container/detail/pair_key_mapped_of_value.hpp>
+#include <boost/container/detail/algorithm.hpp>
 
 // move
 #include <boost/move/traits.hpp>
@@ -1318,6 +1319,15 @@ class map
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class M, class C, class A, class O, class Pred>
+inline typename map<K, M, C, A, O>::size_type erase_if(map<K, M, C, A, O>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>
@@ -2242,6 +2252,15 @@ class multimap
    #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class M, class C, class A, class O, class Pred>
+inline typename multimap<K, M, C, A, O>::size_type erase_if(multimap<K, M, C, A, O>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>

test/map_test.hpp

@@ -16,6 +16,7 @@
 #include "print_container.hpp"
 #include "movable_int.hpp"
 #include <boost/container/detail/pair.hpp>
+#include <boost/container/detail/compare_functors.hpp>
 #include <boost/move/iterator.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/move/make_unique.hpp>
@@ -647,6 +648,68 @@ int map_test_erase(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boos
       if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
       if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
    }
+
+   {  //erase_if
+      boostmap.clear();
+      boostmultimap.clear();
+      stdmap.clear();
+      stdmultimap.clear();
+
+      {
+         IntPairType aux_vect[(std::size_t)MaxElem];
+         IntPairType aux_vect2[(std::size_t)MaxElem];
+         IntPairType aux_vect3[(std::size_t)MaxElem];
+
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect2[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         boostmap.     insert(boost::make_move_iterator(&aux_vect[0]),  boost::make_move_iterator(&aux_vect[0]  + MaxElem));
+         boostmultimap.insert(boost::make_move_iterator(&aux_vect2[0]), boost::make_move_iterator(&aux_vect2[0] + MaxElem));
+         boostmultimap.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      }
+
+      for(int i = 0; i < MaxElem; ++i){
+         stdmap.insert((StdPairType(i, i)));
+         stdmultimap.insert((StdPairType(i, i)));
+         stdmultimap.insert((StdPairType(i, i)));
+      }
+
+      for(int i = 0; i < MaxElem; ++i) {
+         //erase_if
+         const int key = (i + MaxElem/2) % MaxElem;
+
+         if (1 != erase_if(boostmap, equal_to_value_first<int>(key)))
+            return 1;
+         if (0 != erase_if(boostmap, equal_to_value_first<int>(key)))
+            return 1;
+         stdmap.erase(key);
+         if(!test::CheckEqualContainers(boostmap, stdmap)) return false;
+
+         //erase_if
+         if (2 != erase_if(boostmultimap, equal_to_value_first<int>(key)))
+            return 1;
+         if (0 != erase_if(boostmultimap, equal_to_value_first<int>(key)))
+            return 1;
+         stdmultimap.erase(key);
+         if(!test::CheckEqualContainers(boostmultimap, stdmultimap)) return false;
+      }
+   }
+
    return 0;
 }