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 // <map>
11 
12 // class map
13 
14 //       iterator find(const key_type& k);
15 // const_iterator find(const key_type& k) const;
16 
17 #include <map>
18 #include <cassert>
19 
20 #include "min_allocator.h"
21 #include "private_constructor.hpp"
22 
main()23 int main()
24 {
25     {
26     typedef std::pair<const int, double> V;
27     typedef std::map<int, double> M;
28     {
29         typedef M::iterator R;
30         V ar[] =
31         {
32             V(5, 5),
33             V(6, 6),
34             V(7, 7),
35             V(8, 8),
36             V(9, 9),
37             V(10, 10),
38             V(11, 11),
39             V(12, 12)
40         };
41         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
42         R r = m.find(5);
43         assert(r == m.begin());
44         r = m.find(6);
45         assert(r == next(m.begin()));
46         r = m.find(7);
47         assert(r == next(m.begin(), 2));
48         r = m.find(8);
49         assert(r == next(m.begin(), 3));
50         r = m.find(9);
51         assert(r == next(m.begin(), 4));
52         r = m.find(10);
53         assert(r == next(m.begin(), 5));
54         r = m.find(11);
55         assert(r == next(m.begin(), 6));
56         r = m.find(12);
57         assert(r == next(m.begin(), 7));
58         r = m.find(4);
59         assert(r == next(m.begin(), 8));
60     }
61     {
62         typedef M::const_iterator R;
63         V ar[] =
64         {
65             V(5, 5),
66             V(6, 6),
67             V(7, 7),
68             V(8, 8),
69             V(9, 9),
70             V(10, 10),
71             V(11, 11),
72             V(12, 12)
73         };
74         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
75         R r = m.find(5);
76         assert(r == m.begin());
77         r = m.find(6);
78         assert(r == next(m.begin()));
79         r = m.find(7);
80         assert(r == next(m.begin(), 2));
81         r = m.find(8);
82         assert(r == next(m.begin(), 3));
83         r = m.find(9);
84         assert(r == next(m.begin(), 4));
85         r = m.find(10);
86         assert(r == next(m.begin(), 5));
87         r = m.find(11);
88         assert(r == next(m.begin(), 6));
89         r = m.find(12);
90         assert(r == next(m.begin(), 7));
91         r = m.find(4);
92         assert(r == next(m.begin(), 8));
93     }
94     }
95 #if __cplusplus >= 201103L
96     {
97     typedef std::pair<const int, double> V;
98     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
99     {
100         typedef M::iterator R;
101         V ar[] =
102         {
103             V(5, 5),
104             V(6, 6),
105             V(7, 7),
106             V(8, 8),
107             V(9, 9),
108             V(10, 10),
109             V(11, 11),
110             V(12, 12)
111         };
112         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
113         R r = m.find(5);
114         assert(r == m.begin());
115         r = m.find(6);
116         assert(r == next(m.begin()));
117         r = m.find(7);
118         assert(r == next(m.begin(), 2));
119         r = m.find(8);
120         assert(r == next(m.begin(), 3));
121         r = m.find(9);
122         assert(r == next(m.begin(), 4));
123         r = m.find(10);
124         assert(r == next(m.begin(), 5));
125         r = m.find(11);
126         assert(r == next(m.begin(), 6));
127         r = m.find(12);
128         assert(r == next(m.begin(), 7));
129         r = m.find(4);
130         assert(r == next(m.begin(), 8));
131     }
132     {
133         typedef M::const_iterator R;
134         V ar[] =
135         {
136             V(5, 5),
137             V(6, 6),
138             V(7, 7),
139             V(8, 8),
140             V(9, 9),
141             V(10, 10),
142             V(11, 11),
143             V(12, 12)
144         };
145         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
146         R r = m.find(5);
147         assert(r == m.begin());
148         r = m.find(6);
149         assert(r == next(m.begin()));
150         r = m.find(7);
151         assert(r == next(m.begin(), 2));
152         r = m.find(8);
153         assert(r == next(m.begin(), 3));
154         r = m.find(9);
155         assert(r == next(m.begin(), 4));
156         r = m.find(10);
157         assert(r == next(m.begin(), 5));
158         r = m.find(11);
159         assert(r == next(m.begin(), 6));
160         r = m.find(12);
161         assert(r == next(m.begin(), 7));
162         r = m.find(4);
163         assert(r == next(m.begin(), 8));
164     }
165     }
166 #endif
167 #if _LIBCPP_STD_VER > 11
168     {
169     typedef std::pair<const int, double> V;
170     typedef std::map<int, double, std::less<>> M;
171     typedef M::iterator R;
172 
173     V ar[] =
174     {
175         V(5, 5),
176         V(6, 6),
177         V(7, 7),
178         V(8, 8),
179         V(9, 9),
180         V(10, 10),
181         V(11, 11),
182         V(12, 12)
183     };
184     M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
185     R r = m.find(5);
186     assert(r == m.begin());
187     r = m.find(6);
188     assert(r == next(m.begin()));
189     r = m.find(7);
190     assert(r == next(m.begin(), 2));
191     r = m.find(8);
192     assert(r == next(m.begin(), 3));
193     r = m.find(9);
194     assert(r == next(m.begin(), 4));
195     r = m.find(10);
196     assert(r == next(m.begin(), 5));
197     r = m.find(11);
198     assert(r == next(m.begin(), 6));
199     r = m.find(12);
200     assert(r == next(m.begin(), 7));
201     r = m.find(4);
202     assert(r == next(m.begin(), 8));
203     }
204 
205     {
206     typedef PrivateConstructor PC;
207     typedef std::map<PC, double, std::less<>> M;
208     typedef M::iterator R;
209 
210     M m;
211     m [ PC::make(5)  ] = 5;
212     m [ PC::make(6)  ] = 6;
213     m [ PC::make(7)  ] = 7;
214     m [ PC::make(8)  ] = 8;
215     m [ PC::make(9)  ] = 9;
216     m [ PC::make(10) ] = 10;
217     m [ PC::make(11) ] = 11;
218     m [ PC::make(12) ] = 12;
219 
220     R r = m.find(5);
221     assert(r == m.begin());
222     r = m.find(6);
223     assert(r == next(m.begin()));
224     r = m.find(7);
225     assert(r == next(m.begin(), 2));
226     r = m.find(8);
227     assert(r == next(m.begin(), 3));
228     r = m.find(9);
229     assert(r == next(m.begin(), 4));
230     r = m.find(10);
231     assert(r == next(m.begin(), 5));
232     r = m.find(11);
233     assert(r == next(m.begin(), 6));
234     r = m.find(12);
235     assert(r == next(m.begin(), 7));
236     r = m.find(4);
237     assert(r == next(m.begin(), 8));
238     }
239 #endif
240 }
241