1 // 2 // execution/receiver.hpp 3 // ~~~~~~~~~~~~~~~~~~~~~~ 4 // 5 // Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 // 7 // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 // 10 11 #ifndef BOOST_ASIO_EXECUTION_RECEIVER_HPP 12 #define BOOST_ASIO_EXECUTION_RECEIVER_HPP 13 14 #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 # pragma once 16 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 18 #include <boost/asio/detail/config.hpp> 19 #include <boost/asio/detail/type_traits.hpp> 20 #include <boost/asio/detail/variadic_templates.hpp> 21 #include <boost/asio/execution/set_done.hpp> 22 #include <boost/asio/execution/set_error.hpp> 23 #include <boost/asio/execution/set_value.hpp> 24 25 #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) 26 # include <exception> 27 #else // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) 28 # include <boost/system/error_code.hpp> 29 #endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) 30 31 #if defined(BOOST_ASIO_HAS_DEDUCED_SET_DONE_FREE_TRAIT) \ 32 && defined(BOOST_ASIO_HAS_DEDUCED_SET_DONE_MEMBER_TRAIT) \ 33 && defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_FREE_TRAIT) \ 34 && defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT) \ 35 && defined(BOOST_ASIO_HAS_DEDUCED_SET_VALUE_FREE_TRAIT) \ 36 && defined(BOOST_ASIO_HAS_DEDUCED_SET_VALUE_MEMBER_TRAIT) \ 37 && defined(BOOST_ASIO_HAS_DEDUCED_RECEIVER_OF_FREE_TRAIT) \ 38 && defined(BOOST_ASIO_HAS_DEDUCED_RECEIVER_OF_MEMBER_TRAIT) 39 # define BOOST_ASIO_HAS_DEDUCED_EXECUTION_IS_RECEIVER_TRAIT 1 40 #endif // defined(BOOST_ASIO_HAS_DEDUCED_SET_DONE_FREE_TRAIT) 41 // && defined(BOOST_ASIO_HAS_DEDUCED_SET_DONE_MEMBER_TRAIT) 42 // && defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_FREE_TRAIT) 43 // && defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT) 44 // && defined(BOOST_ASIO_HAS_DEDUCED_SET_VALUE_FREE_TRAIT) 45 // && defined(BOOST_ASIO_HAS_DEDUCED_SET_VALUE_MEMBER_TRAIT) 46 // && defined(BOOST_ASIO_HAS_DEDUCED_RECEIVER_OF_FREE_TRAIT) 47 // && defined(BOOST_ASIO_HAS_DEDUCED_RECEIVER_OF_MEMBER_TRAIT) 48 49 #include <boost/asio/detail/push_options.hpp> 50 51 namespace boost { 52 namespace asio { 53 namespace execution { 54 namespace detail { 55 56 template <typename T, typename E> 57 struct is_receiver_base : 58 integral_constant<bool, 59 is_move_constructible<typename remove_cvref<T>::type>::value 60 && is_constructible<typename remove_cvref<T>::type, T>::value 61 > 62 { 63 }; 64 65 } // namespace detail 66 67 #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) 68 # define BOOST_ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT = std::exception_ptr 69 #else // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) 70 # define BOOST_ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT \ 71 = ::boost::system::error_code 72 #endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) 73 74 /// The is_receiver trait detects whether a type T satisfies the 75 /// execution::receiver concept. 76 /** 77 * Class template @c is_receiver is a type trait that is derived from @c 78 * true_type if the type @c T meets the concept definition for a receiver for 79 * error type @c E, otherwise @c false_type. 80 */ 81 template <typename T, typename E BOOST_ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT> 82 struct is_receiver : 83 #if defined(GENERATING_DOCUMENTATION) 84 integral_constant<bool, automatically_determined> 85 #else // defined(GENERATING_DOCUMENTATION) 86 conditional< 87 can_set_done<typename remove_cvref<T>::type>::value 88 && is_nothrow_set_done<typename remove_cvref<T>::type>::value 89 && can_set_error<typename remove_cvref<T>::type, E>::value 90 && is_nothrow_set_error<typename remove_cvref<T>::type, E>::value, 91 detail::is_receiver_base<T, E>, 92 false_type 93 >::type 94 #endif // defined(GENERATING_DOCUMENTATION) 95 { 96 }; 97 98 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 99 100 template <typename T, typename E BOOST_ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT> 101 BOOST_ASIO_CONSTEXPR const bool is_receiver_v = is_receiver<T, E>::value; 102 103 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 104 105 #if defined(BOOST_ASIO_HAS_CONCEPTS) 106 107 template <typename T, typename E BOOST_ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT> 108 BOOST_ASIO_CONCEPT receiver = is_receiver<T, E>::value; 109 110 #define BOOST_ASIO_EXECUTION_RECEIVER ::boost::asio::execution::receiver 111 112 #else // defined(BOOST_ASIO_HAS_CONCEPTS) 113 114 #define BOOST_ASIO_EXECUTION_RECEIVER typename 115 116 #endif // defined(BOOST_ASIO_HAS_CONCEPTS) 117 118 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \ 119 || defined(GENERATING_DOCUMENTATION) 120 121 /// The is_receiver_of trait detects whether a type T satisfies the 122 /// execution::receiver_of concept for some set of value arguments. 123 /** 124 * Class template @c is_receiver_of is a type trait that is derived from @c 125 * true_type if the type @c T meets the concept definition for a receiver for 126 * value arguments @c Vs, otherwise @c false_type. 127 */ 128 template <typename T, typename... Vs> 129 struct is_receiver_of : 130 #if defined(GENERATING_DOCUMENTATION) 131 integral_constant<bool, automatically_determined> 132 #else // defined(GENERATING_DOCUMENTATION) 133 conditional< 134 is_receiver<T>::value, 135 can_set_value<typename remove_cvref<T>::type, Vs...>, 136 false_type 137 >::type 138 #endif // defined(GENERATING_DOCUMENTATION) 139 { 140 }; 141 142 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 143 144 template <typename T, typename... Vs> 145 BOOST_ASIO_CONSTEXPR const bool is_receiver_of_v = 146 is_receiver_of<T, Vs...>::value; 147 148 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 149 150 #if defined(BOOST_ASIO_HAS_CONCEPTS) 151 152 template <typename T, typename... Vs> 153 BOOST_ASIO_CONCEPT receiver_of = is_receiver_of<T, Vs...>::value; 154 155 #define BOOST_ASIO_EXECUTION_RECEIVER_OF_0 \ 156 ::boost::asio::execution::receiver_of 157 158 #define BOOST_ASIO_EXECUTION_RECEIVER_OF_1(v) \ 159 ::boost::asio::execution::receiver_of<v> 160 161 #else // defined(BOOST_ASIO_HAS_CONCEPTS) 162 163 #define BOOST_ASIO_EXECUTION_RECEIVER_OF_0 typename 164 #define BOOST_ASIO_EXECUTION_RECEIVER_OF_1(v) typename 165 166 #endif // defined(BOOST_ASIO_HAS_CONCEPTS) 167 168 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) 169 // || defined(GENERATING_DOCUMENTATION) 170 171 template <typename T, typename = void, 172 typename = void, typename = void, typename = void, typename = void, 173 typename = void, typename = void, typename = void, typename = void> 174 struct is_receiver_of; 175 176 template <typename T> 177 struct is_receiver_of<T> : 178 conditional< 179 is_receiver<T>::value, 180 can_set_value<typename remove_cvref<T>::type>, 181 false_type 182 >::type 183 { 184 }; 185 186 #define BOOST_ASIO_PRIVATE_RECEIVER_OF_TRAITS_DEF(n) \ 187 template <typename T, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ 188 struct is_receiver_of<T, BOOST_ASIO_VARIADIC_TARGS(n)> : \ 189 conditional< \ 190 conditional<true, is_receiver<T>, void>::type::value, \ 191 can_set_value< \ 192 typename remove_cvref<T>::type, \ 193 BOOST_ASIO_VARIADIC_TARGS(n)>, \ 194 false_type \ 195 >::type \ 196 { \ 197 }; \ 198 /**/ 199 BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_RECEIVER_OF_TRAITS_DEF) 200 #undef BOOST_ASIO_PRIVATE_RECEIVER_OF_TRAITS_DEF 201 202 #define BOOST_ASIO_EXECUTION_RECEIVER_OF_0 typename 203 #define BOOST_ASIO_EXECUTION_RECEIVER_OF_1(v) typename 204 205 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) 206 // || defined(GENERATING_DOCUMENTATION) 207 208 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \ 209 || defined(GENERATING_DOCUMENTATION) 210 211 /// The is_nothrow_receiver_of trait detects whether a type T satisfies the 212 /// execution::receiver_of concept for some set of value arguments, with a 213 /// noexcept @c set_value operation. 214 /** 215 * Class template @c is_nothrow_receiver_of is a type trait that is derived 216 * from @c true_type if the type @c T meets the concept definition for a 217 * receiver for value arguments @c Vs, and the expression 218 * <tt>execution::set_value(declval<T>(), declval<Ts>()...)</tt> is noexcept, 219 * otherwise @c false_type. 220 */ 221 template <typename T, typename... Vs> 222 struct is_nothrow_receiver_of : 223 #if defined(GENERATING_DOCUMENTATION) 224 integral_constant<bool, automatically_determined> 225 #else // defined(GENERATING_DOCUMENTATION) 226 integral_constant<bool, 227 is_receiver_of<T, Vs...>::value 228 && is_nothrow_set_value<typename remove_cvref<T>::type, Vs...>::value 229 > 230 #endif // defined(GENERATING_DOCUMENTATION) 231 { 232 }; 233 234 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 235 236 template <typename T, typename... Vs> 237 BOOST_ASIO_CONSTEXPR const bool is_nothrow_receiver_of_v = 238 is_nothrow_receiver_of<T, Vs...>::value; 239 240 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 241 242 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) 243 // || defined(GENERATING_DOCUMENTATION) 244 245 template <typename T, typename = void, 246 typename = void, typename = void, typename = void, typename = void, 247 typename = void, typename = void, typename = void, typename = void> 248 struct is_nothrow_receiver_of; 249 250 template <typename T> 251 struct is_nothrow_receiver_of<T> : 252 integral_constant<bool, 253 is_receiver_of<T>::value 254 && is_nothrow_set_value<typename remove_cvref<T>::type>::value 255 > 256 { 257 }; 258 259 #define BOOST_ASIO_PRIVATE_NOTHROW_RECEIVER_OF_TRAITS_DEF(n) \ 260 template <typename T, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ 261 struct is_nothrow_receiver_of<T, BOOST_ASIO_VARIADIC_TARGS(n)> : \ 262 integral_constant<bool, \ 263 is_receiver_of<T, BOOST_ASIO_VARIADIC_TARGS(n)>::value \ 264 && is_nothrow_set_value<typename remove_cvref<T>::type, \ 265 BOOST_ASIO_VARIADIC_TARGS(n)>::value \ 266 > \ 267 { \ 268 }; \ 269 /**/ 270 BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_NOTHROW_RECEIVER_OF_TRAITS_DEF) 271 #undef BOOST_ASIO_PRIVATE_NOTHROW_RECEIVER_OF_TRAITS_DEF 272 273 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) 274 // || defined(GENERATING_DOCUMENTATION) 275 276 } // namespace execution 277 } // namespace asio 278 } // namespace boost 279 280 #include <boost/asio/detail/pop_options.hpp> 281 282 #endif // BOOST_ASIO_EXECUTION_RECEIVER_HPP 283