[ceph.git] / ceph / src / boost / libs / hana / test / functional / apply.cpp

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)

#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/functional/apply.hpp>

#include <laws/base.hpp>
#include <support/tracked.hpp>

#include <type_traits>
#include <utility>
namespace hana = boost::hana;


template <int i = 0>
struct nonpod : Tracked {
    nonpod() : Tracked{i} { }
};

struct NonCopyable {
    NonCopyable() = default;
    NonCopyable(NonCopyable const&) = delete;
    NonCopyable& operator=(NonCopyable const&) = delete;
};

struct TestClass {
    explicit TestClass(int x) : data(x) { }
    TestClass(TestClass const&) = delete;
    TestClass& operator=(TestClass const&) = delete;

    int& operator()(NonCopyable&&) & { return data; }
    int const& operator()(NonCopyable&&) const & { return data; }
    int volatile& operator()(NonCopyable&&) volatile & { return data; }
    int const volatile& operator()(NonCopyable&&) const volatile & { return data; }

    int&& operator()(NonCopyable&&) && { return std::move(data); }
    int const&& operator()(NonCopyable&&) const && { return std::move(data); }
    int volatile&& operator()(NonCopyable&&) volatile && { return std::move(data); }
    int const volatile&& operator()(NonCopyable&&) const volatile && { return std::move(data); }

    int data;
};

struct DerivedFromTestClass : TestClass {
    explicit DerivedFromTestClass(int x) : TestClass(x) { }
};


template <typename Signature,  typename Expect, typename Functor>
void test_b12(Functor&& f) {
    // Create the callable object.
    using ClassFunc = Signature TestClass::*;
    ClassFunc func_ptr = &TestClass::operator();

    // Create the dummy arg.
    NonCopyable arg;

    // Check that the deduced return type of invoke is what is expected.
    using DeducedReturnType = decltype(
        hana::apply(func_ptr, std::forward<Functor>(f), std::move(arg))
    );
    static_assert(std::is_same<DeducedReturnType, Expect>::value, "");

    // Check that result_of_t matches Expect.
    using ResultOfReturnType = typename std::result_of<ClassFunc&&(Functor&&, NonCopyable&&)>::type;
    static_assert(std::is_same<ResultOfReturnType, Expect>::value, "");

    // Run invoke and check the return value.
    DeducedReturnType ret = hana::apply(func_ptr, std::forward<Functor>(f), std::move(arg));
    BOOST_HANA_RUNTIME_CHECK(ret == 42);
}

template <typename Expect, typename Functor>
void test_b34(Functor&& f) {
    // Create the callable object.
    using ClassFunc = int TestClass::*;
    ClassFunc func_ptr = &TestClass::data;

    // Check that the deduced return type of invoke is what is expected.
    using DeducedReturnType = decltype(
        hana::apply(func_ptr, std::forward<Functor>(f))
    );
    static_assert(std::is_same<DeducedReturnType, Expect>::value, "");

    // Check that result_of_t matches Expect.
    using ResultOfReturnType = typename std::result_of<ClassFunc&&(Functor&&)>::type;
    static_assert(std::is_same<ResultOfReturnType, Expect>::value, "");

    // Run invoke and check the return value.
    DeducedReturnType ret = hana::apply(func_ptr, std::forward<Functor>(f));
    BOOST_HANA_RUNTIME_CHECK(ret == 42);
}

template <typename Expect, typename Functor>
void test_b5(Functor&& f) {
    NonCopyable arg;

    // Check that the deduced return type of invoke is what is expected.
    using DeducedReturnType = decltype(
        hana::apply(std::forward<Functor>(f), std::move(arg))
    );
    static_assert(std::is_same<DeducedReturnType, Expect>::value, "");

    // Check that result_of_t matches Expect.
    using ResultOfReturnType = typename std::result_of<Functor&&(NonCopyable&&)>::type;
    static_assert(std::is_same<ResultOfReturnType, Expect>::value, "");

    // Run invoke and check the return value.
    DeducedReturnType ret = hana::apply(std::forward<Functor>(f), std::move(arg));
    BOOST_HANA_RUNTIME_CHECK(ret == 42);
}

int& foo(NonCopyable&&) {
    static int data = 42;
    return data;
}

int main() {
    // Test normal usage with a function object
    {
        hana::test::_injection<0> f{};
        using hana::test::ct_eq;

        BOOST_HANA_CONSTANT_CHECK(hana::equal(
            hana::apply(f),
            f()
        ));
        BOOST_HANA_CONSTANT_CHECK(hana::equal(
            hana::apply(f, ct_eq<0>{}),
            f(ct_eq<0>{})
        ));
        BOOST_HANA_CONSTANT_CHECK(hana::equal(
            hana::apply(f, ct_eq<0>{}, ct_eq<1>{}),
            f(ct_eq<0>{}, ct_eq<1>{})
        ));
        BOOST_HANA_CONSTANT_CHECK(hana::equal(
            hana::apply(f, ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
            f(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{})
        ));
        BOOST_HANA_CONSTANT_CHECK(hana::equal(
            hana::apply(f, ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
            f(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{})
        ));

        // Make sure we can use apply with non-PODs
        hana::apply(f, nonpod<>{});
    }

    // Bullets 1 & 2 in the standard
    {
        TestClass cl(42);
        test_b12<int&(NonCopyable&&) &, int&>(cl);
        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
        test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
        test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);

        test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
        test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
        test_b12<int volatile&&(NonCopyable&&) volatile &&, int volatile&&>(std::move(cl));
        test_b12<int const volatile&&(NonCopyable&&) const volatile &&, int const volatile&&>(std::move(cl));
    }
    {
        DerivedFromTestClass cl(42);
        test_b12<int&(NonCopyable&&) &, int&>(cl);
        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
        test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
        test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);

        test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
        test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
        test_b12<int volatile&&(NonCopyable&&) volatile &&, int volatile&&>(std::move(cl));
        test_b12<int const volatile&&(NonCopyable&&) const volatile &&, int const volatile&&>(std::move(cl));
    }
    {
        TestClass cl_obj(42);
        TestClass *cl = &cl_obj;
        test_b12<int&(NonCopyable&&) &, int&>(cl);
        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
        test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
        test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
    }
    {
        DerivedFromTestClass cl_obj(42);
        DerivedFromTestClass *cl = &cl_obj;
        test_b12<int&(NonCopyable&&) &, int&>(cl);
        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
        test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
        test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
    }

    // Bullets 3 & 4 in the standard
    {
        using Fn = TestClass;
        Fn cl(42);
        test_b34<int&>(cl);
        test_b34<int const&>(static_cast<Fn const&>(cl));
        test_b34<int volatile&>(static_cast<Fn volatile&>(cl));
        test_b34<int const volatile&>(static_cast<Fn const volatile &>(cl));

        test_b34<int&&>(static_cast<Fn &&>(cl));
        test_b34<int const&&>(static_cast<Fn const&&>(cl));
        test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl));
        test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
    }
    {
        using Fn = DerivedFromTestClass;
        Fn cl(42);
        test_b34<int&>(cl);
        test_b34<int const&>(static_cast<Fn const&>(cl));
        test_b34<int volatile&>(static_cast<Fn volatile&>(cl));
        test_b34<int const volatile&>(static_cast<Fn const volatile &>(cl));

        test_b34<int&&>(static_cast<Fn &&>(cl));
        test_b34<int const&&>(static_cast<Fn const&&>(cl));
        test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl));
        test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
    }
    {
        using Fn = TestClass;
        Fn cl_obj(42);
        Fn* cl = &cl_obj;
        test_b34<int&>(cl);
        test_b34<int const&>(static_cast<Fn const*>(cl));
        test_b34<int volatile&>(static_cast<Fn volatile*>(cl));
        test_b34<int const volatile&>(static_cast<Fn const volatile *>(cl));
    }
    {
        using Fn = DerivedFromTestClass;
        Fn cl_obj(42);
        Fn* cl = &cl_obj;
        test_b34<int&>(cl);
        test_b34<int const&>(static_cast<Fn const*>(cl));
        test_b34<int volatile&>(static_cast<Fn volatile*>(cl));
        test_b34<int const volatile&>(static_cast<Fn const volatile *>(cl));
    }

    // Bullet 5 in the standard
    using FooType = int&(NonCopyable&&);
    {
        FooType& fn = foo;
        test_b5<int &>(fn);
    }
    {
        FooType* fn = foo;
        test_b5<int &>(fn);
    }
    {
        using Fn = TestClass;
        Fn cl(42);
        test_b5<int&>(cl);
        test_b5<int const&>(static_cast<Fn const&>(cl));
        test_b5<int volatile&>(static_cast<Fn volatile&>(cl));
        test_b5<int const volatile&>(static_cast<Fn const volatile &>(cl));

        test_b5<int&&>(static_cast<Fn &&>(cl));
        test_b5<int const&&>(static_cast<Fn const&&>(cl));
        test_b5<int volatile&&>(static_cast<Fn volatile&&>(cl));
        test_b5<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
    }
}
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/assert.hpp>
	6	#include <boost/hana/equal.hpp>
	7	#include <boost/hana/functional/apply.hpp>
	8
	9	#include <laws/base.hpp>
	10	#include <support/tracked.hpp>
	11
	12	#include <type_traits>
	13	#include <utility>
	14	namespace hana = boost::hana;
	15
	16
	17	template <int i = 0>
	18	struct nonpod : Tracked {
	19	nonpod() : Tracked{i} { }
	20	};
	21
	22	struct NonCopyable {
	23	NonCopyable() = default;
	24	NonCopyable(NonCopyable const&) = delete;
	25	NonCopyable& operator=(NonCopyable const&) = delete;
	26	};
	27
	28	struct TestClass {
	29	explicit TestClass(int x) : data(x) { }
	30	TestClass(TestClass const&) = delete;
	31	TestClass& operator=(TestClass const&) = delete;
	32
	33	int& operator()(NonCopyable&&) & { return data; }
	34	int const& operator()(NonCopyable&&) const & { return data; }
	35	int volatile& operator()(NonCopyable&&) volatile & { return data; }
	36	int const volatile& operator()(NonCopyable&&) const volatile & { return data; }
	37
	38	int&& operator()(NonCopyable&&) && { return std::move(data); }
	39	int const&& operator()(NonCopyable&&) const && { return std::move(data); }
	40	int volatile&& operator()(NonCopyable&&) volatile && { return std::move(data); }
	41	int const volatile&& operator()(NonCopyable&&) const volatile && { return std::move(data); }
	42
	43	int data;
	44	};
	45
	46	struct DerivedFromTestClass : TestClass {
	47	explicit DerivedFromTestClass(int x) : TestClass(x) { }
	48	};
	49
	50
	51	template <typename Signature, typename Expect, typename Functor>
	52	void test_b12(Functor&& f) {
	53	// Create the callable object.
	54	using ClassFunc = Signature TestClass::*;
	55	ClassFunc func_ptr = &TestClass::operator();
	56
	57	// Create the dummy arg.
	58	NonCopyable arg;
	59
	60	// Check that the deduced return type of invoke is what is expected.
	61	using DeducedReturnType = decltype(
	62	hana::apply(func_ptr, std::forward<Functor>(f), std::move(arg))
	63	);
	64	static_assert(std::is_same<DeducedReturnType, Expect>::value, "");
	65
66	// Check that result_of_t matches Expect.
67	using ResultOfReturnType = typename std::result_of<ClassFunc&&(Functor&&, NonCopyable&&)>::type;
68	static_assert(std::is_same<ResultOfReturnType, Expect>::value, "");
69
70	// Run invoke and check the return value.
71	DeducedReturnType ret = hana::apply(func_ptr, std::forward<Functor>(f), std::move(arg));
72	BOOST_HANA_RUNTIME_CHECK(ret == 42);
73	}
74
75	template <typename Expect, typename Functor>
76	void test_b34(Functor&& f) {
77	// Create the callable object.
78	using ClassFunc = int TestClass::*;
79	ClassFunc func_ptr = &TestClass::data;
80
81	// Check that the deduced return type of invoke is what is expected.
82	using DeducedReturnType = decltype(
83	hana::apply(func_ptr, std::forward<Functor>(f))
84	);
85	static_assert(std::is_same<DeducedReturnType, Expect>::value, "");
86
87	// Check that result_of_t matches Expect.
88	using ResultOfReturnType = typename std::result_of<ClassFunc&&(Functor&&)>::type;
89	static_assert(std::is_same<ResultOfReturnType, Expect>::value, "");
90
91	// Run invoke and check the return value.
92	DeducedReturnType ret = hana::apply(func_ptr, std::forward<Functor>(f));
93	BOOST_HANA_RUNTIME_CHECK(ret == 42);
94	}
95
96	template <typename Expect, typename Functor>
97	void test_b5(Functor&& f) {
98	NonCopyable arg;
99
100	// Check that the deduced return type of invoke is what is expected.
101	using DeducedReturnType = decltype(
102	hana::apply(std::forward<Functor>(f), std::move(arg))
103	);
104	static_assert(std::is_same<DeducedReturnType, Expect>::value, "");
105
106	// Check that result_of_t matches Expect.
107	using ResultOfReturnType = typename std::result_of<Functor&&(NonCopyable&&)>::type;
108	static_assert(std::is_same<ResultOfReturnType, Expect>::value, "");
109
110	// Run invoke and check the return value.
111	DeducedReturnType ret = hana::apply(std::forward<Functor>(f), std::move(arg));
112	BOOST_HANA_RUNTIME_CHECK(ret == 42);
113	}
114
115	int& foo(NonCopyable&&) {
116	static int data = 42;
117	return data;
118	}
119
120	int main() {
121	// Test normal usage with a function object
122	{
123	hana::test::_injection<0> f{};
124	using hana::test::ct_eq;
125
126	BOOST_HANA_CONSTANT_CHECK(hana::equal(
127	hana::apply(f),
128	f()
129	));
130	BOOST_HANA_CONSTANT_CHECK(hana::equal(
131	hana::apply(f, ct_eq<0>{}),
132	f(ct_eq<0>{})
133	));
134	BOOST_HANA_CONSTANT_CHECK(hana::equal(
135	hana::apply(f, ct_eq<0>{}, ct_eq<1>{}),
136	f(ct_eq<0>{}, ct_eq<1>{})
137	));
138	BOOST_HANA_CONSTANT_CHECK(hana::equal(
139	hana::apply(f, ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
140	f(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{})
141	));
142	BOOST_HANA_CONSTANT_CHECK(hana::equal(
143	hana::apply(f, ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
144	f(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{})
145	));
146
147	// Make sure we can use apply with non-PODs
148	hana::apply(f, nonpod<>{});
149	}
150
151	// Bullets 1 & 2 in the standard
152	{
153	TestClass cl(42);
154	test_b12<int&(NonCopyable&&) &, int&>(cl);
155	test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
156	test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
157	test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
158
159	test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
160	test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
161	test_b12<int volatile&&(NonCopyable&&) volatile &&, int volatile&&>(std::move(cl));
162	test_b12<int const volatile&&(NonCopyable&&) const volatile &&, int const volatile&&>(std::move(cl));
163	}
164	{
165	DerivedFromTestClass cl(42);
166	test_b12<int&(NonCopyable&&) &, int&>(cl);
167	test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
168	test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
169	test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
170
171	test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
172	test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
173	test_b12<int volatile&&(NonCopyable&&) volatile &&, int volatile&&>(std::move(cl));
174	test_b12<int const volatile&&(NonCopyable&&) const volatile &&, int const volatile&&>(std::move(cl));
175	}
176	{
177	TestClass cl_obj(42);
178	TestClass *cl = &cl_obj;
179	test_b12<int&(NonCopyable&&) &, int&>(cl);
180	test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
181	test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
182	test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
183	}
184	{
185	DerivedFromTestClass cl_obj(42);
186	DerivedFromTestClass *cl = &cl_obj;
187	test_b12<int&(NonCopyable&&) &, int&>(cl);
188	test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
189	test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
190	test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
191	}
192
193	// Bullets 3 & 4 in the standard
194	{
195	using Fn = TestClass;
196	Fn cl(42);
197	test_b34<int&>(cl);
198	test_b34<int const&>(static_cast<Fn const&>(cl));
199	test_b34<int volatile&>(static_cast<Fn volatile&>(cl));
200	test_b34<int const volatile&>(static_cast<Fn const volatile &>(cl));
201
202	test_b34<int&&>(static_cast<Fn &&>(cl));
203	test_b34<int const&&>(static_cast<Fn const&&>(cl));
204	test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl));
205	test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
206	}
207	{
208	using Fn = DerivedFromTestClass;
209	Fn cl(42);
210	test_b34<int&>(cl);
211	test_b34<int const&>(static_cast<Fn const&>(cl));
212	test_b34<int volatile&>(static_cast<Fn volatile&>(cl));
213	test_b34<int const volatile&>(static_cast<Fn const volatile &>(cl));
214
215	test_b34<int&&>(static_cast<Fn &&>(cl));
216	test_b34<int const&&>(static_cast<Fn const&&>(cl));
217	test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl));
218	test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
219	}
220	{
221	using Fn = TestClass;
222	Fn cl_obj(42);
223	Fn* cl = &cl_obj;
224	test_b34<int&>(cl);
225	test_b34<int const&>(static_cast<Fn const*>(cl));
226	test_b34<int volatile&>(static_cast<Fn volatile*>(cl));
227	test_b34<int const volatile&>(static_cast<Fn const volatile *>(cl));
228	}
229	{
230	using Fn = DerivedFromTestClass;
231	Fn cl_obj(42);
232	Fn* cl = &cl_obj;
233	test_b34<int&>(cl);
234	test_b34<int const&>(static_cast<Fn const*>(cl));
235	test_b34<int volatile&>(static_cast<Fn volatile*>(cl));
236	test_b34<int const volatile&>(static_cast<Fn const volatile *>(cl));
237	}
238
239	// Bullet 5 in the standard
240	using FooType = int&(NonCopyable&&);
241	{
242	FooType& fn = foo;
243	test_b5<int &>(fn);
244	}
245	{
246	FooType* fn = foo;
247	test_b5<int &>(fn);
248	}
249	{
250	using Fn = TestClass;
251	Fn cl(42);
252	test_b5<int&>(cl);
253	test_b5<int const&>(static_cast<Fn const&>(cl));
254	test_b5<int volatile&>(static_cast<Fn volatile&>(cl));
255	test_b5<int const volatile&>(static_cast<Fn const volatile &>(cl));
256
257	test_b5<int&&>(static_cast<Fn &&>(cl));
258	test_b5<int const&&>(static_cast<Fn const&&>(cl));
259	test_b5<int volatile&&>(static_cast<Fn volatile&&>(cl));
260	test_b5<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
261	}
262	}