Skip to content

Commit 9675b5e

Browse files
vinay-deshmukhvinay-deshmukh
committed
multimap.modifiers
1 parent e8b63c2 commit 9675b5e

16 files changed

+165
-149
lines changed

‎libcxx/include/__tree‎

Lines changed: 18 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1141,7 +1141,7 @@ public:
11411141
} else {
11421142
__end_node_pointer __parent;
11431143
__node_base_pointer& __child = __find_leaf_high(__parent, __nd->__get_value());
1144-
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd.release()));
1144+
__insert_node_at(__parent, __child, std::__static_fancy_pointer_cast<__node_base_pointer>(__nd.release()));
11451145
}
11461146
}
11471147
}
@@ -1894,9 +1894,9 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__end_node_pointer& __parent
18941894
while (true) {
18951895
if (value_comp()(__v, __nd->__get_value())) {
18961896
if (__nd->__left_ != nullptr)
1897-
__nd = static_cast<__node_pointer>(__nd->__left_);
1897+
__nd = std::__static_fancy_pointer_cast<__node_pointer>(__nd->__left_);
18981898
else {
1899-
__parent = static_cast<__end_node_pointer>(__nd);
1899+
__parent = std::__static_fancy_pointer_cast<__end_node_pointer>(__nd);
19001900
return __parent->__left_;
19011901
}
19021902
} else {
@@ -2204,7 +2204,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(_NodeHandle&& __nh
22042204
__node_pointer __ptr = __nh.__ptr_;
22052205
__end_node_pointer __parent;
22062206
__node_base_pointer& __child = __find_leaf_high(__parent, __ptr->__get_value());
2207-
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
2207+
__insert_node_at(__parent, __child, std::__static_fancy_pointer_cast<__node_base_pointer>(__ptr));
22082208
__nh.__release_ptr();
22092209
return iterator(__ptr);
22102210
}
@@ -2219,7 +2219,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(const_iterator __h
22192219
__node_pointer __ptr = __nh.__ptr_;
22202220
__end_node_pointer __parent;
22212221
__node_base_pointer& __child = __find_leaf(__hint, __parent, __ptr->__get_value());
2222-
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
2222+
__insert_node_at(__parent, __child, std::__static_fancy_pointer_cast<__node_base_pointer>(__ptr));
22232223
__nh.__release_ptr();
22242224
return iterator(__ptr);
22252225
}
@@ -2309,14 +2309,16 @@ __tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const {
23092309
while (__rt != nullptr) {
23102310
auto __comp_res = __comp(__k, __rt->__get_value());
23112311
if (__comp_res.__less()) {
2312-
__result = static_cast<__end_node_pointer>(__rt);
2313-
__rt = static_cast<__node_pointer>(__rt->__left_);
2312+
__result = std::__static_fancy_pointer_cast<__end_node_pointer>(__rt);
2313+
__rt = std::__static_fancy_pointer_cast<__node_pointer>(__rt->__left_);
23142314
} else if (__comp_res.__greater())
2315-
__rt = static_cast<__node_pointer>(__rt->__right_);
2315+
__rt = std::__static_fancy_pointer_cast<__node_pointer>(__rt->__right_);
23162316
else
23172317
return std::distance(
2318-
__lower_bound_multi(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),
2319-
__upper_bound_multi(__k, static_cast<__node_pointer>(__rt->__right_), __result));
2318+
__lower_bound_multi(__k,
2319+
std::__static_fancy_pointer_cast<__node_pointer>(__rt->__left_),
2320+
std::__static_fancy_pointer_cast<__end_node_pointer>(__rt)),
2321+
__upper_bound_multi(__k, std::__static_fancy_pointer_cast<__node_pointer>(__rt->__right_), __result));
23202322
}
23212323
return 0;
23222324
}
@@ -2444,14 +2446,15 @@ _LIBCPP_CONSTEXPR_SINCE_CXX26
24442446
while (__rt != nullptr) {
24452447
auto __comp_res = __comp(__k, __rt->__get_value());
24462448
if (__comp_res.__less()) {
2447-
__result = static_cast<__end_node_pointer>(__rt);
2448-
__rt = static_cast<__node_pointer>(__rt->__left_);
2449+
__result = std::__static_fancy_pointer_cast<__end_node_pointer>(__rt);
2450+
__rt = std::__static_fancy_pointer_cast<__node_pointer>(__rt->__left_);
24492451
} else if (__comp_res.__greater())
24502452
__rt = std::__static_fancy_pointer_cast<__node_pointer>(__rt->__right_);
24512453
else
2452-
return _Pp(
2453-
__lower_bound_multi(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),
2454-
__upper_bound_multi(__k, static_cast<__node_pointer>(__rt->__right_), __result));
2454+
return _Pp(__lower_bound_multi(__k,
2455+
std::__static_fancy_pointer_cast<__node_pointer>(__rt->__left_),
2456+
std::__static_fancy_pointer_cast<__end_node_pointer>(__rt)),
2457+
__upper_bound_multi(__k, std::__static_fancy_pointer_cast<__node_pointer>(__rt->__right_), __result));
24552458
}
24562459
return _Pp(iterator(__result), iterator(__result));
24572460
}

‎libcxx/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp‎

Lines changed: 51 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -25,31 +25,34 @@
2525

2626
TEST_CONSTEXPR_CXX26
2727
bool test() {
28-
{
29-
typedef std::multimap<int, DefaultOnly> M;
30-
typedef M::iterator R;
31-
M m;
28+
// DefaultOnly::count is static
29+
if (!TEST_IS_CONSTANT_EVALUATED) {
30+
{
31+
typedef std::multimap<int, DefaultOnly> M;
32+
typedef M::iterator R;
33+
M m;
34+
assert(DefaultOnly::count == 0);
35+
R r = m.emplace();
36+
assert(r == m.begin());
37+
assert(m.size() == 1);
38+
assert(m.begin()->first == 0);
39+
assert(m.begin()->second == DefaultOnly());
40+
assert(DefaultOnly::count == 1);
41+
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
42+
assert(r == std::next(m.begin()));
43+
assert(m.size() == 2);
44+
assert(std::next(m.begin())->first == 1);
45+
assert(std::next(m.begin())->second == DefaultOnly());
46+
assert(DefaultOnly::count == 2);
47+
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
48+
assert(r == std::next(m.begin(), 2));
49+
assert(m.size() == 3);
50+
assert(std::next(m.begin(), 2)->first == 1);
51+
assert(std::next(m.begin(), 2)->second == DefaultOnly());
52+
assert(DefaultOnly::count == 3);
53+
}
3254
assert(DefaultOnly::count == 0);
33-
R r = m.emplace();
34-
assert(r == m.begin());
35-
assert(m.size() == 1);
36-
assert(m.begin()->first == 0);
37-
assert(m.begin()->second == DefaultOnly());
38-
assert(DefaultOnly::count == 1);
39-
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
40-
assert(r == std::next(m.begin()));
41-
assert(m.size() == 2);
42-
assert(std::next(m.begin())->first == 1);
43-
assert(std::next(m.begin())->second == DefaultOnly());
44-
assert(DefaultOnly::count == 2);
45-
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
46-
assert(r == std::next(m.begin(), 2));
47-
assert(m.size() == 3);
48-
assert(std::next(m.begin(), 2)->first == 1);
49-
assert(std::next(m.begin(), 2)->second == DefaultOnly());
50-
assert(DefaultOnly::count == 3);
5155
}
52-
assert(DefaultOnly::count == 0);
5356
{
5457
typedef std::multimap<int, Emplaceable> M;
5558
typedef M::iterator R;
@@ -80,31 +83,33 @@ bool test() {
8083
assert(m.begin()->first == 2);
8184
assert(m.begin()->second == 3.5);
8285
}
83-
{
84-
typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
85-
typedef M::iterator R;
86-
M m;
86+
if (!TEST_IS_CONSTANT_EVALUATED) {
87+
{
88+
typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
89+
typedef M::iterator R;
90+
M m;
91+
assert(DefaultOnly::count == 0);
92+
R r = m.emplace();
93+
assert(r == m.begin());
94+
assert(m.size() == 1);
95+
assert(m.begin()->first == 0);
96+
assert(m.begin()->second == DefaultOnly());
97+
assert(DefaultOnly::count == 1);
98+
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
99+
assert(r == std::next(m.begin()));
100+
assert(m.size() == 2);
101+
assert(std::next(m.begin())->first == 1);
102+
assert(std::next(m.begin())->second == DefaultOnly());
103+
assert(DefaultOnly::count == 2);
104+
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
105+
assert(r == std::next(m.begin(), 2));
106+
assert(m.size() == 3);
107+
assert(std::next(m.begin(), 2)->first == 1);
108+
assert(std::next(m.begin(), 2)->second == DefaultOnly());
109+
assert(DefaultOnly::count == 3);
110+
}
87111
assert(DefaultOnly::count == 0);
88-
R r = m.emplace();
89-
assert(r == m.begin());
90-
assert(m.size() == 1);
91-
assert(m.begin()->first == 0);
92-
assert(m.begin()->second == DefaultOnly());
93-
assert(DefaultOnly::count == 1);
94-
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
95-
assert(r == std::next(m.begin()));
96-
assert(m.size() == 2);
97-
assert(std::next(m.begin())->first == 1);
98-
assert(std::next(m.begin())->second == DefaultOnly());
99-
assert(DefaultOnly::count == 2);
100-
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
101-
assert(r == std::next(m.begin(), 2));
102-
assert(m.size() == 3);
103-
assert(std::next(m.begin(), 2)->first == 1);
104-
assert(std::next(m.begin(), 2)->second == DefaultOnly());
105-
assert(DefaultOnly::count == 3);
106112
}
107-
assert(DefaultOnly::count == 0);
108113
{
109114
typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M;
110115
typedef M::iterator R;

‎libcxx/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp‎

Lines changed: 51 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -25,31 +25,34 @@
2525

2626
TEST_CONSTEXPR_CXX26
2727
bool test() {
28-
{
29-
typedef std::multimap<int, DefaultOnly> M;
30-
typedef M::iterator R;
31-
M m;
28+
// DefaultOnly::count is static
29+
if (!TEST_IS_CONSTANT_EVALUATED) {
30+
{
31+
typedef std::multimap<int, DefaultOnly> M;
32+
typedef M::iterator R;
33+
M m;
34+
assert(DefaultOnly::count == 0);
35+
R r = m.emplace_hint(m.cend());
36+
assert(r == m.begin());
37+
assert(m.size() == 1);
38+
assert(m.begin()->first == 0);
39+
assert(m.begin()->second == DefaultOnly());
40+
assert(DefaultOnly::count == 1);
41+
r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
42+
assert(r == std::next(m.begin()));
43+
assert(m.size() == 2);
44+
assert(std::next(m.begin())->first == 1);
45+
assert(std::next(m.begin())->second == DefaultOnly());
46+
assert(DefaultOnly::count == 2);
47+
r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
48+
assert(r == std::next(m.begin(), 2));
49+
assert(m.size() == 3);
50+
assert(std::next(m.begin(), 2)->first == 1);
51+
assert(std::next(m.begin(), 2)->second == DefaultOnly());
52+
assert(DefaultOnly::count == 3);
53+
}
3254
assert(DefaultOnly::count == 0);
33-
R r = m.emplace_hint(m.cend());
34-
assert(r == m.begin());
35-
assert(m.size() == 1);
36-
assert(m.begin()->first == 0);
37-
assert(m.begin()->second == DefaultOnly());
38-
assert(DefaultOnly::count == 1);
39-
r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
40-
assert(r == std::next(m.begin()));
41-
assert(m.size() == 2);
42-
assert(std::next(m.begin())->first == 1);
43-
assert(std::next(m.begin())->second == DefaultOnly());
44-
assert(DefaultOnly::count == 2);
45-
r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
46-
assert(r == std::next(m.begin(), 2));
47-
assert(m.size() == 3);
48-
assert(std::next(m.begin(), 2)->first == 1);
49-
assert(std::next(m.begin(), 2)->second == DefaultOnly());
50-
assert(DefaultOnly::count == 3);
5155
}
52-
assert(DefaultOnly::count == 0);
5356
{
5457
typedef std::multimap<int, Emplaceable> M;
5558
typedef M::iterator R;
@@ -80,31 +83,33 @@ bool test() {
8083
assert(m.begin()->first == 2);
8184
assert(m.begin()->second == 3.5);
8285
}
83-
{
84-
typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
85-
typedef M::iterator R;
86-
M m;
86+
if (!TEST_IS_CONSTANT_EVALUATED) {
87+
{
88+
typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
89+
typedef M::iterator R;
90+
M m;
91+
assert(DefaultOnly::count == 0);
92+
R r = m.emplace_hint(m.cend());
93+
assert(r == m.begin());
94+
assert(m.size() == 1);
95+
assert(m.begin()->first == 0);
96+
assert(m.begin()->second == DefaultOnly());
97+
assert(DefaultOnly::count == 1);
98+
r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
99+
assert(r == std::next(m.begin()));
100+
assert(m.size() == 2);
101+
assert(std::next(m.begin())->first == 1);
102+
assert(std::next(m.begin())->second == DefaultOnly());
103+
assert(DefaultOnly::count == 2);
104+
r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
105+
assert(r == std::next(m.begin(), 2));
106+
assert(m.size() == 3);
107+
assert(std::next(m.begin(), 2)->first == 1);
108+
assert(std::next(m.begin(), 2)->second == DefaultOnly());
109+
assert(DefaultOnly::count == 3);
110+
}
87111
assert(DefaultOnly::count == 0);
88-
R r = m.emplace_hint(m.cend());
89-
assert(r == m.begin());
90-
assert(m.size() == 1);
91-
assert(m.begin()->first == 0);
92-
assert(m.begin()->second == DefaultOnly());
93-
assert(DefaultOnly::count == 1);
94-
r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
95-
assert(r == std::next(m.begin()));
96-
assert(m.size() == 2);
97-
assert(std::next(m.begin())->first == 1);
98-
assert(std::next(m.begin())->second == DefaultOnly());
99-
assert(DefaultOnly::count == 2);
100-
r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple());
101-
assert(r == std::next(m.begin(), 2));
102-
assert(m.size() == 3);
103-
assert(std::next(m.begin(), 2)->first == 1);
104-
assert(std::next(m.begin(), 2)->second == DefaultOnly());
105-
assert(DefaultOnly::count == 3);
106112
}
107-
assert(DefaultOnly::count == 0);
108113
{
109114
typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M;
110115
typedef M::iterator R;

‎libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,9 +20,10 @@
2020

2121
struct TemplateConstructor {
2222
template <typename T>
23-
TemplateConstructor(const T&) {}
23+
TEST_CONSTEXPR_CXX26 TemplateConstructor(const T&) {}
2424
};
2525

26+
TEST_CONSTEXPR_CXX26
2627
bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
2728

2829
TEST_CONSTEXPR_CXX26

‎libcxx/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp‎

Lines changed: 10 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@
2020
#include "Counter.h"
2121

2222
template <class Container>
23-
void test(Container& c) {
23+
TEST_CONSTEXPR_CXX26 void test(Container& c) {
2424
std::size_t sz = c.size();
2525

2626
auto some_key = c.cbegin()->first;
@@ -29,9 +29,13 @@ void test(Container& c) {
2929
auto key_value = first->first;
3030
typename Container::node_type t = c.extract(first++);
3131
--sz;
32-
assert(t.key() == key_value);
33-
t.key() = some_key;
34-
assert(t.key() == some_key);
32+
33+
if (!TEST_IS_CONSTANT_EVALUATED) {
34+
// FIXME: CWG1514: key() is not `constexpr`
35+
assert(t.key() == key_value);
36+
t.key() = some_key;
37+
assert(t.key() == some_key);
38+
}
3539
assert(t.get_allocator() == c.get_allocator());
3640
assert(sz == c.size());
3741
}
@@ -47,7 +51,8 @@ bool test() {
4751
test(m);
4852
}
4953

50-
{
54+
// Counter_base::gConstructed is static
55+
if (!TEST_IS_CONSTANT_EVALUATED) {
5156
std::multimap<Counter<int>, Counter<int>> m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
5257
assert(Counter_base::gConstructed == 12);
5358
test(m);

‎libcxx/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp‎

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,17 +20,19 @@
2020
#include "Counter.h"
2121

2222
template <class Container, class KeyTypeIter>
23-
void test(Container& c, KeyTypeIter first, KeyTypeIter last) {
23+
TEST_CONSTEXPR_CXX26 void test(Container& c, KeyTypeIter first, KeyTypeIter last) {
2424
std::size_t sz = c.size();
2525
assert((std::size_t)std::distance(first, last) == sz);
2626

2727
for (KeyTypeIter copy = first; copy != last; ++copy) {
2828
typename Container::node_type t = c.extract(*copy);
2929
assert(!t.empty());
3030
--sz;
31-
assert(t.key() == *copy);
32-
t.key() = *first; // We should be able to mutate key.
33-
assert(t.key() == *first);
31+
if (!TEST_IS_CONSTANT_EVALUATED) {
32+
assert(t.key() == *copy);
33+
t.key() = *first; // We should be able to mutate key.
34+
assert(t.key() == *first);
35+
}
3436
assert(t.get_allocator() == c.get_allocator());
3537
assert(sz == c.size());
3638
}
@@ -51,7 +53,8 @@ bool test() {
5153
test(m, std::begin(keys), std::end(keys));
5254
}
5355

54-
{
56+
// Counter_base::gConstructed is static
57+
if (!TEST_IS_CONSTANT_EVALUATED) {
5558
std::multimap<Counter<int>, Counter<int>> m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
5659
{
5760
Counter<int> keys[] = {1, 2, 3, 4, 5, 6};

0 commit comments

Comments
 (0)