[libcxx] r242195 - Implement n4169 - Add invoke function template
Hal Finkel
hfinkel at anl.gov
Tue Jul 14 13:27:15 PDT 2015
----- Original Message -----
> From: "Eric Fiselier" <eric at efcs.ca>
> To: cfe-commits at cs.uiuc.edu
> Sent: Tuesday, July 14, 2015 3:16:15 PM
> Subject: [libcxx] r242195 - Implement n4169 - Add invoke function template
>
> Author: ericwf
> Date: Tue Jul 14 15:16:15 2015
> New Revision: 242195
>
> URL: http://llvm.org/viewvc/llvm-project?rev=242195&view=rev
> Log:
> Implement n4169 - Add invoke function template
>
> Added:
> libcxx/trunk/test/std/utilities/function.objects/func.invoke/
> libcxx/trunk/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
> Modified:
> libcxx/trunk/include/functional
> libcxx/trunk/www/cxx1z_status.html
>
> Modified: libcxx/trunk/include/functional
> URL:
> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/functional?rev=242195&r1=242194&r2=242195&view=diff
> ==============================================================================
> --- libcxx/trunk/include/functional (original)
> +++ libcxx/trunk/include/functional Tue Jul 14 15:16:15 2015
> @@ -2447,6 +2447,15 @@ struct _LIBCPP_TYPE_VIS_ONLY hash
> };
> #endif
>
> +
> +#if _LIBCPP_STD_VER > 14
> +template <class _Fn, class ..._Args>
> +result_of_t<_Fn&&(_Args&&...)>
> +invoke(_Fn&& __f, _Args&&... __args) {
> + return __invoke(_VSTD::forward<_Fn>(__f),
> _VSTD::forward<_Args>(__args)...);
> +}
> +#endif
> +
> // struct hash<T*> in <memory>
>
> _LIBCPP_END_NAMESPACE_STD
>
> Added:
> libcxx/trunk/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp?rev=242195&view=auto
> ==============================================================================
> ---
> libcxx/trunk/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
> (added)
> +++
> libcxx/trunk/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
> Tue Jul 14 15:16:15 2015
> @@ -0,0 +1,268 @@
> +//===----------------------------------------------------------------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +// UNSUPPORTED: c++98, c++03, c++11, c++14
> +
> +// <functional>
> +
> +// template <class F, class ...Args>
> +// result_of_t<F&&(Args&&...)> invoke(F&&, Args&&...);
> +
> +/// C++14 [func.def] 20.9.0
> +/// (1) The following definitions apply to this Clause:
> +/// (2) A call signature is the name of a return type followed by a
> parenthesized
> +/// comma-separated list of zero or more argument types.
> +/// (3) A callable type is a function object type (20.9) or a
> pointer to member.
> +/// (4) A callable object is an object of a callable type.
> +/// (5) A call wrapper type is a type that holds a callable object
> and supports
> +/// a call operation that forwards to that object.
> +/// (6) A call wrapper is an object of a call wrapper type.
> +/// (7) A target object is the callable object held by a call
> wrapper.
> +
> +/// C++14 [func.require] 20.9.1
> +///
> +/// Define INVOKE (f, t1, t2, ..., tN) as follows:
> +/// (1.1) â (t1.*f)(t2, ..., tN) when f is a pointer to a member
Non-ASCII characters here?
-Hal
> function of a class T and t1 is an object of
> +/// type T or a reference to an object of type T or a reference to
> an object of a type derived from T;
> +/// (1.2) â ((*t1).*f)(t2, ..., tN) when f is a pointer to a
> member function of a class T and t1 is not one of
> +/// the types described in the previous item;
> +/// (1.3) â t1.*f when N == 1 and f is a pointer to member data
> of a class T and t1 is an object of type T or a
> +/// reference to an object of type T or a reference to an object
> of a type derived from T;
> +/// (1.4) â (*t1).*f when N == 1 and f is a pointer to member
> data of a class T and t1 is not one of the types
> +/// described in the previous item;
> +/// (1.5) â f(t1, t2, ..., tN) in all other cases.
> +
> +#include <functional>
> +#include <type_traits>
> +#include <cassert>
> +
> +struct NonCopyable {
> + NonCopyable() {}
> +private:
> + NonCopyable(NonCopyable const&) = delete;
> + NonCopyable& operator=(NonCopyable const&) = delete;
> +};
> +
> +struct TestClass {
> + explicit TestClass(int x) : data(x) {}
> +
> + 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;
> +private:
> + TestClass(TestClass const&) = delete;
> + TestClass& operator=(TestClass const&) = delete;
> +};
> +
> +struct DerivedFromTestClass : public TestClass {
> + explicit DerivedFromTestClass(int x) : TestClass(x) {}
> +};
> +
> +int& foo(NonCopyable&&) {
> + static int data = 42;
> + return data;
> +}
> +
> +template <class Signature, class Expect, class Functor>
> +void test_b12(Functor&& f) {
> + // Create the callable object.
> + typedef Signature TestClass::*ClassFunc;
> + ClassFunc func_ptr = &TestClass::operator();
> +
> + // Create the dummy arg.
> + NonCopyable arg;
> +
> + // Check that the deduced return type of invoke is what is
> expected.
> + typedef decltype(
> + std::invoke(func_ptr, std::forward<Functor>(f),
> std::move(arg))
> + ) DeducedReturnType;
> + static_assert((std::is_same<DeducedReturnType, Expect>::value),
> "");
> +
> + // Check that result_of_t matches Expect.
> + typedef typename std::result_of<ClassFunc&&(Functor&&,
> NonCopyable&&)>::type
> + ResultOfReturnType;
> + static_assert((std::is_same<ResultOfReturnType, Expect>::value),
> "");
> +
> + // Run invoke and check the return value.
> + DeducedReturnType ret =
> + std::invoke(func_ptr, std::forward<Functor>(f),
> std::move(arg));
> + assert(ret == 42);
> +}
> +
> +template <class Expect, class Functor>
> +void test_b34(Functor&& f) {
> + // Create the callable object.
> + typedef int TestClass::*ClassFunc;
> + ClassFunc func_ptr = &TestClass::data;
> +
> + // Check that the deduced return type of invoke is what is
> expected.
> + typedef decltype(
> + std::invoke(func_ptr, std::forward<Functor>(f))
> + ) DeducedReturnType;
> + static_assert((std::is_same<DeducedReturnType, Expect>::value),
> "");
> +
> + // Check that result_of_t matches Expect.
> + typedef typename std::result_of<ClassFunc&&(Functor&&)>::type
> + ResultOfReturnType;
> + static_assert((std::is_same<ResultOfReturnType, Expect>::value),
> "");
> +
> + // Run invoke and check the return value.
> + DeducedReturnType ret =
> + std::invoke(func_ptr, std::forward<Functor>(f));
> + assert(ret == 42);
> +}
> +
> +template <class Expect, class Functor>
> +void test_b5(Functor&& f) {
> + NonCopyable arg;
> +
> + // Check that the deduced return type of invoke is what is
> expected.
> + typedef decltype(
> + std::invoke(std::forward<Functor>(f), std::move(arg))
> + ) DeducedReturnType;
> + static_assert((std::is_same<DeducedReturnType, Expect>::value),
> "");
> +
> + // Check that result_of_t matches Expect.
> + typedef typename std::result_of<Functor&&(NonCopyable&&)>::type
> + ResultOfReturnType;
> + static_assert((std::is_same<ResultOfReturnType, Expect>::value),
> "");
> +
> + // Run invoke and check the return value.
> + DeducedReturnType ret = std::invoke(std::forward<Functor>(f),
> std::move(arg));
> + assert(ret == 42);
> +}
> +
> +void bullet_one_two_tests() {
> + {
> + 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);
> + }
> +}
> +
> +void bullet_three_four_tests() {
> + {
> + typedef TestClass Fn;
> + 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));
> + }
> + {
> + typedef DerivedFromTestClass Fn;
> + 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));
> + }
> + {
> + typedef TestClass Fn;
> + 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));
> + }
> + {
> + typedef DerivedFromTestClass Fn;
> + 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));
> + }
> +}
> +
> +void bullet_five_tests() {
> + using FooType = int&(NonCopyable&&);
> + {
> + FooType& fn = foo;
> + test_b5<int &>(fn);
> + }
> + {
> + FooType* fn = foo;
> + test_b5<int &>(fn);
> + }
> + {
> + typedef TestClass Fn;
> + 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));
> + }
> +}
> +
> +int main() {
> + bullet_one_two_tests();
> + bullet_three_four_tests();
> + bullet_five_tests();
> +}
>
> Modified: libcxx/trunk/www/cxx1z_status.html
> URL:
> http://llvm.org/viewvc/llvm-project/libcxx/trunk/www/cxx1z_status.html?rev=242195&r1=242194&r2=242195&view=diff
> ==============================================================================
> --- libcxx/trunk/www/cxx1z_status.html (original)
> +++ libcxx/trunk/www/cxx1z_status.html Tue Jul 14 15:16:15 2015
> @@ -54,7 +54,7 @@
> -->
> <tr><td><a
> href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3911">N3911</a></td><td>LWG</td></td><td>TransformationTrait
> Alias
> <code>void_t</code>.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
> <tr><td><a
> href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4089">N4089</a></td><td>LWG</td></td><td>Safe
> conversions in
> <code>unique_ptr<T[]></code>.</td><td>Urbana</td><td></td><td></td></tr>
> - <tr><td><a
> href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4169">N4169</a></td><td>LWG</td></td><td>A
> proposal to add invoke function
> template</td><td>Urbana</td><td></td><td></td></tr>
> + <tr><td><a
> href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4169">N4169</a></td><td>LWG</td></td><td>A
> proposal to add invoke function
> template</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
> <tr><td><a
> href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4190">N4190</a></td></td><td>LWG</td><td>Removing
> auto_ptr, random_shuffle(), And Old <functional>
> Stuff.</td><td>Urbana</td><td></td><td></td></tr>
> <tr><td><a
> href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4258">N4258</a></td><td>LWG</td></td><td>Cleaning-up
> noexcept in the Library.</td><td>Urbana</td><td>In
> progress</td><td>3.7</td></tr>
> <tr><td><a
> href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4259">N4259</a></td><td>CWG</td></td><td>Wording
> for
> std::uncaught_exceptions</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
>
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>
--
Hal Finkel
Assistant Computational Scientist
Leadership Computing Facility
Argonne National Laboratory
More information about the cfe-commits
mailing list