1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
// <flat_map>
// class flat_multimap
// key_compare key_comp() const;
// value_compare value_comp() const;
#include <cassert>
#include <flat_map>
#include <functional>
#include <utility>
#include <vector>
#include "test_macros.h"
int main(int, char**) {
{
using M = std::flat_multimap<int, char>;
using Comp = std::less<int>; // the default
M m = {};
ASSERT_SAME_TYPE(M::key_compare, Comp);
static_assert(!std::is_same_v<M::value_compare, Comp>);
ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
ASSERT_SAME_TYPE(decltype(m.value_comp()), M::value_compare);
Comp kc = m.key_comp();
assert(kc(1, 2));
assert(!kc(2, 1));
auto vc = m.value_comp();
ASSERT_SAME_TYPE(decltype(vc(std::make_pair(1, 2), std::make_pair(1, 2))), bool);
assert(vc({1, '2'}, {2, '1'}));
assert(!vc({2, '1'}, {1, '2'}));
}
{
using Comp = std::function<bool(int, int)>;
using M = std::flat_multimap<int, int, Comp>;
Comp comp = std::greater<int>();
M m({}, comp);
ASSERT_SAME_TYPE(M::key_compare, Comp);
ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
ASSERT_SAME_TYPE(decltype(m.value_comp()), M::value_compare);
Comp kc = m.key_comp();
assert(!kc(1, 2));
assert(kc(2, 1));
auto vc = m.value_comp();
auto a = std::make_pair(1, 2);
ASSERT_SAME_TYPE(decltype(vc(a, a)), bool);
static_assert(!noexcept(vc(a, a)));
assert(!vc({1, 2}, {2, 1}));
assert(vc({2, 1}, {1, 2}));
}
{
using Comp = std::less<>;
using M = std::flat_multimap<int, int, Comp>;
M m = {};
ASSERT_SAME_TYPE(M::key_compare, Comp);
ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
ASSERT_SAME_TYPE(decltype(m.value_comp()), M::value_compare);
Comp kc = m.key_comp();
assert(kc(1, 2));
assert(!kc(2, 1));
auto vc = m.value_comp();
auto a = std::make_pair(1, 2);
ASSERT_SAME_TYPE(decltype(vc(a, a)), bool);
assert(vc({1, 2}, {2, 1}));
assert(!vc({2, 1}, {1, 2}));
}
{
using Comp = std::function<bool(const std::vector<int>&, const std::vector<int>&)>;
using M = std::flat_multimap<std::vector<int>, int, Comp>;
Comp comp = [i = 1](const auto& x, const auto& y) { return x[i] < y[i]; };
M m({}, comp);
auto vc = m.value_comp();
static_assert(sizeof(vc) >= sizeof(Comp));
comp = nullptr;
m = M({}, nullptr);
assert(m.key_comp() == nullptr);
// At this point, m.key_comp() is disengaged.
// But the std::function captured by copy inside `vc` remains valid.
auto a = std::make_pair(std::vector<int>{2, 1, 4}, 42);
auto b = std::make_pair(std::vector<int>{1, 2, 3}, 42);
auto c = std::make_pair(std::vector<int>{0, 3, 2}, 42);
assert(vc(a, b));
assert(vc(b, c));
assert(!vc(b, a));
assert(!vc(c, b));
}
return 0;
}
|
