1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <unordered_map>
11
12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
13 // class Alloc = allocator<pair<const Key, T>>>
14 // class unordered_multimap
15
16 // iterator erase(const_iterator first, const_iterator last)
17
18 #include <unordered_map>
19 #include <string>
20 #include <cassert>
21
22 #include "min_allocator.h"
23
main()24 int main()
25 {
26 {
27 typedef std::unordered_multimap<int, std::string> C;
28 typedef std::pair<int, std::string> P;
29 P a[] =
30 {
31 P(1, "one"),
32 P(2, "two"),
33 P(3, "three"),
34 P(4, "four"),
35 P(1, "four"),
36 P(2, "four"),
37 };
38 C c(a, a + sizeof(a)/sizeof(a[0]));
39 C::const_iterator i = c.find(2);
40 C::const_iterator j = next(i, 2);
41 C::iterator k = c.erase(i, i);
42 assert(k == i);
43 assert(c.size() == 6);
44 typedef std::pair<C::iterator, C::iterator> Eq;
45 Eq eq = c.equal_range(1);
46 assert(std::distance(eq.first, eq.second) == 2);
47 k = eq.first;
48 assert(k->first == 1);
49 assert(k->second == "one");
50 ++k;
51 assert(k->first == 1);
52 assert(k->second == "four");
53 eq = c.equal_range(2);
54 assert(std::distance(eq.first, eq.second) == 2);
55 k = eq.first;
56 assert(k->first == 2);
57 assert(k->second == "two");
58 ++k;
59 assert(k->first == 2);
60 assert(k->second == "four");
61 eq = c.equal_range(3);
62 assert(std::distance(eq.first, eq.second) == 1);
63 k = eq.first;
64 assert(k->first == 3);
65 assert(k->second == "three");
66 eq = c.equal_range(4);
67 assert(std::distance(eq.first, eq.second) == 1);
68 k = eq.first;
69 assert(k->first == 4);
70 assert(k->second == "four");
71 assert(std::distance(c.begin(), c.end()) == c.size());
72 assert(std::distance(c.cbegin(), c.cend()) == c.size());
73
74 k = c.erase(i, j);
75 assert(c.size() == 4);
76 eq = c.equal_range(1);
77 assert(std::distance(eq.first, eq.second) == 2);
78 k = eq.first;
79 assert(k->first == 1);
80 assert(k->second == "one");
81 ++k;
82 assert(k->first == 1);
83 assert(k->second == "four");
84 eq = c.equal_range(3);
85 assert(std::distance(eq.first, eq.second) == 1);
86 k = eq.first;
87 assert(k->first == 3);
88 assert(k->second == "three");
89 eq = c.equal_range(4);
90 assert(std::distance(eq.first, eq.second) == 1);
91 k = eq.first;
92 assert(k->first == 4);
93 assert(k->second == "four");
94 assert(std::distance(c.begin(), c.end()) == c.size());
95 assert(std::distance(c.cbegin(), c.cend()) == c.size());
96
97 k = c.erase(c.cbegin(), c.cend());
98 assert(c.size() == 0);
99 assert(k == c.end());
100 }
101 #if __cplusplus >= 201103L
102 {
103 typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
104 min_allocator<std::pair<const int, std::string>>> C;
105 typedef std::pair<int, std::string> P;
106 P a[] =
107 {
108 P(1, "one"),
109 P(2, "two"),
110 P(3, "three"),
111 P(4, "four"),
112 P(1, "four"),
113 P(2, "four"),
114 };
115 C c(a, a + sizeof(a)/sizeof(a[0]));
116 C::const_iterator i = c.find(2);
117 C::const_iterator j = next(i, 2);
118 C::iterator k = c.erase(i, i);
119 assert(k == i);
120 assert(c.size() == 6);
121 typedef std::pair<C::iterator, C::iterator> Eq;
122 Eq eq = c.equal_range(1);
123 assert(std::distance(eq.first, eq.second) == 2);
124 k = eq.first;
125 assert(k->first == 1);
126 assert(k->second == "one");
127 ++k;
128 assert(k->first == 1);
129 assert(k->second == "four");
130 eq = c.equal_range(2);
131 assert(std::distance(eq.first, eq.second) == 2);
132 k = eq.first;
133 assert(k->first == 2);
134 assert(k->second == "two");
135 ++k;
136 assert(k->first == 2);
137 assert(k->second == "four");
138 eq = c.equal_range(3);
139 assert(std::distance(eq.first, eq.second) == 1);
140 k = eq.first;
141 assert(k->first == 3);
142 assert(k->second == "three");
143 eq = c.equal_range(4);
144 assert(std::distance(eq.first, eq.second) == 1);
145 k = eq.first;
146 assert(k->first == 4);
147 assert(k->second == "four");
148 assert(std::distance(c.begin(), c.end()) == c.size());
149 assert(std::distance(c.cbegin(), c.cend()) == c.size());
150
151 k = c.erase(i, j);
152 assert(c.size() == 4);
153 eq = c.equal_range(1);
154 assert(std::distance(eq.first, eq.second) == 2);
155 k = eq.first;
156 assert(k->first == 1);
157 assert(k->second == "one");
158 ++k;
159 assert(k->first == 1);
160 assert(k->second == "four");
161 eq = c.equal_range(3);
162 assert(std::distance(eq.first, eq.second) == 1);
163 k = eq.first;
164 assert(k->first == 3);
165 assert(k->second == "three");
166 eq = c.equal_range(4);
167 assert(std::distance(eq.first, eq.second) == 1);
168 k = eq.first;
169 assert(k->first == 4);
170 assert(k->second == "four");
171 assert(std::distance(c.begin(), c.end()) == c.size());
172 assert(std::distance(c.cbegin(), c.cend()) == c.size());
173
174 k = c.erase(c.cbegin(), c.cend());
175 assert(c.size() == 0);
176 assert(k == c.end());
177 }
178 #endif
179 }
180