Skip to content

Commit cad715d

Browse files
Abseil Teamsuertreus
Abseil Team
authored and
suertreus
committed
Export of internal Abseil changes
-- e2a571b818faaec4185426a8cf71fd2970674423 by Matt Kulukundis <[email protected]>: Fix missed use of old RTTI macro PiperOrigin-RevId: 413239579 -- e3c15a3fe0a4e44d6e08d69ad912b2245a403bd6 by Derek Mauro <[email protected]>: Makes erase_if return the number of erased elements for compatibility with C++20 https://en.cppreference.com/w/cpp/container/unordered_map/erase_if This may technically be an API break, but no actual breaks were found in Google code. Fixes to open source code should be trivial. Closes #1065 PiperOrigin-RevId: 413204392 -- c1fb1ddbc2def3f3d177e5b80b9934bdbb7b16fc by Matt Kulukundis <[email protected]>: Consolidate to a single HAS_RTTI macro PiperOrigin-RevId: 413169336 GitOrigin-RevId: e2a571b818faaec4185426a8cf71fd2970674423 Change-Id: I74b78ebd5fc172e3f5fcbd13a58cf53f7b250ae9
1 parent 3e1983c commit cad715d

17 files changed

+95
-68
lines changed

‎absl/base/config.h

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -788,4 +788,12 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
788788
#define ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
789789
#endif
790790

791+
// `ABSL_INTERNAL_HAS_RTTI` determines whether abseil is being compiled with
792+
// RTTI support.
793+
#ifdef ABSL_INTERNAL_HAS_RTTI
794+
#error ABSL_INTERNAL_HAS_RTTI cannot be directly set
795+
#elif !defined(__GNUC__) || defined(__GXX_RTTI)
796+
#define ABSL_INTERNAL_HAS_RTTI 1
797+
#endif // !defined(__GNUC__) || defined(__GXX_RTTI)
798+
791799
#endif // ABSL_BASE_CONFIG_H_

‎absl/container/btree_map.h

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -478,15 +478,19 @@ void swap(btree_map<K, V, C, A> &x, btree_map<K, V, C, A> &y) {
478478
// absl::erase_if(absl::btree_map<>, Pred)
479479
//
480480
// Erases all elements that satisfy the predicate pred from the container.
481+
// Returns the number of erased elements.
481482
template <typename K, typename V, typename C, typename A, typename Pred>
482-
void erase_if(btree_map<K, V, C, A> &map, Pred pred) {
483+
typename btree_map<K, V, C, A>::size_type erase_if(
484+
btree_map<K, V, C, A> &map, Pred pred) {
485+
const auto initial_size = map.size();
483486
for (auto it = map.begin(); it != map.end();) {
484487
if (pred(*it)) {
485488
it = map.erase(it);
486489
} else {
487490
++it;
488491
}
489492
}
493+
return initial_size - map.size();
490494
}
491495

492496
// absl::btree_multimap
@@ -809,15 +813,19 @@ void swap(btree_multimap<K, V, C, A> &x, btree_multimap<K, V, C, A> &y) {
809813
// absl::erase_if(absl::btree_multimap<>, Pred)
810814
//
811815
// Erases all elements that satisfy the predicate pred from the container.
816+
// Returns the number of erased elements.
812817
template <typename K, typename V, typename C, typename A, typename Pred>
813-
void erase_if(btree_multimap<K, V, C, A> &map, Pred pred) {
818+
typename btree_multimap<K, V, C, A>::size_type erase_if(
819+
btree_multimap<K, V, C, A> &map, Pred pred) {
820+
const auto initial_size = map.size();
814821
for (auto it = map.begin(); it != map.end();) {
815822
if (pred(*it)) {
816823
it = map.erase(it);
817824
} else {
818825
++it;
819826
}
820827
}
828+
return initial_size - map.size();
821829
}
822830

823831
namespace container_internal {

‎absl/container/btree_set.h

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -398,15 +398,19 @@ void swap(btree_set<K, C, A> &x, btree_set<K, C, A> &y) {
398398
// absl::erase_if(absl::btree_set<>, Pred)
399399
//
400400
// Erases all elements that satisfy the predicate pred from the container.
401+
// Returns the number of erased elements.
401402
template <typename K, typename C, typename A, typename Pred>
402-
void erase_if(btree_set<K, C, A> &set, Pred pred) {
403+
typename btree_set<K, C, A>::size_type erase_if(btree_set<K, C, A> &set,
404+
Pred pred) {
405+
const auto initial_size = set.size();
403406
for (auto it = set.begin(); it != set.end();) {
404407
if (pred(*it)) {
405408
it = set.erase(it);
406409
} else {
407410
++it;
408411
}
409412
}
413+
return initial_size - set.size();
410414
}
411415

412416
// absl::btree_multiset<>
@@ -724,15 +728,19 @@ void swap(btree_multiset<K, C, A> &x, btree_multiset<K, C, A> &y) {
724728
// absl::erase_if(absl::btree_multiset<>, Pred)
725729
//
726730
// Erases all elements that satisfy the predicate pred from the container.
731+
// Returns the number of erased elements.
727732
template <typename K, typename C, typename A, typename Pred>
728-
void erase_if(btree_multiset<K, C, A> &set, Pred pred) {
733+
typename btree_multiset<K, C, A>::size_type erase_if(
734+
btree_multiset<K, C, A> & set, Pred pred) {
735+
const auto initial_size = set.size();
729736
for (auto it = set.begin(); it != set.end();) {
730737
if (pred(*it)) {
731738
it = set.erase(it);
732739
} else {
733740
++it;
734741
}
735742
}
743+
return initial_size - set.size();
736744
}
737745

738746
namespace container_internal {

‎absl/container/btree_test.cc

Lines changed: 11 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2452,37 +2452,42 @@ TEST(Btree, EraseIf) {
24522452
// Test that erase_if works with all the container types and supports lambdas.
24532453
{
24542454
absl::btree_set<int> s = {1, 3, 5, 6, 100};
2455-
erase_if(s, [](int k) { return k > 3; });
2455+
EXPECT_EQ(erase_if(s, [](int k) { return k > 3; }), 3);
24562456
EXPECT_THAT(s, ElementsAre(1, 3));
24572457
}
24582458
{
24592459
absl::btree_multiset<int> s = {1, 3, 3, 5, 6, 6, 100};
2460-
erase_if(s, [](int k) { return k <= 3; });
2460+
EXPECT_EQ(erase_if(s, [](int k) { return k <= 3; }), 3);
24612461
EXPECT_THAT(s, ElementsAre(5, 6, 6, 100));
24622462
}
24632463
{
24642464
absl::btree_map<int, int> m = {{1, 1}, {3, 3}, {6, 6}, {100, 100}};
2465-
erase_if(m, [](std::pair<const int, int> kv) { return kv.first > 3; });
2465+
EXPECT_EQ(
2466+
erase_if(m, [](std::pair<const int, int> kv) { return kv.first > 3; }),
2467+
2);
24662468
EXPECT_THAT(m, ElementsAre(Pair(1, 1), Pair(3, 3)));
24672469
}
24682470
{
24692471
absl::btree_multimap<int, int> m = {{1, 1}, {3, 3}, {3, 6},
24702472
{6, 6}, {6, 7}, {100, 6}};
2471-
erase_if(m, [](std::pair<const int, int> kv) { return kv.second == 6; });
2473+
EXPECT_EQ(
2474+
erase_if(m,
2475+
[](std::pair<const int, int> kv) { return kv.second == 6; }),
2476+
3);
24722477
EXPECT_THAT(m, ElementsAre(Pair(1, 1), Pair(3, 3), Pair(6, 7)));
24732478
}
24742479
// Test that erasing all elements from a large set works and test support for
24752480
// function pointers.
24762481
{
24772482
absl::btree_set<int> s;
24782483
for (int i = 0; i < 1000; ++i) s.insert(2 * i);
2479-
erase_if(s, IsEven);
2484+
EXPECT_EQ(erase_if(s, IsEven), 1000);
24802485
EXPECT_THAT(s, IsEmpty());
24812486
}
24822487
// Test that erase_if supports other format of function pointers.
24832488
{
24842489
absl::btree_set<int> s = {1, 3, 5, 6, 100};
2485-
erase_if(s, &IsEven);
2490+
EXPECT_EQ(erase_if(s, &IsEven), 2);
24862491
EXPECT_THAT(s, ElementsAre(1, 3, 5));
24872492
}
24882493
}

‎absl/container/flat_hash_map.h

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -541,10 +541,12 @@ class flat_hash_map : public absl::container_internal::raw_hash_map<
541541
// erase_if(flat_hash_map<>, Pred)
542542
//
543543
// Erases all elements that satisfy the predicate `pred` from the container `c`.
544+
// Returns the number of erased elements.
544545
template <typename K, typename V, typename H, typename E, typename A,
545546
typename Predicate>
546-
void erase_if(flat_hash_map<K, V, H, E, A>& c, Predicate pred) {
547-
container_internal::EraseIf(pred, &c);
547+
typename flat_hash_map<K, V, H, E, A>::size_type erase_if(
548+
flat_hash_map<K, V, H, E, A>& c, Predicate pred) {
549+
return container_internal::EraseIf(pred, &c);
548550
}
549551

550552
namespace container_internal {

‎absl/container/flat_hash_map_test.cc

Lines changed: 9 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -236,33 +236,36 @@ TEST(FlatHashMap, EraseIf) {
236236
// Erase all elements.
237237
{
238238
flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
239-
erase_if(s, [](std::pair<const int, int>) { return true; });
239+
EXPECT_EQ(erase_if(s, [](std::pair<const int, int>) { return true; }), 5);
240240
EXPECT_THAT(s, IsEmpty());
241241
}
242242
// Erase no elements.
243243
{
244244
flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
245-
erase_if(s, [](std::pair<const int, int>) { return false; });
245+
EXPECT_EQ(erase_if(s, [](std::pair<const int, int>) { return false; }), 0);
246246
EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(2, 2), Pair(3, 3),
247247
Pair(4, 4), Pair(5, 5)));
248248
}
249249
// Erase specific elements.
250250
{
251251
flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
252-
erase_if(s,
253-
[](std::pair<const int, int> kvp) { return kvp.first % 2 == 1; });
252+
EXPECT_EQ(erase_if(s,
253+
[](std::pair<const int, int> kvp) {
254+
return kvp.first % 2 == 1;
255+
}),
256+
3);
254257
EXPECT_THAT(s, UnorderedElementsAre(Pair(2, 2), Pair(4, 4)));
255258
}
256259
// Predicate is function reference.
257260
{
258261
flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
259-
erase_if(s, FirstIsEven);
262+
EXPECT_EQ(erase_if(s, FirstIsEven), 2);
260263
EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(3, 3), Pair(5, 5)));
261264
}
262265
// Predicate is function pointer.
263266
{
264267
flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
265-
erase_if(s, &FirstIsEven);
268+
EXPECT_EQ(erase_if(s, &FirstIsEven), 2);
266269
EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(3, 3), Pair(5, 5)));
267270
}
268271
}

‎absl/container/flat_hash_set.h

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -443,9 +443,11 @@ class flat_hash_set
443443
// erase_if(flat_hash_set<>, Pred)
444444
//
445445
// Erases all elements that satisfy the predicate `pred` from the container `c`.
446+
// Returns the number of erased elements.
446447
template <typename T, typename H, typename E, typename A, typename Predicate>
447-
void erase_if(flat_hash_set<T, H, E, A>& c, Predicate pred) {
448-
container_internal::EraseIf(pred, &c);
448+
typename flat_hash_set<T, H, E, A>::size_type erase_if(
449+
flat_hash_set<T, H, E, A>& c, Predicate pred) {
450+
return container_internal::EraseIf(pred, &c);
449451
}
450452

451453
namespace container_internal {

‎absl/container/flat_hash_set_test.cc

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -143,31 +143,31 @@ TEST(FlatHashSet, EraseIf) {
143143
// Erase all elements.
144144
{
145145
flat_hash_set<int> s = {1, 2, 3, 4, 5};
146-
erase_if(s, [](int) { return true; });
146+
EXPECT_EQ(erase_if(s, [](int) { return true; }), 5);
147147
EXPECT_THAT(s, IsEmpty());
148148
}
149149
// Erase no elements.
150150
{
151151
flat_hash_set<int> s = {1, 2, 3, 4, 5};
152-
erase_if(s, [](int) { return false; });
152+
EXPECT_EQ(erase_if(s, [](int) { return false; }), 0);
153153
EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
154154
}
155155
// Erase specific elements.
156156
{
157157
flat_hash_set<int> s = {1, 2, 3, 4, 5};
158-
erase_if(s, [](int k) { return k % 2 == 1; });
158+
EXPECT_EQ(erase_if(s, [](int k) { return k % 2 == 1; }), 3);
159159
EXPECT_THAT(s, UnorderedElementsAre(2, 4));
160160
}
161161
// Predicate is function reference.
162162
{
163163
flat_hash_set<int> s = {1, 2, 3, 4, 5};
164-
erase_if(s, IsEven);
164+
EXPECT_EQ(erase_if(s, IsEven), 2);
165165
EXPECT_THAT(s, UnorderedElementsAre(1, 3, 5));
166166
}
167167
// Predicate is function pointer.
168168
{
169169
flat_hash_set<int> s = {1, 2, 3, 4, 5};
170-
erase_if(s, &IsEven);
170+
EXPECT_EQ(erase_if(s, &IsEven), 2);
171171
EXPECT_THAT(s, UnorderedElementsAre(1, 3, 5));
172172
}
173173
}

‎absl/container/internal/raw_hash_set.h

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1958,14 +1958,17 @@ class raw_hash_set {
19581958

19591959
// Erases all elements that satisfy the predicate `pred` from the container `c`.
19601960
template <typename P, typename H, typename E, typename A, typename Predicate>
1961-
void EraseIf(Predicate& pred, raw_hash_set<P, H, E, A>* c) {
1961+
typename raw_hash_set<P, H, E, A>::size_type EraseIf(
1962+
Predicate& pred, raw_hash_set<P, H, E, A>* c) {
1963+
const auto initial_size = c->size();
19621964
for (auto it = c->begin(), last = c->end(); it != last;) {
19631965
if (pred(*it)) {
19641966
c->erase(it++);
19651967
} else {
19661968
++it;
19671969
}
19681970
}
1971+
return initial_size - c->size();
19691972
}
19701973

19711974
namespace hashtable_debug_internal {

‎absl/container/node_hash_map.h

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -525,10 +525,12 @@ class node_hash_map
525525
// erase_if(node_hash_map<>, Pred)
526526
//
527527
// Erases all elements that satisfy the predicate `pred` from the container `c`.
528+
// Returns the number of erased elements.
528529
template <typename K, typename V, typename H, typename E, typename A,
529530
typename Predicate>
530-
void erase_if(node_hash_map<K, V, H, E, A>& c, Predicate pred) {
531-
container_internal::EraseIf(pred, &c);
531+
typename node_hash_map<K, V, H, E, A>::size_type erase_if(
532+
node_hash_map<K, V, H, E, A>& c, Predicate pred) {
533+
return container_internal::EraseIf(pred, &c);
532534
}
533535

534536
namespace container_internal {

0 commit comments

Comments
 (0)