Pre-emptively support P0646R1 for std container erasure.

2018-11-30  Edward Smith-Rowland  <3dw4rd@verizon.net>

	Pre-emptively support P0646R1 for std container erasure.
	* include/bits/erase_if.h: Accumulate and return number of erased nodes.
	* include/std/forward_list (): Return number of erased items.
	* include/std/list (): Ditto.
	* include/std/map (): Ditto.
	* include/std/set (): Ditto.
	* include/std/string (): Ditto.
	* include/std/unordered_map (): Ditto.
	* include/std/unordered_set (): Ditto.
	* include/std/vector (): Ditto.
	* testsuite/21_strings/basic_string/erasure.cc: Test number of erasures.
	* testsuite/23_containers/deque/erasure.cc: Ditto.
	* testsuite/23_containers/forward_list/erasure.cc: Ditto.
	* testsuite/23_containers/list/erasure.cc: Ditto.
	* testsuite/23_containers/map/erasure.cc: Ditto.
	* testsuite/23_containers/set/erasure.cc: Ditto.
	* testsuite/23_containers/unordered_map/erasure.cc: Ditto.
	* testsuite/23_containers/unordered_set/erasure.cc: Ditto.
	* testsuite/23_containers/vector/erasure.cc: Ditto.

From-SVN: r266672

libstdc++-v3/ChangeLog

@@ -1,3 +1,25 @@
+2018-11-30  Edward Smith-Rowland  <3dw4rd@verizon.net>
+
+	Pre-emptively support P0646R1 for std container erasure.
+	* include/bits/erase_if.h: Accumulate and return number of erased nodes.
+	* include/std/forward_list (): Return number of erased items.
+	* include/std/list (): Ditto.
+	* include/std/map (): Ditto.
+	* include/std/set (): Ditto.
+	* include/std/string (): Ditto.
+	* include/std/unordered_map (): Ditto.
+	* include/std/unordered_set (): Ditto.
+	* include/std/vector (): Ditto.
+	* testsuite/21_strings/basic_string/erasure.cc: Test number of erasures.
+	* testsuite/23_containers/deque/erasure.cc: Ditto.
+	* testsuite/23_containers/forward_list/erasure.cc: Ditto.
+	* testsuite/23_containers/list/erasure.cc: Ditto.
+	* testsuite/23_containers/map/erasure.cc: Ditto.
+	* testsuite/23_containers/set/erasure.cc: Ditto.
+	* testsuite/23_containers/unordered_map/erasure.cc: Ditto.
+	* testsuite/23_containers/unordered_set/erasure.cc: Ditto.
+	* testsuite/23_containers/vector/erasure.cc: Ditto.
+
 2018-11-29  Edward Smith-Rowland  <3dw4rd@verizon.net>
 
 	Only include bits/stl_algo.h for C++20.

libstdc++-v3/include/bits/erase_if.h

@@ -41,17 +41,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   namespace __detail
   {
     template<typename _Container, typename _Predicate>
-      void
+      typename _Container::size_type
       __erase_nodes_if(_Container& __cont, _Predicate __pred)
       {
+	typename _Container::size_type __num = 0;
 	for (auto __iter = __cont.begin(), __last = __cont.end();
 	     __iter != __last;)
-	{
+	  {
-	  if (__pred(*__iter))
+	    if (__pred(*__iter))
-	    __iter = __cont.erase(__iter);
+	      {
-	  else
+		__iter = __cont.erase(__iter);
-	    ++__iter;
+		++__num;
-	}
+	      }
+	    else
+	      ++__iter;
+	  }
+	return __num;
       }
   } // namespace __detail
 

libstdc++-v3/include/std/forward_list

@@ -66,16 +66,17 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp, typename _Alloc, typename _Predicate>
-    inline void 
+    inline typename forward_list<_Tp, _Alloc>::size_type 
     erase_if(forward_list<_Tp, _Alloc>& __cont, _Predicate __pred)
-    { __cont.remove_if(__pred); }
+    { return __cont.remove_if(__pred); }
 
   template<typename _Tp, typename _Alloc, typename _Up>
-    inline void
+    inline typename forward_list<_Tp, _Alloc>::size_type
     erase(forward_list<_Tp, _Alloc>& __cont, const _Up& __value)
     {
       using __elem_type = typename forward_list<_Tp, _Alloc>::value_type;
-      erase_if(__cont, [&](__elem_type& __elem) { return __elem == __value; });
+      return erase_if(__cont,
+		      [&](__elem_type& __elem) { return __elem == __value; });
     }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std

libstdc++-v3/include/std/list

@@ -90,16 +90,17 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp, typename _Alloc, typename _Predicate>
-    inline void
+    inline typename list<_Tp, _Alloc>::size_type
     erase_if(list<_Tp, _Alloc>& __cont, _Predicate __pred)
-    { __cont.remove_if(__pred); }
+    { return __cont.remove_if(__pred); }
 
   template<typename _Tp, typename _Alloc, typename _Up>
-    inline void
+    inline typename list<_Tp, _Alloc>::size_type
     erase(list<_Tp, _Alloc>& __cont, const _Up& __value)
     {
       using __elem_type = typename list<_Tp, _Alloc>::value_type;
-      erase_if(__cont, [&](__elem_type& __elem) { return __elem == __value; });
+      return erase_if(__cont,
+		      [&](__elem_type& __elem) { return __elem == __value; });
     }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std

libstdc++-v3/include/std/map

@@ -97,15 +97,15 @@ namespace std _GLIBCXX_VISIBILITY(default)
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Key, typename _Tp, typename _Compare, typename _Alloc,
 	   typename _Predicate>
-    inline void
+    inline typename map<_Key, _Tp, _Compare, _Alloc>::size_type
     erase_if(map<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred)
-    { __detail::__erase_nodes_if(__cont, __pred); }
+    { return __detail::__erase_nodes_if(__cont, __pred); }
 
   template<typename _Key, typename _Tp, typename _Compare, typename _Alloc,
 	   typename _Predicate>
-    inline void
+    inline typename multimap<_Key, _Tp, _Compare, _Alloc>::size_type
     erase_if(multimap<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred)
-    { __detail::__erase_nodes_if(__cont, __pred); }
+    { return __detail::__erase_nodes_if(__cont, __pred); }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // C++20

libstdc++-v3/include/std/set

@@ -93,15 +93,15 @@ namespace std _GLIBCXX_VISIBILITY(default)
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Key, typename _Compare, typename _Alloc,
 	   typename _Predicate>
-    inline void
+    inline typename set<_Key, _Compare, _Alloc>::size_type
     erase_if(set<_Key, _Compare, _Alloc>& __cont, _Predicate __pred)
-    { __detail::__erase_nodes_if(__cont, __pred); }
+    { return __detail::__erase_nodes_if(__cont, __pred); }
 
   template<typename _Key, typename _Compare, typename _Alloc,
 	   typename _Predicate>
-    inline void
+    inline typename multiset<_Key, _Compare, _Alloc>::size_type
     erase_if(multiset<_Key, _Compare, _Alloc>& __cont, _Predicate __pred)
-    { __detail::__erase_nodes_if(__cont, __pred); }
+    { return __detail::__erase_nodes_if(__cont, __pred); }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // C++20

libstdc++-v3/include/std/string

@@ -81,19 +81,23 @@ namespace std _GLIBCXX_VISIBILITY(default)
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _CharT, typename _Traits, typename _Alloc,
 	   typename _Predicate>
-    inline void
+    inline typename basic_string<_CharT, _Traits, _Alloc>::size_type
     erase_if(basic_string<_CharT, _Traits, _Alloc>& __cont, _Predicate __pred)
     {
+      const auto __osz = __cont.size();
       __cont.erase(std::remove_if(__cont.begin(), __cont.end(), __pred),
 		   __cont.end());
+      return __osz - __cont.size();
     }
 
   template<typename _CharT, typename _Traits, typename _Alloc, typename _Up>
-    inline void
+    inline typename basic_string<_CharT, _Traits, _Alloc>::size_type
     erase(basic_string<_CharT, _Traits, _Alloc>& __cont, const _Up& __value)
     {
+      const auto __osz = __cont.size();
       __cont.erase(std::remove(__cont.begin(), __cont.end(), __value),
 		   __cont.end());
+      return __osz - __cont.size();
     }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std

libstdc++-v3/include/std/unordered_map

@@ -84,17 +84,18 @@ namespace std _GLIBCXX_VISIBILITY(default)
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
 	   typename _Alloc, typename _Predicate>
-    inline void
+    inline typename unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>::size_type
     erase_if(unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont,
 	     _Predicate __pred)
-    { __detail::__erase_nodes_if(__cont, __pred); }
+    { return __detail::__erase_nodes_if(__cont, __pred); }
 
   template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
 	   typename _Alloc, typename _Predicate>
-    inline void
+    inline typename unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>::
+		    size_type
     erase_if(unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont,
 	     _Predicate __pred)
-    { __detail::__erase_nodes_if(__cont, __pred); }
+    { return __detail::__erase_nodes_if(__cont, __pred); }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // C++20

libstdc++-v3/include/std/unordered_set

@@ -84,17 +84,17 @@ namespace std _GLIBCXX_VISIBILITY(default)
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Key, typename _Hash, typename _CPred, typename _Alloc,
 	   typename _Predicate>
-    inline void
+    inline typename unordered_set<_Key, _Hash, _CPred, _Alloc>::size_type
     erase_if(unordered_set<_Key, _Hash, _CPred, _Alloc>& __cont,
 	     _Predicate __pred)
-    { std::__detail::__erase_nodes_if(__cont, __pred); }
+    { return __detail::__erase_nodes_if(__cont, __pred); }
 
   template<typename _Key, typename _Hash, typename _CPred, typename _Alloc,
 	   typename _Predicate>
-    inline void
+    inline typename unordered_multiset<_Key, _Hash, _CPred, _Alloc>::size_type
     erase_if(unordered_multiset<_Key, _Hash, _CPred, _Alloc>& __cont,
 	     _Predicate __pred)
-    { std::__detail::__erase_nodes_if(__cont, __pred); }
+    { return __detail::__erase_nodes_if(__cont, __pred); }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // C++20

libstdc++-v3/include/std/vector

@@ -98,19 +98,23 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp, typename _Alloc, typename _Predicate>
-    inline void
+    inline typename vector<_Tp, _Alloc>::size_type
     erase_if(vector<_Tp, _Alloc>& __cont, _Predicate __pred)
     {
+      const auto __osz = __cont.size();
       __cont.erase(std::remove_if(__cont.begin(), __cont.end(), __pred),
 		   __cont.end());
+      return __osz - __cont.size();
     }
 
   template<typename _Tp, typename _Alloc, typename _Up>
-    inline void
+    inline typename vector<_Tp, _Alloc>::size_type
     erase(vector<_Tp, _Alloc>& __cont, const _Up& __value)
     {
+      const auto __osz = __cont.size();
       __cont.erase(std::remove(__cont.begin(), __cont.end(), __value),
 		   __cont.end());
+      return __osz - __cont.size();
     }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std

libstdc++-v3/testsuite/21_strings/basic_string/erasure.cc

@@ -30,18 +30,21 @@ test01()
   };
 
   std::string str("cute fluffy kittens");
-  std::erase_if(str, is_vowel);
+  auto num = std::erase_if(str, is_vowel);
   VERIFY( str == "ct flffy kttns" );
+  VERIFY( num == 5 );
 }
 
 void
 test02()
 {
   std::string str = "cute fluffy kittens";
-  std::erase(str, 'f');
+  auto num = std::erase(str, 'f');
   VERIFY( str == "cute luy kittens" );
-  std::erase(str, 'z');
+  VERIFY( num == 3 );
+  num = std::erase(str, 'z');
   VERIFY( str == "cute luy kittens" );
+  VERIFY( num == 0 );
 }
 
 int

libstdc++-v3/testsuite/23_containers/deque/erasure.cc

@@ -27,20 +27,23 @@ test01()
   auto is_odd = [](const int i) { return i % 2 != 0; };
 
   std::deque<int> d{ 10, 11, 12, 14, 15, 17, 18, 19 };
-  std::erase_if(d, is_odd);
+  auto num = std::erase_if(d, is_odd);
   std::deque<int> t{ 10, 12, 14, 18 };
   VERIFY( d == t );
+  VERIFY( num == 4 );
 }
 
 void
 test02()
 {
   std::deque<int> d{ 10, 11, 12, 14, 15, 17, 18, 19 };
-  std::erase(d, 14);
+  auto num = std::erase(d, 14);
   std::deque<int> t{ 10, 11, 12, 15, 17, 18, 19 };
   VERIFY( d == t );
-  std::erase(d, 20);
+  VERIFY( num == 1 );
+  num = std::erase(d, 20);
   VERIFY( d == t );
+  VERIFY( num == 0 );
 }
 
 int

libstdc++-v3/testsuite/23_containers/forward_list/erasure.cc

@@ -27,20 +27,23 @@ test01()
   auto is_odd = [](const int i) { return i % 2 != 0; };
 
   std::forward_list<int> fl{ 10, 11, 12, 14, 15, 17, 18, 19 };
-  std::erase_if(fl, is_odd);
+  auto num = std::erase_if(fl, is_odd);
   std::forward_list<int> t{ 10, 12, 14, 18 };
   VERIFY( fl == t );
+  VERIFY( num == 4 );
 }
 
 void
 test02()
 {
   std::forward_list<int> fl{ 10, 11, 12, 14, 15, 17, 18, 19 };
-  std::erase(fl, 14);
+  auto num = std::erase(fl, 14);
   std::forward_list<int> t{ 10, 11, 12, 15, 17, 18, 19 };
   VERIFY( fl == t );
-  std::erase(fl, 20);
+  VERIFY( num == 1 );
+  num = std::erase(fl, 20);
   VERIFY( fl == t );
+  VERIFY( num == 0 );
 }
 
 int

libstdc++-v3/testsuite/23_containers/list/erasure.cc

@@ -36,11 +36,13 @@ void
 test02()
 {
   std::list<int> l{ 0, 11, 0, 0, 22, 33, 0, 0, 44, 0 };
-  std::erase(l, 0);
+  auto num = std::erase(l, 0);
   std::list<int> t{ 11, 22, 33, 44 };
   VERIFY( l == t );
-  std::erase(l, 55);
+  VERIFY( num == 6 );
+  num = std::erase(l, 55);
   VERIFY( l == t );
+  VERIFY( num == 0 );
 }
 
 int

libstdc++-v3/testsuite/23_containers/map/erasure.cc

@@ -33,10 +33,11 @@ test01()
 				{ 12, "C" }, { 14, "D" },
 				{ 15, "E" }, { 17, "F" },
 				{ 18, "G" }, { 19, "H" } };
-  std::erase_if(m, is_odd_pair);
+  auto num = std::erase_if(m, is_odd_pair);
   std::map<int, std::string> t{ { 10, "A" }, { 12, "C" },
 				{ 14, "D" }, { 18, "G" } };
   VERIFY( m == t );
+  VERIFY( num == 4 );
 }
 
 void
@@ -46,10 +47,11 @@ test02()
 				      { 22, "U" }, { 22, "V" },
 				      { 23, "W" }, { 23, "X" },
 				      { 24, "Y" }, { 25, "Z" } };
-  std::erase_if(mm, is_odd_pair);
+  auto num = std::erase_if(mm, is_odd_pair);
   std::multimap<int, std::string> t{ { 20, "S" }, { 22, "U" },
 				     { 22, "V" }, { 24, "Y" } };
   VERIFY( mm == t );
+  VERIFY( num == 4 );
 }
 
 int

libstdc++-v3/testsuite/23_containers/set/erasure.cc

@@ -27,18 +27,20 @@ void
 test01()
 {
   std::set<int> s{ 10, 11, 12, 14, 15, 17, 18, 19 };
-  std::erase_if(s, is_odd);
+  auto num = std::erase_if(s, is_odd);
   std::set<int> t{ 10, 12, 14, 18 };
   VERIFY( s == t );
+  VERIFY( num == 4 );
 }
 
 void
 test02()
 {
   std::multiset<int> ms{ 20, 21, 22, 22, 23, 23, 24, 25 };
-  std::erase_if(ms, is_odd);
+  auto num = std::erase_if(ms, is_odd);
   std::multiset<int> t{ 20, 22, 22, 24 };
   VERIFY( ms == t );
+  VERIFY( num == 4 );
 }
 
 int

libstdc++-v3/testsuite/23_containers/unordered_map/erasure.cc

@@ -33,10 +33,11 @@ test01()
 					   { 12, "C" }, { 14, "D" },
 					   { 15, "E" }, { 17, "F" },
 					   { 18, "G" }, { 19, "H" } };
-  std::erase_if(um, is_odd_pair);
+  auto num = std::erase_if(um, is_odd_pair);
   std::unordered_map<int, std::string> t{ { 10, "A" }, { 12, "C" },
 					  { 14, "D" }, { 18, "G" } };
   VERIFY( um == t );
+  VERIFY( num == 4 );
 }
 
 void
@@ -46,10 +47,11 @@ test02()
 						 { 22, "U" }, { 22, "V" },
 						 { 23, "W" }, { 23, "X" },
 						 { 24, "Y" }, { 25, "Z" } };
-  std::erase_if(umm, is_odd_pair);
+  auto num = std::erase_if(umm, is_odd_pair);
   std::unordered_multimap<int, std::string> t{ { 20, "S" }, { 22, "U" },
 					       { 22, "V" }, { 24, "Y" } };
   VERIFY( umm == t );
+  VERIFY( num == 4 );
 }
 
 int

libstdc++-v3/testsuite/23_containers/unordered_set/erasure.cc

@@ -27,9 +27,10 @@ test01()
   auto is_odd = [](const int i) { return i % 2 != 0; };
 
   std::unordered_set<int> us{ 10, 11, 12, 14, 15, 17, 18, 19 };
-  std::erase_if(us, is_odd);
+  auto num = std::erase_if(us, is_odd);
   std::unordered_set<int> t{ 10, 12, 14, 18 };
   VERIFY( us == t );
+  VERIFY( num == 4 );
 }
 
 void
@@ -38,9 +39,10 @@ test02()
   auto is_odd = [](const int i) { return i % 2 != 0; };
 
   std::unordered_multiset<int> ums{ 20, 21, 22, 22, 23, 23, 24, 25 };
-  std::erase_if(ums, is_odd);
+  auto num = std::erase_if(ums, is_odd);
   std::unordered_multiset<int> t{ 20, 22, 22, 24 };
   VERIFY( ums == t );
+  VERIFY( num == 4 );
 }
 
 int

libstdc++-v3/testsuite/23_containers/vector/erasure.cc

@@ -27,20 +27,23 @@ test01()
   auto is_odd = [](const int i) { return i % 2 != 0; };
 
   std::vector<int> v{ 10, 11, 12, 14, 15, 17, 18, 19 };
-  std::erase_if(v, is_odd);
+  auto num = std::erase_if(v, is_odd);
   std::vector<int> t{ 10, 12, 14, 18 };
   VERIFY( v == t );
+  VERIFY( num == 4 );
 }
 
 void
 test02()
 {
   std::vector<int> v{ 0, 11, 0, 0, 22, 33, 0, 0, 44, 0 };
-  std::erase(v, 0);
+  auto num = std::erase(v, 0);
   std::vector<int> t{ 11, 22, 33, 44 };
   VERIFY( v == t );
-  std::erase(v, 55);
+  VERIFY( num == 6 );
+  num = std::erase(v, 55);
   VERIFY( v == t );
+  VERIFY( num == 0 );
 }
 
 int