Skip to content

Commit c6746f5

Browse files
huixie90huixie90
committed
deduction
1 parent 80f3f08 commit c6746f5

File tree

2 files changed

+121
-132
lines changed

2 files changed

+121
-132
lines changed

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct.compile.pass.cpp‎

Lines changed: 4 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -23,27 +23,21 @@ struct NotAnAllocator {
2323
};
2424

2525
template <class... Args>
26-
concept CanDeductFlatSet = requires { std::flat_set{std::declval<Args>()...}; };
26+
concept CanDeductFlatSet = requires { std::flat_set(std::declval<Args>()...); };
2727

28-
static_assert(CanDeductFlatSet<std::vector<int>, std::vector<int>>);
28+
static_assert(CanDeductFlatSet<std::vector<int>>);
2929

3030
// cannot deduce Key and T from nothing
3131
static_assert(!CanDeductFlatSet<>);
3232

33-
// cannot deduce Key and T from just (KeyContainer), even if it's a container of pairs
34-
static_assert(!CanDeductFlatSet<std::vector<std::pair<int, int>>>);
35-
36-
// cannot deduce Key and T from just (KeyContainer, Allocator)
37-
static_assert(!CanDeductFlatSet<std::vector<int>, std::allocator<std::pair<const int, int>>>);
38-
3933
// cannot deduce Key and T from just (Compare)
4034
static_assert(!CanDeductFlatSet<std::less<int>>);
4135

4236
// cannot deduce Key and T from just (Compare, Allocator)
43-
static_assert(!CanDeductFlatSet<std::less<int>, std::allocator<PC>>);
37+
static_assert(!CanDeductFlatSet<std::less<int>, std::allocator<int>>);
4438

4539
// cannot deduce Key and T from just (Allocator)
46-
static_assert(!CanDeductFlatSet<std::allocator<PC>>);
40+
static_assert(!CanDeductFlatSet<std::allocator<int>>);
4741

4842
// cannot convert from some arbitrary unrelated type
4943
static_assert(!CanDeductFlatSet<NotAnAllocator>);

‎libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct.pass.cpp‎

Lines changed: 117 additions & 122 deletions
Original file line numberDiff line numberDiff line change
@@ -116,8 +116,8 @@ void test_containers_compare() {
116116
}
117117

118118
void test_iter_iter() {
119-
const int arr[] = {1, 2, 1, INT_MAX, 3};
120-
const int sorted_arr[] = {1, 2, 3, INT_MAX};
119+
int arr[] = {1, 2, 1, INT_MAX, 3};
120+
int sorted_arr[] = {1, 2, 3, INT_MAX};
121121
const int arrc[] = {1, 2, 1, INT_MAX, 3};
122122
const int sorted_arrc[] = {1, 2, 3, INT_MAX};
123123
{
@@ -154,6 +154,12 @@ void test_iter_iter() {
154154
std::flat_set m(mo.cbegin(), mo.cend());
155155
ASSERT_SAME_TYPE(decltype(m), decltype(mo));
156156
}
157+
{
158+
int source[3] = {1, 2, 3};
159+
std::flat_set s(source, source + 3);
160+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int>);
161+
assert(s.size() == 3);
162+
}
157163
{
158164
// This does not deduce to flat_set(InputIterator, InputIterator)
159165
// But deduces to flat_set(initializer_list<int*>)
@@ -171,140 +177,125 @@ void test_iter_iter() {
171177
}
172178

173179
void test_iter_iter_compare() {
174-
// const P arr[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
175-
// const P sorted_arr[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
176-
// const PC arrc[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
177-
// const PC sorted_arrc[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
178-
// using C = std::greater<long long>;
179-
// {
180-
// std::flat_set m(std::begin(arr), std::end(arr), C());
181-
182-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, long, C>);
183-
// assert(std::ranges::equal(m, sorted_arr));
184-
// }
185-
// {
186-
// std::flat_set m(std::begin(arrc), std::end(arrc), C());
187-
188-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, long, C>);
189-
// assert(std::ranges::equal(m, sorted_arr));
190-
// }
191-
// {
192-
// std::flat_set m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), C());
193-
194-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, long, C>);
195-
// assert(std::ranges::equal(m, sorted_arr));
196-
// }
197-
// {
198-
// std::flat_set m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), C());
199-
200-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, long, C>);
201-
// assert(std::ranges::equal(m, sorted_arr));
202-
// }
203-
// {
204-
// std::flat_set<int, short> mo;
205-
// std::flat_set m(mo.begin(), mo.end(), C());
206-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, short, C>);
207-
// }
208-
// {
209-
// std::flat_set<int, short> mo;
210-
// std::flat_set m(mo.cbegin(), mo.cend(), C());
211-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, short, C>);
212-
// }
180+
int arr[] = {1, 2, 1, INT_MAX, 3};
181+
int sorted_arr[] = {INT_MAX, 3, 2, 1};
182+
const int arrc[] = {1, 2, 1, INT_MAX, 3};
183+
const int sorted_arrc[] = {INT_MAX, 3, 2, 1};
184+
using C = std::greater<long>;
185+
{
186+
std::flat_set m(std::begin(arr), std::end(arr), C());
187+
188+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, C>);
189+
assert(std::ranges::equal(m, sorted_arr));
190+
}
191+
{
192+
std::flat_set m(std::begin(arrc), std::end(arrc), C());
193+
194+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, C>);
195+
assert(std::ranges::equal(m, sorted_arr));
196+
}
197+
{
198+
std::flat_set m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), C());
199+
200+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, C>);
201+
assert(std::ranges::equal(m, sorted_arr));
202+
}
203+
{
204+
std::flat_set m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), C());
205+
206+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, C>);
207+
assert(std::ranges::equal(m, sorted_arr));
208+
}
209+
{
210+
std::flat_set<int> mo;
211+
std::flat_set m(mo.begin(), mo.end(), C());
212+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, C>);
213+
}
214+
{
215+
std::flat_set<int> mo;
216+
std::flat_set m(mo.cbegin(), mo.cend(), C());
217+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, C>);
218+
}
213219
}
214220

215221
void test_initializer_list() {
216-
// const P sorted_arr[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};
217-
// {
218-
// std::flat_set m{std::pair{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
219-
220-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, long>);
221-
// assert(std::ranges::equal(m, sorted_arr));
222-
// }
223-
// {
224-
// std::flat_set m(std::sorted_unique, {std::pair{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}});
225-
226-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, long>);
227-
// assert(std::ranges::equal(m, sorted_arr));
228-
// }
229-
// {
230-
// std::flat_set s = {std::make_pair(1, 'a')}; // flat_set(initializer_list<pair<int, char>>)
231-
// ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, char>);
232-
// assert(s.size() == 1);
233-
// }
234-
// {
235-
// using M = std::flat_set<int, short>;
236-
// M m;
237-
// std::flat_set s = {std::make_pair(m, m)}; // flat_set(initializer_list<pair<M, M>>)
238-
// ASSERT_SAME_TYPE(decltype(s), std::flat_set<M, M>);
239-
// assert(s.size() == 1);
240-
// assert(s[m] == m);
241-
// }
222+
const int sorted_arr[] = {1, 2, 3, INT_MAX};
223+
{
224+
std::flat_set m{1, 2, 1, INT_MAX, 3};
225+
226+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int>);
227+
assert(std::ranges::equal(m, sorted_arr));
228+
}
229+
{
230+
std::flat_set m(std::sorted_unique, {1, 2, 3, INT_MAX});
231+
232+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int>);
233+
assert(std::ranges::equal(m, sorted_arr));
234+
}
235+
{
236+
std::flat_set s = {1};
237+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int>);
238+
assert(s.size() == 1);
239+
}
240+
{
241+
using M = std::flat_set<int>;
242+
M m;
243+
std::flat_set s{m, m}; // flat_set(initializer_list<M>)
244+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<M>);
245+
assert(s.size() == 1);
246+
}
242247
}
243248

244249
void test_initializer_list_compare() {
245-
// const P sorted_arr[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
246-
// using C = std::greater<long long>;
247-
// {
248-
// std::flat_set m({std::pair{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}}, C());
249-
250-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, long, C>);
251-
// assert(std::ranges::equal(m, sorted_arr));
252-
// }
253-
// {
254-
// std::flat_set m(std::sorted_unique, {std::pair{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}}, C());
255-
256-
// ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, long, C>);
257-
// assert(std::ranges::equal(m, sorted_arr));
258-
// }
250+
const int sorted_arr[] = {INT_MAX, 3, 2, 1};
251+
using C = std::greater<long>;
252+
{
253+
std::flat_set m({1, 2, 1, INT_MAX, 3}, C());
254+
255+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, C>);
256+
assert(std::ranges::equal(m, sorted_arr));
257+
}
258+
{
259+
std::flat_set m(std::sorted_unique, {INT_MAX, 3, 2, 1}, C());
260+
261+
ASSERT_SAME_TYPE(decltype(m), std::flat_set<int, C>);
262+
assert(std::ranges::equal(m, sorted_arr));
263+
}
259264
}
260265

261266
void test_from_range() {
262-
// std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
263-
// const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
264-
// {
265-
// std::flat_set s(std::from_range, r);
266-
// ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, short, std::less<int>>);
267-
// assert(std::ranges::equal(s, expected));
268-
// }
269-
// {
270-
// std::flat_set s(std::from_range, r, test_allocator<long>(0, 42));
271-
// ASSERT_SAME_TYPE(
272-
// decltype(s),
273-
// std::flat_set<int,
274-
// short,
275-
// std::less<int>,
276-
// std::vector<int, test_allocator<int>>,
277-
// std::vector<short, test_allocator<short>>>);
278-
// assert(std::ranges::equal(s, expected));
279-
// assert(s.keys().get_allocator().get_id() == 42);
280-
// assert(s.values().get_allocator().get_id() == 42);
281-
// }
267+
std::list<int> r = {1, 2, 1, INT_MAX, 3};
268+
const int expected[] = {1, 2, 3, INT_MAX};
269+
{
270+
std::flat_set s(std::from_range, r);
271+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::less<int>>);
272+
assert(std::ranges::equal(s, expected));
273+
}
274+
{
275+
std::flat_set s(std::from_range, r, test_allocator<long>(0, 42));
276+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::less<int>, std::vector<int, test_allocator<int>>>);
277+
assert(std::ranges::equal(s, expected));
278+
assert(std::move(s).extract().get_allocator().get_id() == 42);
279+
}
282280
}
283281

284282
void test_from_range_compare() {
285-
// std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
286-
// const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
287-
// {
288-
// std::flat_set s(std::from_range, r, std::greater<int>());
289-
// ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, short, std::greater<int>>);
290-
// assert(std::ranges::equal(s, expected));
291-
// }
292-
// {
293-
// std::flat_set s(std::from_range, r, std::greater<int>(), test_allocator<long>(0, 42));
294-
// ASSERT_SAME_TYPE(
295-
// decltype(s),
296-
// std::flat_set<int,
297-
// short,
298-
// std::greater<int>,
299-
// std::vector<int, test_allocator<int>>,
300-
// std::vector<short, test_allocator<short>>>);
301-
// assert(std::ranges::equal(s, expected));
302-
// assert(s.keys().get_allocator().get_id() == 42);
303-
// assert(s.values().get_allocator().get_id() == 42);
304-
// }
283+
std::list<int> r = {1, 2, 1, INT_MAX, 3};
284+
const int expected[] = {INT_MAX, 3, 2, 1};
285+
{
286+
std::flat_set s(std::from_range, r, std::greater<int>());
287+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::greater<int>>);
288+
assert(std::ranges::equal(s, expected));
289+
}
290+
{
291+
std::flat_set s(std::from_range, r, std::greater<int>(), test_allocator<long>(0, 42));
292+
ASSERT_SAME_TYPE(decltype(s), std::flat_set<int, std::greater<int>, std::vector<int, test_allocator<int>>>);
293+
assert(std::ranges::equal(s, expected));
294+
assert(std::move(s).extract().get_allocator().get_id() == 42);
295+
}
305296
}
306297

307-
int main(int, char**) {
298+
void test() {
308299
// Each test function also tests the sorted_unique-prefixed and allocator-suffixed overloads.
309300
test_copy();
310301
test_containers();
@@ -317,6 +308,10 @@ int main(int, char**) {
317308
test_from_range_compare();
318309

319310
AssociativeContainerDeductionGuidesSfinaeAway<std::flat_set, std::flat_set<int>>();
311+
}
312+
313+
int main(int, char**) {
314+
test();
320315

321316
return 0;
322317
}

0 commit comments

Comments
 (0)