Thanks, Removed the non-ASCII characters in invoke.pass.cpp in r242197. On Tue, Jul 14, 2015 at 4:27 PM, Hal Finkel <[email protected]> wrote: > ----- Original Message ----- >> From: "Eric Fiselier" <[email protected]> >> To: [email protected] >> 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 >> [email protected] >> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits >> > > -- > Hal Finkel > Assistant Computational Scientist > Leadership Computing Facility > Argonne National Laboratory
_______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
