]>
Commit | Line | Data |
---|---|---|
b32b8144 | 1 | // Copyright Louis Dionne 2013-2017 |
7c673cae FG |
2 | // Distributed under the Boost Software License, Version 1.0. |
3 | // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) | |
4 | ||
5 | #include <boost/hana/functional/overload_linearly.hpp> | |
6 | ||
7 | #include <boost/hana/assert.hpp> | |
8 | #include <boost/hana/equal.hpp> | |
9 | ||
10 | #include <laws/base.hpp> | |
11 | namespace hana = boost::hana; | |
12 | using hana::test::ct_eq; | |
13 | ||
14 | ||
15 | struct A { }; | |
16 | struct AA : A { }; | |
17 | struct B { }; | |
18 | struct C { }; | |
19 | ||
20 | int main() { | |
21 | // 2 functions without overlap | |
22 | { | |
23 | auto f = hana::overload_linearly( | |
24 | [](A) { return ct_eq<0>{}; }, | |
25 | [](B) { return ct_eq<1>{}; } | |
26 | ); | |
27 | ||
28 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
29 | f(A{}), | |
30 | ct_eq<0>{} | |
31 | )); | |
32 | ||
33 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
34 | f(AA{}), | |
35 | f(A{}) | |
36 | )); | |
37 | ||
38 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
39 | f(B{}), | |
40 | ct_eq<1>{} | |
41 | )); | |
42 | } | |
43 | ||
44 | // 2 functions with overlap | |
45 | { | |
46 | auto f = hana::overload_linearly( | |
47 | [](A) { return ct_eq<0>{}; }, | |
48 | [](A) { return ct_eq<1>{}; } | |
49 | ); | |
50 | ||
51 | auto g = hana::overload_linearly( | |
52 | [](A) { return ct_eq<0>{}; }, | |
53 | [](AA) { return ct_eq<1>{}; } | |
54 | ); | |
55 | ||
56 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
57 | f(A{}), | |
58 | ct_eq<0>{} | |
59 | )); | |
60 | ||
61 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
62 | f(AA{}), | |
63 | f(A{}) | |
64 | )); | |
65 | ||
66 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
67 | g(A{}), | |
68 | ct_eq<0>{} | |
69 | )); | |
70 | ||
71 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
72 | g(AA{}), | |
73 | g(A{}) | |
74 | )); | |
75 | } | |
76 | ||
77 | // 3 functions | |
78 | { | |
79 | auto f = hana::overload_linearly( | |
80 | [](A) { return ct_eq<0>{}; }, | |
81 | [](B) { return ct_eq<1>{}; }, | |
82 | [](C) { return ct_eq<2>{}; } | |
83 | ); | |
84 | ||
85 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
86 | f(A{}), | |
87 | ct_eq<0>{} | |
88 | )); | |
89 | ||
90 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
91 | f(AA{}), | |
92 | f(A{}) | |
93 | )); | |
94 | ||
95 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
96 | f(B{}), | |
97 | ct_eq<1>{} | |
98 | )); | |
99 | ||
100 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
101 | f(C{}), | |
102 | ct_eq<2>{} | |
103 | )); | |
104 | } | |
105 | ||
106 | // 1 function (github issue #280) | |
107 | { | |
108 | auto f = hana::overload_linearly( | |
109 | [](A) { return ct_eq<0>{}; } | |
110 | ); | |
111 | ||
112 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
113 | f(A{}), | |
114 | ct_eq<0>{} | |
115 | )); | |
116 | ||
117 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
118 | f(AA{}), | |
119 | f(A{}) | |
120 | )); | |
121 | } | |
122 | } |