Implementing erase/erase_if functions from library fundamentals ts:

base/containers/flat_set.h

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_CONTAINERS_FLAT_SET_H_
 #define BASE_CONTAINERS_FLAT_SET_H_
 
 #include <algorithm>
 #include <functional>
 #include <utility>
@@ skipping 15 matching lines @@
 //
 // Usage guidance:
 // Prefer base::flat_set for:
 //  * Very small sets, something that is an easy fit for cache. Consider
 //    "very small" to be under a 100 32bit integers.
 //  * Sets that are built once (using flat_set::flat_set(first, last)). Consider
 //    collecting all data in a vector and then building flat_set out of it.
 //    TODO(dyaroshev): improve the interface to better support this pattern
 //    (crbug.com/682254).
 //  * Sets where mutating happens in big bulks: use erase(std::remove()) idiom
-//    for erasing many elements. Insertion is harder - consider set operations
-//    or building a new vector. Set operations can be slow if one of the sets
-//    is considerably bigger. Also be aware that beating performance of
-//    sort + unique (implementation of flat_set's constructor) is hard, clever
-//    merge of many sets might not win. Generally avoid inserting into flat set
-//    without benchmarks.
+//    for erasing many elements. If possible - use supplied for flat_set
+//    overload of base::EraseIf. Insertion is harder - consider set operations

[dyaroshev, 2017/03/03 23:16:54]

I'm not sure how to formulate this thought.

[Peter Kasting, 2017/03/03 23:27:30]

"Sets where mutating happens in bulk operations: to erase multiple elements, use
base::EraseIf() rather than repeated single-element removal."

[dyaroshev, 2017/03/04 00:32:49]

Done.

+//    or building a new vector. Set operations can be slow if one of the sets is
+//    considerably bigger. Also be aware that beating performance of sort +
+//    unique (implementation of flat_set's constructor) is hard, clever merge of
+//    many sets might not win. Generally avoid inserting into flat set without
+//    benchmarks.
 //  * Copying and iterating.
 //  * Set operations (union/intersect etc).
 //
 // Prefer to build a new flat_set from a std::vector (or similar) instead of
 // calling insert() repeatedly, which would have O(size^2) complexity.
 //
 // TODO(dyaroshev): develop standalone benchmarks to find performance boundaries
 // for different types of sets crbug.com/682215.
 //
 // If you do write a benchmark that significantly depends on using sets please
@@ skipping 157 matching lines @@
   iterator emplace_hint(const_iterator position_hint, Args&&... args);
 
   // --------------------------------------------------------------------------
   // Erase operations.
   //
   // Assume that every operation invalidates iterators and references.
   //
   // erase(position), erase(first, last) can take O(size).
   // erase(key) may take O(size) + O(log(size)).
   //
   // Prefer the erase(std::remove(), end()) idiom for deleting multiple

[danakj, 2017/03/03 23:51:22]

Like peter said above just say to use base::EraseIf() here

[dyaroshev, 2017/03/04 00:32:49]

Slightly extended it. Is it ok?

-  // elements.
+  // elements. If possible use supplied base::EraseIf overload.
+  //
 
   iterator erase(const_iterator position);
   iterator erase(const_iterator first, const_iterator last);
   size_type erase(const key_type& key);
 
   // --------------------------------------------------------------------------
   // Comparators.
 
   key_compare key_comp() const;
   value_compare value_comp() const;
@@ skipping 419 matching lines @@
 }
 
 // ----------------------------------------------------------------------------
 // General operations.
 
 template <class Key, class Compare>
 void flat_set<Key, Compare>::swap(flat_set& other) {
   std::swap(impl_, other.impl_);
 }
 
+// ----------------------------------------------------------------------------
+// Free functions.
+
+// Erases all elements that match predicate. It has O(size) complexity.
+

[danakj, 2017/03/03 23:51:22]

no whitespace here

[dyaroshev, 2017/03/04 00:32:49]

Done.

+template <typename Key, typename Compare, typename Predicate>
+void EraseIf(base::flat_set<Key, Compare>& container, Predicate pred) {
+  container.erase(
+      std::remove_if(std::begin(container), std::end(container), pred),

[danakj, 2017/03/03 23:51:22]

it's a bit less verbose to use container.begin() and container.end()

[dyaroshev, 2017/03/04 00:32:49]

Done.

+      std::end(container));
+}
+
 }  // namespace  base
 
 #endif  // BASE_CONTAINERS_FLAT_SET_H_