----- Original Message ----- > From: "Eric Fiselier" <e...@efcs.ca> > To: cfe-commits@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@cs.uiuc.edu > http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits > -- Hal Finkel Assistant Computational Scientist Leadership Computing Facility Argonne National Laboratory _______________________________________________ cfe-commits mailing list cfe-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits