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 
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