1 // 2 // execution/set_error.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_SET_ERROR_HPP 12 #define BOOST_ASIO_EXECUTION_SET_ERROR_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/traits/set_error_member.hpp> 21 #include <boost/asio/traits/set_error_free.hpp> 22 23 #include <boost/asio/detail/push_options.hpp> 24 25 #if defined(GENERATING_DOCUMENTATION) 26 27 namespace boost { 28 namespace asio { 29 namespace execution { 30 31 /// A customisation point that delivers an error notification to a receiver. 32 /** 33 * The name <tt>execution::set_error</tt> denotes a customisation point object. 34 * The expression <tt>execution::set_error(R, E)</tt> for some subexpressions 35 * <tt>R</tt> and <tt>E</tt> are expression-equivalent to: 36 * 37 * @li <tt>R.set_error(E)</tt>, if that expression is valid. If the function 38 * selected does not send the error <tt>E</tt> to the receiver <tt>R</tt>'s 39 * error channel, the program is ill-formed with no diagnostic required. 40 * 41 * @li Otherwise, <tt>set_error(R, E)</tt>, if that expression is valid, with 42 * overload resolution performed in a context that includes the declaration 43 * <tt>void set_error();</tt> and that does not include a declaration of 44 * <tt>execution::set_error</tt>. If the function selected by overload 45 * resolution does not send the error <tt>E</tt> to the receiver <tt>R</tt>'s 46 * error channel, the program is ill-formed with no diagnostic required. 47 * 48 * @li Otherwise, <tt>execution::set_error(R, E)</tt> is ill-formed. 49 */ 50 inline constexpr unspecified set_error = unspecified; 51 52 /// A type trait that determines whether a @c set_error expression is 53 /// well-formed. 54 /** 55 * Class template @c can_set_error is a trait that is derived from 56 * @c true_type if the expression <tt>execution::set_error(std::declval<R>(), 57 * std::declval<E>())</tt> is well formed; otherwise @c false_type. 58 */ 59 template <typename R, typename E> 60 struct can_set_error : 61 integral_constant<bool, automatically_determined> 62 { 63 }; 64 65 } // namespace execution 66 } // namespace asio 67 } // namespace boost 68 69 #else // defined(GENERATING_DOCUMENTATION) 70 71 namespace asio_execution_set_error_fn { 72 73 using boost::asio::decay; 74 using boost::asio::declval; 75 using boost::asio::enable_if; 76 using boost::asio::traits::set_error_free; 77 using boost::asio::traits::set_error_member; 78 79 void set_error(); 80 81 enum overload_type 82 { 83 call_member, 84 call_free, 85 ill_formed 86 }; 87 88 template <typename R, typename E, typename = void, typename = void> 89 struct call_traits 90 { 91 BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed); 92 BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false); 93 typedef void result_type; 94 }; 95 96 template <typename R, typename E> 97 struct call_traits<R, void(E), 98 typename enable_if< 99 set_error_member<R, E>::is_valid 100 >::type> : 101 set_error_member<R, E> 102 { 103 BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_member); 104 }; 105 106 template <typename R, typename E> 107 struct call_traits<R, void(E), 108 typename enable_if< 109 !set_error_member<R, E>::is_valid 110 >::type, 111 typename enable_if< 112 set_error_free<R, E>::is_valid 113 >::type> : 114 set_error_free<R, E> 115 { 116 BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_free); 117 }; 118 119 struct impl 120 { 121 #if defined(BOOST_ASIO_HAS_MOVE) 122 template <typename R, typename E> 123 BOOST_ASIO_CONSTEXPR typename enable_if< 124 call_traits<R, void(E)>::overload == call_member, 125 typename call_traits<R, void(E)>::result_type 126 >::type operator ()asio_execution_set_error_fn::impl127 operator()(R&& r, E&& e) const 128 BOOST_ASIO_NOEXCEPT_IF(( 129 call_traits<R, void(E)>::is_noexcept)) 130 { 131 return BOOST_ASIO_MOVE_CAST(R)(r).set_error(BOOST_ASIO_MOVE_CAST(E)(e)); 132 } 133 134 template <typename R, typename E> 135 BOOST_ASIO_CONSTEXPR typename enable_if< 136 call_traits<R, void(E)>::overload == call_free, 137 typename call_traits<R, void(E)>::result_type 138 >::type operator ()asio_execution_set_error_fn::impl139 operator()(R&& r, E&& e) const 140 BOOST_ASIO_NOEXCEPT_IF(( 141 call_traits<R, void(E)>::is_noexcept)) 142 { 143 return set_error(BOOST_ASIO_MOVE_CAST(R)(r), BOOST_ASIO_MOVE_CAST(E)(e)); 144 } 145 #else // defined(BOOST_ASIO_HAS_MOVE) 146 template <typename R, typename E> 147 BOOST_ASIO_CONSTEXPR typename enable_if< 148 call_traits<R&, void(const E&)>::overload == call_member, 149 typename call_traits<R&, void(const E&)>::result_type 150 >::type 151 operator()(R& r, const E& e) const 152 BOOST_ASIO_NOEXCEPT_IF(( 153 call_traits<R&, void(const E&)>::is_noexcept)) 154 { 155 return r.set_error(e); 156 } 157 158 template <typename R, typename E> 159 BOOST_ASIO_CONSTEXPR typename enable_if< 160 call_traits<const R&, void(const E&)>::overload == call_member, 161 typename call_traits<const R&, void(const E&)>::result_type 162 >::type 163 operator()(const R& r, const E& e) const 164 BOOST_ASIO_NOEXCEPT_IF(( 165 call_traits<const R&, void(const E&)>::is_noexcept)) 166 { 167 return r.set_error(e); 168 } 169 170 template <typename R, typename E> 171 BOOST_ASIO_CONSTEXPR typename enable_if< 172 call_traits<R&, void(const E&)>::overload == call_free, 173 typename call_traits<R&, void(const E&)>::result_type 174 >::type 175 operator()(R& r, const E& e) const 176 BOOST_ASIO_NOEXCEPT_IF(( 177 call_traits<R&, void(const E&)>::is_noexcept)) 178 { 179 return set_error(r, e); 180 } 181 182 template <typename R, typename E> 183 BOOST_ASIO_CONSTEXPR typename enable_if< 184 call_traits<const R&, void(const E&)>::overload == call_free, 185 typename call_traits<const R&, void(const E&)>::result_type 186 >::type 187 operator()(const R& r, const E& e) const 188 BOOST_ASIO_NOEXCEPT_IF(( 189 call_traits<const R&, void(const E&)>::is_noexcept)) 190 { 191 return set_error(r, e); 192 } 193 #endif // defined(BOOST_ASIO_HAS_MOVE) 194 }; 195 196 template <typename T = impl> 197 struct static_instance 198 { 199 static const T instance; 200 }; 201 202 template <typename T> 203 const T static_instance<T>::instance = {}; 204 205 } // namespace asio_execution_set_error_fn 206 namespace boost { 207 namespace asio { 208 namespace execution { 209 namespace { 210 211 static BOOST_ASIO_CONSTEXPR const asio_execution_set_error_fn::impl& 212 set_error = asio_execution_set_error_fn::static_instance<>::instance; 213 214 } // namespace 215 216 template <typename R, typename E> 217 struct can_set_error : 218 integral_constant<bool, 219 asio_execution_set_error_fn::call_traits<R, void(E)>::overload != 220 asio_execution_set_error_fn::ill_formed> 221 { 222 }; 223 224 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 225 226 template <typename R, typename E> 227 constexpr bool can_set_error_v = can_set_error<R, E>::value; 228 229 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 230 231 template <typename R, typename E> 232 struct is_nothrow_set_error : 233 integral_constant<bool, 234 asio_execution_set_error_fn::call_traits<R, void(E)>::is_noexcept> 235 { 236 }; 237 238 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 239 240 template <typename R, typename E> 241 constexpr bool is_nothrow_set_error_v 242 = is_nothrow_set_error<R, E>::value; 243 244 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) 245 246 } // namespace execution 247 } // namespace asio 248 } // namespace boost 249 250 #endif // defined(GENERATING_DOCUMENTATION) 251 252 #include <boost/asio/detail/pop_options.hpp> 253 254 #endif // BOOST_ASIO_EXECUTION_SET_ERROR_HPP 255