]>
Commit | Line | Data |
---|---|---|
b32b8144 FG |
1 | // |
2 | // async_result.hpp | |
3 | // ~~~~~~~~~~~~~~~~ | |
4 | // | |
1e59de90 | 5 | // Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com) |
b32b8144 FG |
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_ASYNC_RESULT_HPP | |
12 | #define BOOST_ASIO_ASYNC_RESULT_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> | |
92f5a8d4 | 20 | #include <boost/asio/detail/variadic_templates.hpp> |
b32b8144 FG |
21 | |
22 | #include <boost/asio/detail/push_options.hpp> | |
23 | ||
24 | namespace boost { | |
25 | namespace asio { | |
26 | ||
92f5a8d4 TL |
27 | #if defined(BOOST_ASIO_HAS_CONCEPTS) \ |
28 | && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \ | |
29 | && defined(BOOST_ASIO_HAS_DECLTYPE) | |
30 | ||
31 | namespace detail { | |
32 | ||
33 | template <typename T> | |
34 | struct is_completion_signature : false_type | |
35 | { | |
36 | }; | |
37 | ||
38 | template <typename R, typename... Args> | |
39 | struct is_completion_signature<R(Args...)> : true_type | |
40 | { | |
41 | }; | |
42 | ||
1e59de90 TL |
43 | #if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) |
44 | ||
45 | template <typename R, typename... Args> | |
46 | struct is_completion_signature<R(Args...) &> : true_type | |
47 | { | |
48 | }; | |
49 | ||
50 | template <typename R, typename... Args> | |
51 | struct is_completion_signature<R(Args...) &&> : true_type | |
52 | { | |
53 | }; | |
54 | ||
55 | # if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) | |
56 | ||
57 | template <typename R, typename... Args> | |
58 | struct is_completion_signature<R(Args...) noexcept> : true_type | |
59 | { | |
60 | }; | |
61 | ||
62 | template <typename R, typename... Args> | |
63 | struct is_completion_signature<R(Args...) & noexcept> : true_type | |
64 | { | |
65 | }; | |
66 | ||
67 | template <typename R, typename... Args> | |
68 | struct is_completion_signature<R(Args...) && noexcept> : true_type | |
69 | { | |
70 | }; | |
71 | ||
72 | # endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) | |
73 | #endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) | |
74 | ||
75 | template <typename... T> | |
76 | struct are_completion_signatures : false_type | |
77 | { | |
78 | }; | |
79 | ||
80 | template <typename T0> | |
81 | struct are_completion_signatures<T0> | |
82 | : is_completion_signature<T0> | |
83 | { | |
84 | }; | |
85 | ||
86 | template <typename T0, typename... TN> | |
87 | struct are_completion_signatures<T0, TN...> | |
88 | : integral_constant<bool, ( | |
89 | is_completion_signature<T0>::value | |
90 | && are_completion_signatures<TN...>::value)> | |
91 | { | |
92 | }; | |
93 | ||
92f5a8d4 | 94 | template <typename T, typename... Args> |
1e59de90 | 95 | BOOST_ASIO_CONCEPT callable_with = requires(T&& t, Args&&... args) |
92f5a8d4 | 96 | { |
1e59de90 | 97 | static_cast<T&&>(t)(static_cast<Args&&>(args)...); |
92f5a8d4 TL |
98 | }; |
99 | ||
1e59de90 | 100 | template <typename T, typename... Signatures> |
92f5a8d4 TL |
101 | struct is_completion_handler_for : false_type |
102 | { | |
103 | }; | |
104 | ||
105 | template <typename T, typename R, typename... Args> | |
106 | struct is_completion_handler_for<T, R(Args...)> | |
107 | : integral_constant<bool, (callable_with<T, Args...>)> | |
108 | { | |
109 | }; | |
110 | ||
1e59de90 TL |
111 | #if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) |
112 | ||
113 | template <typename T, typename R, typename... Args> | |
114 | struct is_completion_handler_for<T, R(Args...) &> | |
115 | : integral_constant<bool, (callable_with<T&, Args...>)> | |
116 | { | |
117 | }; | |
118 | ||
119 | template <typename T, typename R, typename... Args> | |
120 | struct is_completion_handler_for<T, R(Args...) &&> | |
121 | : integral_constant<bool, (callable_with<T&&, Args...>)> | |
122 | { | |
123 | }; | |
124 | ||
125 | # if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) | |
126 | ||
127 | template <typename T, typename R, typename... Args> | |
128 | struct is_completion_handler_for<T, R(Args...) noexcept> | |
129 | : integral_constant<bool, (callable_with<T, Args...>)> | |
130 | { | |
131 | }; | |
132 | ||
133 | template <typename T, typename R, typename... Args> | |
134 | struct is_completion_handler_for<T, R(Args...) & noexcept> | |
135 | : integral_constant<bool, (callable_with<T&, Args...>)> | |
136 | { | |
137 | }; | |
138 | ||
139 | template <typename T, typename R, typename... Args> | |
140 | struct is_completion_handler_for<T, R(Args...) && noexcept> | |
141 | : integral_constant<bool, (callable_with<T&&, Args...>)> | |
142 | { | |
143 | }; | |
144 | ||
145 | # endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) | |
146 | #endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) | |
147 | ||
148 | template <typename T, typename Signature0, typename... SignatureN> | |
149 | struct is_completion_handler_for<T, Signature0, SignatureN...> | |
150 | : integral_constant<bool, ( | |
151 | is_completion_handler_for<T, Signature0>::value | |
152 | && is_completion_handler_for<T, SignatureN...>::value)> | |
153 | { | |
154 | }; | |
155 | ||
92f5a8d4 TL |
156 | } // namespace detail |
157 | ||
158 | template <typename T> | |
159 | BOOST_ASIO_CONCEPT completion_signature = | |
160 | detail::is_completion_signature<T>::value; | |
161 | ||
162 | #define BOOST_ASIO_COMPLETION_SIGNATURE \ | |
163 | ::boost::asio::completion_signature | |
164 | ||
1e59de90 | 165 | template <typename T, typename... Signatures> |
92f5a8d4 | 166 | BOOST_ASIO_CONCEPT completion_handler_for = |
1e59de90 TL |
167 | detail::are_completion_signatures<Signatures...>::value |
168 | && detail::is_completion_handler_for<T, Signatures...>::value; | |
92f5a8d4 | 169 | |
1e59de90 TL |
170 | #define BOOST_ASIO_COMPLETION_HANDLER_FOR(sig) \ |
171 | ::boost::asio::completion_handler_for<sig> | |
172 | #define BOOST_ASIO_COMPLETION_HANDLER_FOR2(sig0, sig1) \ | |
173 | ::boost::asio::completion_handler_for<sig0, sig1> | |
174 | #define BOOST_ASIO_COMPLETION_HANDLER_FOR3(sig0, sig1, sig2) \ | |
175 | ::boost::asio::completion_handler_for<sig0, sig1, sig2> | |
92f5a8d4 TL |
176 | |
177 | #else // defined(BOOST_ASIO_HAS_CONCEPTS) | |
178 | // && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
179 | // && defined(BOOST_ASIO_HAS_DECLTYPE) | |
180 | ||
181 | #define BOOST_ASIO_COMPLETION_SIGNATURE typename | |
1e59de90 TL |
182 | #define BOOST_ASIO_COMPLETION_HANDLER_FOR(sig) typename |
183 | #define BOOST_ASIO_COMPLETION_HANDLER_FOR2(sig0, sig1) typename | |
184 | #define BOOST_ASIO_COMPLETION_HANDLER_FOR3(sig0, sig1, sig2) typename | |
92f5a8d4 TL |
185 | |
186 | #endif // defined(BOOST_ASIO_HAS_CONCEPTS) | |
187 | // && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
188 | // && defined(BOOST_ASIO_HAS_DECLTYPE) | |
189 | ||
1e59de90 TL |
190 | namespace detail { |
191 | ||
192 | template <typename T> | |
193 | struct is_simple_completion_signature : false_type | |
194 | { | |
195 | }; | |
196 | ||
197 | template <typename T> | |
198 | struct simple_completion_signature; | |
199 | ||
200 | #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
201 | ||
202 | template <typename R, typename... Args> | |
203 | struct is_simple_completion_signature<R(Args...)> : true_type | |
204 | { | |
205 | }; | |
206 | ||
207 | template <typename... Signatures> | |
208 | struct are_simple_completion_signatures : false_type | |
209 | { | |
210 | }; | |
211 | ||
212 | template <typename Sig0> | |
213 | struct are_simple_completion_signatures<Sig0> | |
214 | : is_simple_completion_signature<Sig0> | |
215 | { | |
216 | }; | |
217 | ||
218 | template <typename Sig0, typename... SigN> | |
219 | struct are_simple_completion_signatures<Sig0, SigN...> | |
220 | : integral_constant<bool, ( | |
221 | is_simple_completion_signature<Sig0>::value | |
222 | && are_simple_completion_signatures<SigN...>::value)> | |
223 | { | |
224 | }; | |
225 | ||
226 | template <typename R, typename... Args> | |
227 | struct simple_completion_signature<R(Args...)> | |
228 | { | |
229 | typedef R type(Args...); | |
230 | }; | |
231 | ||
232 | #if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) | |
233 | ||
234 | template <typename R, typename... Args> | |
235 | struct simple_completion_signature<R(Args...) &> | |
236 | { | |
237 | typedef R type(Args...); | |
238 | }; | |
239 | ||
240 | template <typename R, typename... Args> | |
241 | struct simple_completion_signature<R(Args...) &&> | |
242 | { | |
243 | typedef R type(Args...); | |
244 | }; | |
245 | ||
246 | # if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) | |
247 | ||
248 | template <typename R, typename... Args> | |
249 | struct simple_completion_signature<R(Args...) noexcept> | |
250 | { | |
251 | typedef R type(Args...); | |
252 | }; | |
253 | ||
254 | template <typename R, typename... Args> | |
255 | struct simple_completion_signature<R(Args...) & noexcept> | |
256 | { | |
257 | typedef R type(Args...); | |
258 | }; | |
259 | ||
260 | template <typename R, typename... Args> | |
261 | struct simple_completion_signature<R(Args...) && noexcept> | |
262 | { | |
263 | typedef R type(Args...); | |
264 | }; | |
265 | ||
266 | # endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) | |
267 | #endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) | |
268 | ||
269 | #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
270 | ||
271 | template <typename R> | |
272 | struct is_simple_completion_signature<R()> : true_type | |
273 | { | |
274 | }; | |
275 | ||
276 | #define BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \ | |
277 | template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
278 | struct is_simple_completion_signature<R(BOOST_ASIO_VARIADIC_TARGS(n))> \ | |
279 | : true_type \ | |
280 | { \ | |
281 | }; \ | |
282 | /**/ | |
283 | BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF) | |
284 | #undef BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF | |
285 | ||
286 | template <typename Sig0 = void, typename Sig1 = void, | |
287 | typename Sig2 = void, typename = void> | |
288 | struct are_simple_completion_signatures : false_type | |
289 | { | |
290 | }; | |
291 | ||
292 | template <typename Sig0> | |
293 | struct are_simple_completion_signatures<Sig0> | |
294 | : is_simple_completion_signature<Sig0> | |
295 | { | |
296 | }; | |
297 | ||
298 | template <typename Sig0, typename Sig1> | |
299 | struct are_simple_completion_signatures<Sig0, Sig1> | |
300 | : integral_constant<bool, | |
301 | (is_simple_completion_signature<Sig0>::value | |
302 | && is_simple_completion_signature<Sig1>::value)> | |
303 | { | |
304 | }; | |
305 | ||
306 | template <typename Sig0, typename Sig1, typename Sig2> | |
307 | struct are_simple_completion_signatures<Sig0, Sig1, Sig2> | |
308 | : integral_constant<bool, | |
309 | (is_simple_completion_signature<Sig0>::value | |
310 | && is_simple_completion_signature<Sig1>::value | |
311 | && is_simple_completion_signature<Sig2>::value)> | |
312 | { | |
313 | }; | |
314 | ||
315 | template <> | |
316 | struct simple_completion_signature<void> | |
317 | { | |
318 | typedef void type; | |
319 | }; | |
320 | ||
321 | template <typename R> | |
322 | struct simple_completion_signature<R()> | |
323 | { | |
324 | typedef R type(); | |
325 | }; | |
326 | ||
327 | #define BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \ | |
328 | template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
329 | struct simple_completion_signature<R(BOOST_ASIO_VARIADIC_TARGS(n))> \ | |
330 | { \ | |
331 | typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \ | |
332 | }; \ | |
333 | /**/ | |
334 | BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF) | |
335 | #undef BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF | |
336 | ||
337 | #if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) | |
338 | ||
339 | template <typename R> | |
340 | struct simple_completion_signature<R() &> | |
341 | { | |
342 | typedef R type(); | |
343 | }; | |
344 | ||
345 | template <typename R> | |
346 | struct simple_completion_signature<R() &&> | |
347 | { | |
348 | typedef R type(); | |
349 | }; | |
350 | ||
351 | #define BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \ | |
352 | template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
353 | struct simple_completion_signature< \ | |
354 | R(BOOST_ASIO_VARIADIC_TARGS(n)) &> \ | |
355 | { \ | |
356 | typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \ | |
357 | }; \ | |
358 | \ | |
359 | template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
360 | struct simple_completion_signature< \ | |
361 | R(BOOST_ASIO_VARIADIC_TARGS(n)) &&> \ | |
362 | { \ | |
363 | typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \ | |
364 | }; \ | |
365 | /**/ | |
366 | BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF) | |
367 | #undef BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF | |
368 | ||
369 | # if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) | |
370 | ||
371 | template <typename R> | |
372 | struct simple_completion_signature<R() noexcept> | |
373 | { | |
374 | typedef R type(); | |
375 | }; | |
376 | ||
377 | template <typename R> | |
378 | struct simple_completion_signature<R() & noexcept> | |
379 | { | |
380 | typedef R type(); | |
381 | }; | |
382 | ||
383 | template <typename R> | |
384 | struct simple_completion_signature<R() && noexcept> | |
385 | { | |
386 | typedef R type(); | |
387 | }; | |
388 | ||
389 | #define BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \ | |
390 | template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
391 | struct simple_completion_signature< \ | |
392 | R(BOOST_ASIO_VARIADIC_TARGS(n)) noexcept> \ | |
393 | { \ | |
394 | typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \ | |
395 | }; \ | |
396 | \ | |
397 | template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
398 | struct simple_completion_signature< \ | |
399 | R(BOOST_ASIO_VARIADIC_TARGS(n)) & noexcept> \ | |
400 | { \ | |
401 | typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \ | |
402 | }; \ | |
403 | \ | |
404 | template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
405 | struct simple_completion_signature< \ | |
406 | R(BOOST_ASIO_VARIADIC_TARGS(n)) && noexcept> \ | |
407 | { \ | |
408 | typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \ | |
409 | }; \ | |
410 | /**/ | |
411 | BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF) | |
412 | #undef BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF | |
413 | ||
414 | # endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) | |
415 | #endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) | |
416 | ||
417 | #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
418 | ||
419 | #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \ | |
420 | || defined(GENERATING_DOCUMENTATION) | |
421 | ||
422 | # define BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS \ | |
423 | BOOST_ASIO_COMPLETION_SIGNATURE... Signatures | |
424 | ||
425 | # define BOOST_ASIO_COMPLETION_SIGNATURES_TSPECPARAMS \ | |
426 | BOOST_ASIO_COMPLETION_SIGNATURE... Signatures | |
427 | ||
428 | # define BOOST_ASIO_COMPLETION_SIGNATURES_TARGS Signatures... | |
429 | ||
430 | # define BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS \ | |
431 | typename boost::asio::detail::simple_completion_signature< \ | |
432 | Signatures>::type... | |
433 | ||
434 | #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
435 | // || defined(GENERATING_DOCUMENTATION) | |
436 | ||
437 | # define BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS \ | |
438 | typename Sig0 = void, \ | |
439 | typename Sig1 = void, \ | |
440 | typename Sig2 = void | |
441 | ||
442 | # define BOOST_ASIO_COMPLETION_SIGNATURES_TSPECPARAMS \ | |
443 | typename Sig0, \ | |
444 | typename Sig1, \ | |
445 | typename Sig2 | |
446 | ||
447 | # define BOOST_ASIO_COMPLETION_SIGNATURES_TARGS Sig0, Sig1, Sig2 | |
448 | ||
449 | # define BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS \ | |
450 | typename ::boost::asio::detail::simple_completion_signature<Sig0>::type, \ | |
451 | typename ::boost::asio::detail::simple_completion_signature<Sig1>::type, \ | |
452 | typename ::boost::asio::detail::simple_completion_signature<Sig2>::type | |
453 | ||
454 | #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
455 | // || defined(GENERATING_DOCUMENTATION) | |
456 | ||
457 | template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS> | |
458 | class completion_handler_async_result | |
b32b8144 FG |
459 | { |
460 | public: | |
b32b8144 | 461 | typedef CompletionToken completion_handler_type; |
b32b8144 | 462 | typedef void return_type; |
b32b8144 | 463 | |
1e59de90 | 464 | explicit completion_handler_async_result(completion_handler_type&) |
b32b8144 | 465 | { |
b32b8144 FG |
466 | } |
467 | ||
b32b8144 FG |
468 | return_type get() |
469 | { | |
b32b8144 FG |
470 | } |
471 | ||
1e59de90 | 472 | #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) |
b32b8144 | 473 | |
92f5a8d4 | 474 | template <typename Initiation, |
1e59de90 | 475 | BOOST_ASIO_COMPLETION_HANDLER_FOR(Signatures...) RawCompletionToken, |
92f5a8d4 TL |
476 | typename... Args> |
477 | static return_type initiate( | |
478 | BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
479 | BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, | |
480 | BOOST_ASIO_MOVE_ARG(Args)... args) | |
b32b8144 | 481 | { |
92f5a8d4 TL |
482 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( |
483 | BOOST_ASIO_MOVE_CAST(RawCompletionToken)(token), | |
484 | BOOST_ASIO_MOVE_CAST(Args)(args)...); | |
b32b8144 FG |
485 | } |
486 | ||
92f5a8d4 TL |
487 | #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) |
488 | ||
1e59de90 | 489 | template <typename Initiation, typename RawCompletionToken> |
92f5a8d4 TL |
490 | static return_type initiate( |
491 | BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
492 | BOOST_ASIO_MOVE_ARG(RawCompletionToken) token) | |
b32b8144 | 493 | { |
92f5a8d4 TL |
494 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( |
495 | BOOST_ASIO_MOVE_CAST(RawCompletionToken)(token)); | |
b32b8144 | 496 | } |
92f5a8d4 TL |
497 | |
498 | #define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \ | |
499 | template <typename Initiation, \ | |
1e59de90 | 500 | typename RawCompletionToken, \ |
92f5a8d4 TL |
501 | BOOST_ASIO_VARIADIC_TPARAMS(n)> \ |
502 | static return_type initiate( \ | |
503 | BOOST_ASIO_MOVE_ARG(Initiation) initiation, \ | |
504 | BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \ | |
505 | BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \ | |
506 | { \ | |
507 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \ | |
508 | BOOST_ASIO_MOVE_CAST(RawCompletionToken)(token), \ | |
509 | BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \ | |
510 | } \ | |
511 | /**/ | |
512 | BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF) | |
513 | #undef BOOST_ASIO_PRIVATE_INITIATE_DEF | |
514 | ||
515 | #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
516 | ||
1e59de90 TL |
517 | private: |
518 | completion_handler_async_result( | |
519 | const completion_handler_async_result&) BOOST_ASIO_DELETED; | |
520 | completion_handler_async_result& operator=( | |
521 | const completion_handler_async_result&) BOOST_ASIO_DELETED; | |
522 | }; | |
523 | ||
524 | } // namespace detail | |
525 | ||
526 | #if defined(GENERATING_DOCUMENTATION) | |
527 | ||
528 | /// An interface for customising the behaviour of an initiating function. | |
529 | /** | |
530 | * The async_result traits class is used for determining: | |
531 | * | |
532 | * @li the concrete completion handler type to be called at the end of the | |
533 | * asynchronous operation; | |
534 | * | |
535 | * @li the initiating function return type; and | |
536 | * | |
537 | * @li how the return value of the initiating function is obtained. | |
538 | * | |
539 | * The trait allows the handler and return types to be determined at the point | |
540 | * where the specific completion handler signature is known. | |
541 | * | |
542 | * This template may be specialised for user-defined completion token types. | |
543 | * The primary template assumes that the CompletionToken is the completion | |
544 | * handler. | |
545 | */ | |
546 | template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS> | |
547 | class async_result | |
548 | { | |
549 | public: | |
550 | /// The concrete completion handler type for the specific signature. | |
551 | typedef CompletionToken completion_handler_type; | |
552 | ||
553 | /// The return type of the initiating function. | |
554 | typedef void return_type; | |
555 | ||
556 | /// Construct an async result from a given handler. | |
557 | /** | |
558 | * When using a specalised async_result, the constructor has an opportunity | |
559 | * to initialise some state associated with the completion handler, which is | |
560 | * then returned from the initiating function. | |
561 | */ | |
562 | explicit async_result(completion_handler_type& h); | |
563 | ||
564 | /// Obtain the value to be returned from the initiating function. | |
565 | return_type get(); | |
566 | ||
567 | /// Initiate the asynchronous operation that will produce the result, and | |
568 | /// obtain the value to be returned from the initiating function. | |
569 | template <typename Initiation, typename RawCompletionToken, typename... Args> | |
570 | static return_type initiate( | |
571 | BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
572 | BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, | |
573 | BOOST_ASIO_MOVE_ARG(Args)... args); | |
574 | ||
575 | private: | |
576 | async_result(const async_result&) BOOST_ASIO_DELETED; | |
577 | async_result& operator=(const async_result&) BOOST_ASIO_DELETED; | |
578 | }; | |
579 | ||
580 | #else // defined(GENERATING_DOCUMENTATION) | |
581 | ||
582 | #if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) | |
583 | ||
584 | template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS> | |
585 | class async_result : | |
586 | public conditional< | |
587 | detail::are_simple_completion_signatures< | |
588 | BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>::value, | |
589 | detail::completion_handler_async_result< | |
590 | CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>, | |
591 | async_result<CompletionToken, | |
592 | BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS> | |
593 | >::type | |
594 | { | |
595 | public: | |
596 | typedef typename conditional< | |
597 | detail::are_simple_completion_signatures< | |
598 | BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>::value, | |
599 | detail::completion_handler_async_result< | |
600 | CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>, | |
601 | async_result<CompletionToken, | |
602 | BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS> | |
603 | >::type base_type; | |
604 | ||
605 | using base_type::base_type; | |
606 | ||
607 | private: | |
608 | async_result(const async_result&) BOOST_ASIO_DELETED; | |
609 | async_result& operator=(const async_result&) BOOST_ASIO_DELETED; | |
610 | }; | |
611 | ||
612 | #else // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) | |
613 | ||
614 | template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS> | |
615 | class async_result : | |
616 | public detail::completion_handler_async_result< | |
617 | CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS> | |
618 | { | |
619 | public: | |
620 | explicit async_result(CompletionToken& h) | |
621 | : detail::completion_handler_async_result< | |
622 | CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>(h) | |
623 | { | |
624 | } | |
625 | ||
92f5a8d4 TL |
626 | private: |
627 | async_result(const async_result&) BOOST_ASIO_DELETED; | |
628 | async_result& operator=(const async_result&) BOOST_ASIO_DELETED; | |
629 | }; | |
630 | ||
1e59de90 | 631 | #endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) |
92f5a8d4 | 632 | |
1e59de90 TL |
633 | template <BOOST_ASIO_COMPLETION_SIGNATURES_TSPECPARAMS> |
634 | class async_result<void, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS> | |
92f5a8d4 TL |
635 | { |
636 | // Empty. | |
b32b8144 FG |
637 | }; |
638 | ||
1e59de90 | 639 | #endif // defined(GENERATING_DOCUMENTATION) |
b32b8144 FG |
640 | |
641 | /// Helper template to deduce the handler type from a CompletionToken, capture | |
642 | /// a local copy of the handler, and then create an async_result for the | |
643 | /// handler. | |
1e59de90 | 644 | template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS> |
b32b8144 FG |
645 | struct async_completion |
646 | { | |
647 | /// The real handler type to be used for the asynchronous operation. | |
648 | typedef typename boost::asio::async_result< | |
649 | typename decay<CompletionToken>::type, | |
1e59de90 TL |
650 | BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>::completion_handler_type |
651 | completion_handler_type; | |
b32b8144 FG |
652 | |
653 | #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) | |
654 | /// Constructor. | |
655 | /** | |
656 | * The constructor creates the concrete completion handler and makes the link | |
657 | * between the handler and the asynchronous result. | |
658 | */ | |
659 | explicit async_completion(CompletionToken& token) | |
660 | : completion_handler(static_cast<typename conditional< | |
661 | is_same<CompletionToken, completion_handler_type>::value, | |
662 | completion_handler_type&, CompletionToken&&>::type>(token)), | |
663 | result(completion_handler) | |
664 | { | |
665 | } | |
666 | #else // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) | |
667 | explicit async_completion(typename decay<CompletionToken>::type& token) | |
668 | : completion_handler(token), | |
669 | result(completion_handler) | |
670 | { | |
671 | } | |
672 | ||
673 | explicit async_completion(const typename decay<CompletionToken>::type& token) | |
674 | : completion_handler(token), | |
675 | result(completion_handler) | |
676 | { | |
677 | } | |
678 | #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) | |
679 | ||
680 | /// A copy of, or reference to, a real handler object. | |
681 | #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) | |
682 | typename conditional< | |
683 | is_same<CompletionToken, completion_handler_type>::value, | |
684 | completion_handler_type&, completion_handler_type>::type completion_handler; | |
685 | #else // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) | |
686 | completion_handler_type completion_handler; | |
687 | #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) | |
688 | ||
689 | /// The result of the asynchronous operation's initiating function. | |
1e59de90 TL |
690 | async_result<typename decay<CompletionToken>::type, |
691 | BOOST_ASIO_COMPLETION_SIGNATURES_TARGS> result; | |
b32b8144 FG |
692 | }; |
693 | ||
694 | namespace detail { | |
695 | ||
1e59de90 | 696 | template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS> |
b32b8144 | 697 | struct async_result_helper |
1e59de90 TL |
698 | : async_result<typename decay<CompletionToken>::type, |
699 | BOOST_ASIO_COMPLETION_SIGNATURES_TARGS> | |
b32b8144 FG |
700 | { |
701 | }; | |
702 | ||
92f5a8d4 TL |
703 | struct async_result_memfns_base |
704 | { | |
705 | void initiate(); | |
706 | }; | |
b32b8144 | 707 | |
92f5a8d4 TL |
708 | template <typename T> |
709 | struct async_result_memfns_derived | |
710 | : T, async_result_memfns_base | |
711 | { | |
712 | }; | |
713 | ||
714 | template <typename T, T> | |
715 | struct async_result_memfns_check | |
716 | { | |
717 | }; | |
718 | ||
719 | template <typename> | |
720 | char (&async_result_initiate_memfn_helper(...))[2]; | |
721 | ||
722 | template <typename T> | |
723 | char async_result_initiate_memfn_helper( | |
724 | async_result_memfns_check< | |
725 | void (async_result_memfns_base::*)(), | |
726 | &async_result_memfns_derived<T>::initiate>*); | |
727 | ||
1e59de90 | 728 | template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS> |
92f5a8d4 TL |
729 | struct async_result_has_initiate_memfn |
730 | : integral_constant<bool, sizeof(async_result_initiate_memfn_helper< | |
1e59de90 TL |
731 | async_result<typename decay<CompletionToken>::type, |
732 | BOOST_ASIO_COMPLETION_SIGNATURES_TARGS> | |
92f5a8d4 TL |
733 | >(0)) != 1> |
734 | { | |
735 | }; | |
736 | ||
737 | } // namespace detail | |
b32b8144 FG |
738 | |
739 | #if defined(GENERATING_DOCUMENTATION) | |
740 | # define BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) \ | |
741 | void_or_deduced | |
1e59de90 TL |
742 | # define BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \ |
743 | void_or_deduced | |
744 | # define BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \ | |
745 | void_or_deduced | |
b32b8144 FG |
746 | #elif defined(_MSC_VER) && (_MSC_VER < 1500) |
747 | # define BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) \ | |
748 | typename ::boost::asio::detail::async_result_helper< \ | |
749 | ct, sig>::return_type | |
1e59de90 TL |
750 | # define BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \ |
751 | typename ::boost::asio::detail::async_result_helper< \ | |
752 | ct, sig0, sig1>::return_type | |
753 | # define BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \ | |
754 | typename ::boost::asio::detail::async_result_helper< \ | |
755 | ct, sig0, sig1, sig2>::return_type | |
b32b8144 FG |
756 | #define BOOST_ASIO_HANDLER_TYPE(ct, sig) \ |
757 | typename ::boost::asio::detail::async_result_helper< \ | |
758 | ct, sig>::completion_handler_type | |
1e59de90 TL |
759 | #define BOOST_ASIO_HANDLER_TYPE2(ct, sig0, sig1) \ |
760 | typename ::boost::asio::detail::async_result_helper< \ | |
761 | ct, sig0, sig1>::completion_handler_type | |
762 | #define BOOST_ASIO_HANDLER_TYPE3(ct, sig0, sig1, sig2) \ | |
763 | typename ::boost::asio::detail::async_result_helper< \ | |
764 | ct, sig0, sig1, sig2>::completion_handler_type | |
b32b8144 FG |
765 | #else |
766 | # define BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) \ | |
767 | typename ::boost::asio::async_result< \ | |
768 | typename ::boost::asio::decay<ct>::type, sig>::return_type | |
1e59de90 TL |
769 | # define BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \ |
770 | typename ::boost::asio::async_result< \ | |
771 | typename ::boost::asio::decay<ct>::type, sig0, sig1>::return_type | |
772 | # define BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \ | |
773 | typename ::boost::asio::async_result< \ | |
774 | typename ::boost::asio::decay<ct>::type, sig0, sig1, sig2>::return_type | |
b32b8144 FG |
775 | #define BOOST_ASIO_HANDLER_TYPE(ct, sig) \ |
776 | typename ::boost::asio::async_result< \ | |
777 | typename ::boost::asio::decay<ct>::type, sig>::completion_handler_type | |
1e59de90 TL |
778 | #define BOOST_ASIO_HANDLER_TYPE2(ct, sig0, sig1) \ |
779 | typename ::boost::asio::async_result< \ | |
780 | typename ::boost::asio::decay<ct>::type, \ | |
781 | sig0, sig1>::completion_handler_type | |
782 | #define BOOST_ASIO_HANDLER_TYPE3(ct, sig0, sig1, sig2) \ | |
783 | typename ::boost::asio::async_result< \ | |
784 | typename ::boost::asio::decay<ct>::type, \ | |
785 | sig0, sig1, sig2>::completion_handler_type | |
b32b8144 FG |
786 | #endif |
787 | ||
20effc67 | 788 | #if defined(GENERATING_DOCUMENTATION) |
92f5a8d4 TL |
789 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \ |
790 | auto | |
1e59de90 TL |
791 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \ |
792 | auto | |
793 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \ | |
794 | auto | |
92f5a8d4 TL |
795 | #elif defined(BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION) |
796 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \ | |
797 | auto | |
1e59de90 TL |
798 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \ |
799 | auto | |
800 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \ | |
801 | auto | |
92f5a8d4 TL |
802 | #else |
803 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \ | |
804 | BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) | |
1e59de90 TL |
805 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \ |
806 | BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) | |
807 | # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \ | |
808 | BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) | |
92f5a8d4 TL |
809 | #endif |
810 | ||
20effc67 | 811 | #if defined(GENERATING_DOCUMENTATION) |
92f5a8d4 TL |
812 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \ |
813 | void_or_deduced | |
1e59de90 TL |
814 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \ |
815 | void_or_deduced | |
816 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \ | |
817 | void_or_deduced | |
92f5a8d4 TL |
818 | #elif defined(BOOST_ASIO_HAS_DECLTYPE) |
819 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \ | |
820 | decltype expr | |
1e59de90 TL |
821 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \ |
822 | decltype expr | |
823 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \ | |
824 | decltype expr | |
92f5a8d4 TL |
825 | #else |
826 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \ | |
827 | BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) | |
1e59de90 TL |
828 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \ |
829 | BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) | |
830 | # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \ | |
831 | BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) | |
92f5a8d4 TL |
832 | #endif |
833 | ||
834 | #if defined(GENERATING_DOCUMENTATION) | |
835 | ||
836 | template <typename CompletionToken, | |
1e59de90 | 837 | completion_signature... Signatures, |
92f5a8d4 TL |
838 | typename Initiation, typename... Args> |
839 | void_or_deduced async_initiate( | |
840 | BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
841 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken), | |
842 | BOOST_ASIO_MOVE_ARG(Args)... args); | |
843 | ||
844 | #elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
845 | ||
846 | template <typename CompletionToken, | |
1e59de90 | 847 | BOOST_ASIO_COMPLETION_SIGNATURE... Signatures, |
92f5a8d4 | 848 | typename Initiation, typename... Args> |
1e59de90 TL |
849 | inline typename constraint< |
850 | detail::async_result_has_initiate_memfn< | |
851 | CompletionToken, Signatures...>::value, | |
852 | BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Signatures..., | |
92f5a8d4 | 853 | (async_result<typename decay<CompletionToken>::type, |
1e59de90 | 854 | Signatures...>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), |
92f5a8d4 TL |
855 | declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>(), |
856 | declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))>::type | |
857 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
858 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, | |
859 | BOOST_ASIO_MOVE_ARG(Args)... args) | |
860 | { | |
861 | return async_result<typename decay<CompletionToken>::type, | |
1e59de90 | 862 | Signatures...>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation), |
92f5a8d4 TL |
863 | BOOST_ASIO_MOVE_CAST(CompletionToken)(token), |
864 | BOOST_ASIO_MOVE_CAST(Args)(args)...); | |
865 | } | |
866 | ||
867 | template <typename CompletionToken, | |
1e59de90 | 868 | BOOST_ASIO_COMPLETION_SIGNATURE... Signatures, |
92f5a8d4 | 869 | typename Initiation, typename... Args> |
1e59de90 TL |
870 | inline typename constraint< |
871 | !detail::async_result_has_initiate_memfn< | |
872 | CompletionToken, Signatures...>::value, | |
873 | BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signatures...)>::type | |
92f5a8d4 TL |
874 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, |
875 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, | |
876 | BOOST_ASIO_MOVE_ARG(Args)... args) | |
877 | { | |
1e59de90 | 878 | async_completion<CompletionToken, Signatures...> completion(token); |
92f5a8d4 TL |
879 | |
880 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( | |
881 | BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken, | |
1e59de90 | 882 | Signatures...))(completion.completion_handler), |
92f5a8d4 TL |
883 | BOOST_ASIO_MOVE_CAST(Args)(args)...); |
884 | ||
885 | return completion.result.get(); | |
886 | } | |
887 | ||
888 | #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
889 | ||
890 | template <typename CompletionToken, | |
1e59de90 TL |
891 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, |
892 | typename Initiation> | |
893 | inline typename constraint< | |
894 | detail::async_result_has_initiate_memfn< | |
895 | CompletionToken, Sig0>::value, | |
896 | BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Sig0, | |
897 | (async_result<typename decay<CompletionToken>::type, | |
898 | Sig0>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), | |
899 | declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>())))>::type | |
900 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
901 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) | |
902 | { | |
903 | return async_result<typename decay<CompletionToken>::type, | |
904 | Sig0>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation), | |
905 | BOOST_ASIO_MOVE_CAST(CompletionToken)(token)); | |
906 | } | |
907 | ||
908 | template <typename CompletionToken, | |
909 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, | |
910 | BOOST_ASIO_COMPLETION_SIGNATURE Sig1, | |
92f5a8d4 | 911 | typename Initiation> |
1e59de90 TL |
912 | inline typename constraint< |
913 | detail::async_result_has_initiate_memfn< | |
914 | CompletionToken, Sig0, Sig1>::value, | |
915 | BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2(CompletionToken, Sig0, Sig1, | |
92f5a8d4 | 916 | (async_result<typename decay<CompletionToken>::type, |
1e59de90 | 917 | Sig0, Sig1>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), |
92f5a8d4 TL |
918 | declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>())))>::type |
919 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
920 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) | |
921 | { | |
922 | return async_result<typename decay<CompletionToken>::type, | |
1e59de90 | 923 | Sig0, Sig1>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation), |
92f5a8d4 TL |
924 | BOOST_ASIO_MOVE_CAST(CompletionToken)(token)); |
925 | } | |
926 | ||
927 | template <typename CompletionToken, | |
1e59de90 TL |
928 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, |
929 | BOOST_ASIO_COMPLETION_SIGNATURE Sig1, | |
930 | BOOST_ASIO_COMPLETION_SIGNATURE Sig2, | |
92f5a8d4 | 931 | typename Initiation> |
1e59de90 TL |
932 | inline typename constraint< |
933 | detail::async_result_has_initiate_memfn< | |
934 | CompletionToken, Sig0, Sig1, Sig2>::value, | |
935 | BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2, | |
936 | (async_result<typename decay<CompletionToken>::type, | |
937 | Sig0, Sig1, Sig2>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), | |
938 | declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>())))>::type | |
92f5a8d4 TL |
939 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, |
940 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) | |
941 | { | |
1e59de90 TL |
942 | return async_result<typename decay<CompletionToken>::type, |
943 | Sig0, Sig1, Sig2>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation), | |
944 | BOOST_ASIO_MOVE_CAST(CompletionToken)(token)); | |
945 | } | |
946 | ||
947 | template <typename CompletionToken, | |
948 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, | |
949 | typename Initiation> | |
950 | inline typename constraint< | |
951 | !detail::async_result_has_initiate_memfn< | |
952 | CompletionToken, Sig0>::value, | |
953 | BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Sig0)>::type | |
954 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
955 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) | |
956 | { | |
957 | async_completion<CompletionToken, Sig0> completion(token); | |
92f5a8d4 TL |
958 | |
959 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( | |
960 | BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken, | |
1e59de90 TL |
961 | Sig0))(completion.completion_handler)); |
962 | ||
963 | return completion.result.get(); | |
964 | } | |
965 | ||
966 | template <typename CompletionToken, | |
967 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, | |
968 | BOOST_ASIO_COMPLETION_SIGNATURE Sig1, | |
969 | typename Initiation> | |
970 | inline typename constraint< | |
971 | !detail::async_result_has_initiate_memfn< | |
972 | CompletionToken, Sig0, Sig1>::value, | |
973 | BOOST_ASIO_INITFN_RESULT_TYPE2(CompletionToken, Sig0, Sig1)>::type | |
974 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
975 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) | |
976 | { | |
977 | async_completion<CompletionToken, Sig0, Sig1> completion(token); | |
978 | ||
979 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( | |
980 | BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE2(CompletionToken, | |
981 | Sig0, Sig1))(completion.completion_handler)); | |
982 | ||
983 | return completion.result.get(); | |
984 | } | |
985 | ||
986 | template <typename CompletionToken, | |
987 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, | |
988 | BOOST_ASIO_COMPLETION_SIGNATURE Sig1, | |
989 | BOOST_ASIO_COMPLETION_SIGNATURE Sig2, | |
990 | typename Initiation> | |
991 | inline typename constraint< | |
992 | !detail::async_result_has_initiate_memfn< | |
993 | CompletionToken, Sig0, Sig1, Sig2>::value, | |
994 | BOOST_ASIO_INITFN_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2)>::type | |
995 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, | |
996 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) | |
997 | { | |
998 | async_completion<CompletionToken, Sig0, Sig1, Sig2> completion(token); | |
999 | ||
1000 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( | |
1001 | BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE3(CompletionToken, | |
1002 | Sig0, Sig1, Sig2))(completion.completion_handler)); | |
92f5a8d4 TL |
1003 | |
1004 | return completion.result.get(); | |
1005 | } | |
1006 | ||
1007 | #define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \ | |
1008 | template <typename CompletionToken, \ | |
1e59de90 TL |
1009 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \ |
1010 | typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
1011 | inline typename constraint< \ | |
1012 | detail::async_result_has_initiate_memfn< \ | |
1013 | CompletionToken, Sig0>::value, \ | |
1014 | BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE( \ | |
1015 | CompletionToken, Sig0, \ | |
1016 | (async_result<typename decay<CompletionToken>::type, \ | |
1017 | Sig0>::initiate( \ | |
1018 | declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), \ | |
1019 | declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>(), \ | |
1020 | BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \ | |
1021 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \ | |
1022 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ | |
1023 | BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \ | |
1024 | { \ | |
1025 | return async_result<typename decay<CompletionToken>::type, \ | |
1026 | Sig0>::initiate( \ | |
1027 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation), \ | |
1028 | BOOST_ASIO_MOVE_CAST(CompletionToken)(token), \ | |
1029 | BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \ | |
1030 | } \ | |
1031 | \ | |
1032 | template <typename CompletionToken, \ | |
1033 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \ | |
1034 | BOOST_ASIO_COMPLETION_SIGNATURE Sig1, \ | |
1035 | typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
1036 | inline typename constraint< \ | |
1037 | detail::async_result_has_initiate_memfn< \ | |
1038 | CompletionToken, Sig0, Sig1>::value, \ | |
1039 | BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2( \ | |
1040 | CompletionToken, Sig0, Sig1, \ | |
1041 | (async_result<typename decay<CompletionToken>::type, \ | |
1042 | Sig0, Sig1>::initiate( \ | |
1043 | declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), \ | |
1044 | declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>(), \ | |
1045 | BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \ | |
1046 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \ | |
1047 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ | |
1048 | BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \ | |
1049 | { \ | |
1050 | return async_result<typename decay<CompletionToken>::type, \ | |
1051 | Sig0, Sig1>::initiate( \ | |
1052 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation), \ | |
1053 | BOOST_ASIO_MOVE_CAST(CompletionToken)(token), \ | |
1054 | BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \ | |
1055 | } \ | |
1056 | \ | |
1057 | template <typename CompletionToken, \ | |
1058 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \ | |
1059 | BOOST_ASIO_COMPLETION_SIGNATURE Sig1, \ | |
1060 | BOOST_ASIO_COMPLETION_SIGNATURE Sig2, \ | |
92f5a8d4 | 1061 | typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ |
1e59de90 | 1062 | inline typename constraint< \ |
92f5a8d4 | 1063 | detail::async_result_has_initiate_memfn< \ |
1e59de90 TL |
1064 | CompletionToken, Sig0, Sig1, Sig2>::value, \ |
1065 | BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3( \ | |
1066 | CompletionToken, Sig0, Sig1, Sig2, \ | |
92f5a8d4 | 1067 | (async_result<typename decay<CompletionToken>::type, \ |
1e59de90 TL |
1068 | Sig0, Sig1, Sig2>::initiate( \ |
1069 | declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), \ | |
92f5a8d4 TL |
1070 | declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>(), \ |
1071 | BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \ | |
1072 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \ | |
1073 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ | |
1074 | BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \ | |
1075 | { \ | |
1076 | return async_result<typename decay<CompletionToken>::type, \ | |
1e59de90 TL |
1077 | Sig0, Sig1, Sig2>::initiate( \ |
1078 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation), \ | |
92f5a8d4 TL |
1079 | BOOST_ASIO_MOVE_CAST(CompletionToken)(token), \ |
1080 | BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \ | |
1081 | } \ | |
1082 | \ | |
1083 | template <typename CompletionToken, \ | |
1e59de90 | 1084 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \ |
92f5a8d4 | 1085 | typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ |
1e59de90 | 1086 | inline typename constraint< \ |
92f5a8d4 | 1087 | !detail::async_result_has_initiate_memfn< \ |
1e59de90 TL |
1088 | CompletionToken, Sig0>::value, \ |
1089 | BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Sig0)>::type \ | |
92f5a8d4 TL |
1090 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \ |
1091 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ | |
1092 | BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \ | |
1093 | { \ | |
1e59de90 TL |
1094 | async_completion<CompletionToken, \ |
1095 | Sig0> completion(token); \ | |
92f5a8d4 TL |
1096 | \ |
1097 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \ | |
1098 | BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken, \ | |
1e59de90 TL |
1099 | Sig0))(completion.completion_handler), \ |
1100 | BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \ | |
1101 | \ | |
1102 | return completion.result.get(); \ | |
1103 | } \ | |
1104 | \ | |
1105 | template <typename CompletionToken, \ | |
1106 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \ | |
1107 | BOOST_ASIO_COMPLETION_SIGNATURE Sig1, \ | |
1108 | typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
1109 | inline typename constraint< \ | |
1110 | !detail::async_result_has_initiate_memfn< \ | |
1111 | CompletionToken, Sig0, Sig1>::value, \ | |
1112 | BOOST_ASIO_INITFN_RESULT_TYPE2(CompletionToken, Sig0, Sig1)>::type \ | |
1113 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \ | |
1114 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ | |
1115 | BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \ | |
1116 | { \ | |
1117 | async_completion<CompletionToken, \ | |
1118 | Sig0, Sig1> completion(token); \ | |
1119 | \ | |
1120 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \ | |
1121 | BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE2(CompletionToken, \ | |
1122 | Sig0, Sig1))(completion.completion_handler), \ | |
1123 | BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \ | |
1124 | \ | |
1125 | return completion.result.get(); \ | |
1126 | } \ | |
1127 | \ | |
1128 | template <typename CompletionToken, \ | |
1129 | BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \ | |
1130 | BOOST_ASIO_COMPLETION_SIGNATURE Sig1, \ | |
1131 | BOOST_ASIO_COMPLETION_SIGNATURE Sig2, \ | |
1132 | typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ | |
1133 | inline typename constraint< \ | |
1134 | !detail::async_result_has_initiate_memfn< \ | |
1135 | CompletionToken, Sig0, Sig1, Sig2>::value, \ | |
1136 | BOOST_ASIO_INITFN_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2)>::type \ | |
1137 | async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \ | |
1138 | BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ | |
1139 | BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \ | |
1140 | { \ | |
1141 | async_completion<CompletionToken, \ | |
1142 | Sig0, Sig1, Sig2> completion(token); \ | |
1143 | \ | |
1144 | BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \ | |
1145 | BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE3(CompletionToken, \ | |
1146 | Sig0, Sig1, Sig2))(completion.completion_handler), \ | |
92f5a8d4 TL |
1147 | BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \ |
1148 | \ | |
1149 | return completion.result.get(); \ | |
1150 | } \ | |
1151 | /**/ | |
1152 | BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF) | |
1153 | #undef BOOST_ASIO_PRIVATE_INITIATE_DEF | |
1154 | ||
1155 | #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
1156 | ||
1157 | #if defined(BOOST_ASIO_HAS_CONCEPTS) \ | |
1158 | && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \ | |
1159 | && defined(BOOST_ASIO_HAS_DECLTYPE) | |
1160 | ||
1161 | namespace detail { | |
1162 | ||
1e59de90 | 1163 | template <typename... Signatures> |
92f5a8d4 TL |
1164 | struct initiation_archetype |
1165 | { | |
1e59de90 | 1166 | template <completion_handler_for<Signatures...> CompletionHandler> |
92f5a8d4 TL |
1167 | void operator()(CompletionHandler&&) const |
1168 | { | |
1169 | } | |
1170 | }; | |
1171 | ||
1172 | } // namespace detail | |
1173 | ||
1e59de90 | 1174 | template <typename T, typename... Signatures> |
f67539c2 | 1175 | BOOST_ASIO_CONCEPT completion_token_for = |
1e59de90 | 1176 | detail::are_completion_signatures<Signatures...>::value |
f67539c2 TL |
1177 | && |
1178 | requires(T&& t) | |
1179 | { | |
1e59de90 TL |
1180 | async_initiate<T, Signatures...>( |
1181 | detail::initiation_archetype<Signatures...>{}, t); | |
f67539c2 | 1182 | }; |
92f5a8d4 | 1183 | |
1e59de90 TL |
1184 | #define BOOST_ASIO_COMPLETION_TOKEN_FOR(sig) \ |
1185 | ::boost::asio::completion_token_for<sig> | |
1186 | #define BOOST_ASIO_COMPLETION_TOKEN_FOR2(sig0, sig1) \ | |
1187 | ::boost::asio::completion_token_for<sig0, sig1> | |
1188 | #define BOOST_ASIO_COMPLETION_TOKEN_FOR3(sig0, sig1, sig2) \ | |
1189 | ::boost::asio::completion_token_for<sig0, sig1, sig2> | |
92f5a8d4 TL |
1190 | |
1191 | #else // defined(BOOST_ASIO_HAS_CONCEPTS) | |
1192 | // && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
1193 | // && defined(BOOST_ASIO_HAS_DECLTYPE) | |
1194 | ||
1e59de90 TL |
1195 | #define BOOST_ASIO_COMPLETION_TOKEN_FOR(sig) typename |
1196 | #define BOOST_ASIO_COMPLETION_TOKEN_FOR2(sig0, sig1) typename | |
1197 | #define BOOST_ASIO_COMPLETION_TOKEN_FOR3(sig0, sig1, sig2) typename | |
92f5a8d4 TL |
1198 | |
1199 | #endif // defined(BOOST_ASIO_HAS_CONCEPTS) | |
1200 | // && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) | |
1201 | // && defined(BOOST_ASIO_HAS_DECLTYPE) | |
1202 | ||
1203 | namespace detail { | |
1204 | ||
92f5a8d4 TL |
1205 | template <typename T, typename = void> |
1206 | struct default_completion_token_impl | |
1207 | { | |
1208 | typedef void type; | |
1209 | }; | |
1210 | ||
1211 | template <typename T> | |
1212 | struct default_completion_token_impl<T, | |
20effc67 | 1213 | typename void_type<typename T::default_completion_token_type>::type> |
92f5a8d4 TL |
1214 | { |
1215 | typedef typename T::default_completion_token_type type; | |
1216 | }; | |
1217 | ||
1218 | } // namespace detail | |
1219 | ||
1220 | #if defined(GENERATING_DOCUMENTATION) | |
1221 | ||
1222 | /// Traits type used to determine the default completion token type associated | |
1223 | /// with a type (such as an executor). | |
1224 | /** | |
1225 | * A program may specialise this traits type if the @c T template parameter in | |
1226 | * the specialisation is a user-defined type. | |
1227 | * | |
1228 | * Specialisations of this trait may provide a nested typedef @c type, which is | |
1229 | * a default-constructible completion token type. | |
1230 | */ | |
1231 | template <typename T> | |
1232 | struct default_completion_token | |
1233 | { | |
1234 | /// If @c T has a nested type @c default_completion_token_type, | |
1235 | /// <tt>T::default_completion_token_type</tt>. Otherwise the typedef @c type | |
1236 | /// is not defined. | |
1237 | typedef see_below type; | |
1238 | }; | |
1239 | #else | |
1240 | template <typename T> | |
1241 | struct default_completion_token | |
1242 | : detail::default_completion_token_impl<T> | |
1243 | { | |
1244 | }; | |
1245 | #endif | |
1246 | ||
1247 | #if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) | |
1248 | ||
1249 | template <typename T> | |
1250 | using default_completion_token_t = typename default_completion_token<T>::type; | |
1251 | ||
1252 | #endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) | |
1253 | ||
1254 | #if defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) | |
1255 | ||
1256 | #define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e) \ | |
1257 | = typename ::boost::asio::default_completion_token<e>::type | |
1258 | #define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(e) \ | |
1259 | = typename ::boost::asio::default_completion_token<e>::type() | |
1260 | ||
1261 | #else // defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) | |
1262 | ||
1263 | #define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e) | |
1264 | #define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(e) | |
1265 | ||
1266 | #endif // defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) | |
1267 | ||
1268 | } // namespace asio | |
1269 | } // namespace boost | |
1270 | ||
1271 | #include <boost/asio/detail/pop_options.hpp> | |
1272 | ||
b32b8144 | 1273 | #endif // BOOST_ASIO_ASYNC_RESULT_HPP |