// // execution/bulk_execute.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_ASIO_EXECUTION_BULK_EXECUTE_HPP #define BOOST_ASIO_EXECUTION_BULK_EXECUTE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include #include #include #include #include #include #include #include #include #if defined(GENERATING_DOCUMENTATION) namespace boost { namespace asio { namespace execution { /// A customisation point that creates a bulk sender. /** * The name execution::bulk_execute denotes a customisation point * object. If is_convertible_v is true, then the expression * execution::bulk_execute(S, F, N) for some subexpressions * S, F, and N is expression-equivalent to: * * @li S.bulk_execute(F, N), if that expression is valid. If the * function selected does not execute N invocations of the function * object F on the executor S in bulk with forward progress * guarantee boost::asio::query(S, execution::bulk_guarantee), and * the result of that function does not model sender, the * program is ill-formed with no diagnostic required. * * @li Otherwise, bulk_execute(S, F, N), if that expression is valid, * with overload resolution performed in a context that includes the * declaration void bulk_execute(); and that does not include a * declaration of execution::bulk_execute. If the function selected * by overload resolution does not execute N invocations of the * function object F on the executor S in bulk with forward * progress guarantee boost::asio::query(E, * execution::bulk_guarantee), and the result of that function does not * model sender, the program is ill-formed with no diagnostic * required. * * @li Otherwise, if the types F and * executor_index_t> model invocable and * if boost::asio::query(S, execution::bulk_guarantee) equals * execution::bulk_guarantee.unsequenced, then * * - Evaluates DECAY_COPY(std::forward(F)) on the * calling thread to create a function object cf. [Note: * Additional copies of cf may subsequently be created. --end * note.] * * - For each value of i in N, cf(i) (or copy of * cf)) will be invoked at most once by an execution agent that is * unique for each value of i. * * - May block pending completion of one or more invocations of cf. * * - Synchronizes with (C++Std [intro.multithread]) the invocations of * cf. * * @li Otherwise, execution::bulk_execute(S, F, N) is ill-formed. */ inline constexpr unspecified bulk_execute = unspecified; /// A type trait that determines whether a @c bulk_execute expression is /// well-formed. /** * Class template @c can_bulk_execute is a trait that is derived from @c * true_type if the expression execution::bulk_execute(std::declval(), * std::declval(), std::declval) is well formed; otherwise @c * false_type. */ template struct can_bulk_execute : integral_constant { }; } // namespace execution } // namespace asio } // namespace boost #else // defined(GENERATING_DOCUMENTATION) namespace boost_asio_execution_bulk_execute_fn { using boost::asio::declval; using boost::asio::enable_if; using boost::asio::execution::bulk_guarantee_t; using boost::asio::execution::detail::bulk_sender; using boost::asio::execution::executor_index; using boost::asio::execution::is_sender; using boost::asio::is_convertible; using boost::asio::is_same; using boost::asio::remove_cvref; using boost::asio::result_of; using boost::asio::traits::bulk_execute_free; using boost::asio::traits::bulk_execute_member; using boost::asio::traits::static_require; void bulk_execute(); enum overload_type { call_member, call_free, adapter, ill_formed }; template struct call_traits { BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed); BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false); typedef void result_type; }; template struct call_traits::value >::type, typename enable_if< bulk_execute_member::is_valid >::type, typename enable_if< is_sender< typename bulk_execute_member::result_type >::value >::type> : bulk_execute_member { BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_member); }; template struct call_traits::value >::type, typename enable_if< !bulk_execute_member::is_valid >::type, typename enable_if< bulk_execute_free::is_valid >::type, typename enable_if< is_sender< typename bulk_execute_free::result_type >::value >::type> : bulk_execute_free { BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_free); }; template struct call_traits::value >::type, typename enable_if< !bulk_execute_member::is_valid >::type, typename enable_if< !bulk_execute_free::is_valid >::type, typename enable_if< is_sender::value >::type, typename enable_if< is_same< typename result_of< F(typename executor_index::type>::type) >::type, typename result_of< F(typename executor_index::type>::type) >::type >::value >::type, typename enable_if< static_require::is_valid >::type> { BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = adapter); BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false); typedef bulk_sender result_type; }; struct impl { #if defined(BOOST_ASIO_HAS_MOVE) template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == call_member, typename call_traits::result_type >::type operator()(S&& s, F&& f, N&& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return BOOST_ASIO_MOVE_CAST(S)(s).bulk_execute( BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == call_free, typename call_traits::result_type >::type operator()(S&& s, F&& f, N&& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return bulk_execute(BOOST_ASIO_MOVE_CAST(S)(s), BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == adapter, typename call_traits::result_type >::type operator()(S&& s, F&& f, N&& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return typename call_traits::result_type( BOOST_ASIO_MOVE_CAST(S)(s), BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } #else // defined(BOOST_ASIO_HAS_MOVE) template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == call_member, typename call_traits::result_type >::type operator()(S& s, const F& f, const N& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return s.bulk_execute(BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == call_member, typename call_traits::result_type >::type operator()(const S& s, const F& f, const N& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return s.bulk_execute(BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == call_free, typename call_traits::result_type >::type operator()(S& s, const F& f, const N& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return bulk_execute(s, BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == call_free, typename call_traits::result_type >::type operator()(const S& s, const F& f, const N& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return bulk_execute(s, BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == adapter, typename call_traits::result_type >::type operator()(S& s, const F& f, const N& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return typename call_traits::result_type( s, BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } template BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == adapter, typename call_traits::result_type >::type operator()(const S& s, const F& f, const N& n) const BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return typename call_traits::result_type( s, BOOST_ASIO_MOVE_CAST(F)(f), BOOST_ASIO_MOVE_CAST(N)(n)); } #endif // defined(BOOST_ASIO_HAS_MOVE) }; template struct static_instance { static const T instance; }; template const T static_instance::instance = {}; } // namespace boost_asio_execution_bulk_execute_fn namespace boost { namespace asio { namespace execution { namespace { static BOOST_ASIO_CONSTEXPR const boost_asio_execution_bulk_execute_fn::impl& bulk_execute = boost_asio_execution_bulk_execute_fn::static_instance<>::instance; } // namespace template struct can_bulk_execute : integral_constant::overload != boost_asio_execution_bulk_execute_fn::ill_formed> { }; #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) template constexpr bool can_bulk_execute_v = can_bulk_execute::value; #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) template struct is_nothrow_bulk_execute : integral_constant::is_noexcept> { }; #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) template constexpr bool is_nothrow_bulk_execute_v = is_nothrow_bulk_execute::value; #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) template struct bulk_execute_result { typedef typename boost_asio_execution_bulk_execute_fn::call_traits< S, void(F, N)>::result_type type; }; } // namespace execution } // namespace asio } // namespace boost #endif // defined(GENERATING_DOCUMENTATION) #include #endif // BOOST_ASIO_EXECUTION_BULK_EXECUTE_HPP