ceph/src/boost/boost/asio/async_result.hpp

   1 //
   2 // async_result.hpp
   3 // ~~~~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2022 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_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>
  20 #include <boost/asio/detail/variadic_templates.hpp>
  21
  22 #include <boost/asio/detail/push_options.hpp>
  23
  24 namespace boost {
  25 namespace asio {
  26
  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
  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
  94 template <typename T, typename... Args>
  95 BOOST_ASIO_CONCEPT callable_with = requires(T&& t, Args&&... args)
  96 {
  97   static_cast<T&&>(t)(static_cast<Args&&>(args)...);
  98 };
  99
 100 template <typename T, typename... Signatures>
 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
 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
 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
 165 template <typename T, typename... Signatures>
 166 BOOST_ASIO_CONCEPT completion_handler_for =
 167   detail::are_completion_signatures<Signatures...>::value
 168     && detail::is_completion_handler_for<T, Signatures...>::value;
 169
 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>
 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
 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
 185
 186 #endif // defined(BOOST_ASIO_HAS_CONCEPTS)
 187        //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 188        //   && defined(BOOST_ASIO_HAS_DECLTYPE)
 189
 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
 459 {
 460 public:
 461   typedef CompletionToken completion_handler_type;
 462   typedef void return_type;
 463
 464   explicit completion_handler_async_result(completion_handler_type&)
 465   {
 466   }
 467
 468   return_type get()
 469   {
 470   }
 471
 472 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 473
 474   template <typename Initiation,
 475       BOOST_ASIO_COMPLETION_HANDLER_FOR(Signatures...) RawCompletionToken,
 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)
 481   {
 482     BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
 483         BOOST_ASIO_MOVE_CAST(RawCompletionToken)(token),
 484         BOOST_ASIO_MOVE_CAST(Args)(args)...);
 485   }
 486
 487 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 488
 489   template <typename Initiation, typename RawCompletionToken>
 490   static return_type initiate(
 491       BOOST_ASIO_MOVE_ARG(Initiation) initiation,
 492       BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
 493   {
 494     BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
 495         BOOST_ASIO_MOVE_CAST(RawCompletionToken)(token));
 496   }
 497
 498 #define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
 499   template <typename Initiation, \
 500       typename RawCompletionToken, \
 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
 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
 626 private:
 627   async_result(const async_result&) BOOST_ASIO_DELETED;
 628   async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
 629 };
 630
 631 #endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 632
 633 template <BOOST_ASIO_COMPLETION_SIGNATURES_TSPECPARAMS>
 634 class async_result<void, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
 635 {
 636   // Empty.
 637 };
 638
 639 #endif // defined(GENERATING_DOCUMENTATION)
 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.
 644 template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
 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,
 650       BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>::completion_handler_type
 651         completion_handler_type;
 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.
 690   async_result<typename decay<CompletionToken>::type,
 691     BOOST_ASIO_COMPLETION_SIGNATURES_TARGS> result;
 692 };
 693
 694 namespace detail {
 695
 696 template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
 697 struct async_result_helper
 698   : async_result<typename decay<CompletionToken>::type,
 699       BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
 700 {
 701 };
 702
 703 struct async_result_memfns_base
 704 {
 705   void initiate();
 706 };
 707
 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
 728 template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
 729 struct async_result_has_initiate_memfn
 730   : integral_constant<bool, sizeof(async_result_initiate_memfn_helper<
 731       async_result<typename decay<CompletionToken>::type,
 732         BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
 733     >(0)) != 1>
 734 {
 735 };
 736
 737 } // namespace detail
 738
 739 #if defined(GENERATING_DOCUMENTATION)
 740 # define BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) \
 741   void_or_deduced
 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
 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
 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
 756 #define BOOST_ASIO_HANDLER_TYPE(ct, sig) \
 757   typename ::boost::asio::detail::async_result_helper< \
 758     ct, sig>::completion_handler_type
 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
 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
 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
 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
 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
 786 #endif
 787
 788 #if defined(GENERATING_DOCUMENTATION)
 789 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
 790   auto
 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
 795 #elif defined(BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION)
 796 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
 797   auto
 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
 802 #else
 803 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
 804   BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig)
 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)
 809 #endif
 810
 811 #if defined(GENERATING_DOCUMENTATION)
 812 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
 813   void_or_deduced
 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
 818 #elif defined(BOOST_ASIO_HAS_DECLTYPE)
 819 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
 820   decltype expr
 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
 825 #else
 826 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
 827   BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig)
 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)
 832 #endif
 833
 834 #if defined(GENERATING_DOCUMENTATION)
 835
 836 template <typename CompletionToken,
 837     completion_signature... Signatures,
 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,
 847     BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
 848     typename Initiation, typename... Args>
 849 inline typename constraint<
 850     detail::async_result_has_initiate_memfn<
 851       CompletionToken, Signatures...>::value,
 852     BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Signatures...,
 853       (async_result<typename decay<CompletionToken>::type,
 854         Signatures...>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(),
 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,
 862     Signatures...>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
 863       BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
 864       BOOST_ASIO_MOVE_CAST(Args)(args)...);
 865 }
 866
 867 template <typename CompletionToken,
 868     BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
 869     typename Initiation, typename... Args>
 870 inline typename constraint<
 871     !detail::async_result_has_initiate_memfn<
 872       CompletionToken, Signatures...>::value,
 873     BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signatures...)>::type
 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 {
 878   async_completion<CompletionToken, Signatures...> completion(token);
 879
 880   BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
 881       BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken,
 882         Signatures...))(completion.completion_handler),
 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,
 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,
 911     typename Initiation>
 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,
 916       (async_result<typename decay<CompletionToken>::type,
 917         Sig0, Sig1>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(),
 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,
 923     Sig0, Sig1>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
 924       BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
 925 }
 926
 927 template <typename CompletionToken,
 928     BOOST_ASIO_COMPLETION_SIGNATURE Sig0,
 929     BOOST_ASIO_COMPLETION_SIGNATURE Sig1,
 930     BOOST_ASIO_COMPLETION_SIGNATURE Sig2,
 931     typename Initiation>
 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
 939 async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
 940     BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token)
 941 {
 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);
 958
 959   BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
 960       BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken,
 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));
1003
1004   return completion.result.get();
1005 }
1006
1007 #define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
1008   template <typename CompletionToken, \
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, \
1061       typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
1062   inline typename constraint< \
1063       detail::async_result_has_initiate_memfn< \
1064         CompletionToken, Sig0, Sig1, Sig2>::value, \
1065       BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3( \
1066         CompletionToken, Sig0, Sig1, Sig2, \
1067         (async_result<typename decay<CompletionToken>::type, \
1068           Sig0, Sig1, Sig2>::initiate( \
1069             declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), \
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, \
1077       Sig0, Sig1, Sig2>::initiate( \
1078         BOOST_ASIO_MOVE_CAST(Initiation)(initiation), \
1079         BOOST_ASIO_MOVE_CAST(CompletionToken)(token), \
1080         BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
1081   } \
1082   \
1083   template <typename CompletionToken, \
1084       BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \
1085       typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
1086   inline typename constraint< \
1087       !detail::async_result_has_initiate_memfn< \
1088         CompletionToken, Sig0>::value, \
1089       BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Sig0)>::type \
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   { \
1094     async_completion<CompletionToken, \
1095       Sig0> completion(token); \
1096   \
1097     BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \
1098         BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken, \
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), \
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
1163 template <typename... Signatures>
1164 struct initiation_archetype
1165 {
1166   template <completion_handler_for<Signatures...> CompletionHandler>
1167   void operator()(CompletionHandler&&) const
1168   {
1169   }
1170 };
1171
1172 } // namespace detail
1173
1174 template <typename T, typename... Signatures>
1175 BOOST_ASIO_CONCEPT completion_token_for =
1176   detail::are_completion_signatures<Signatures...>::value
1177   &&
1178   requires(T&& t)
1179   {
1180     async_initiate<T, Signatures...>(
1181         detail::initiation_archetype<Signatures...>{}, t);
1182   };
1183
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>
1190
1191 #else // defined(BOOST_ASIO_HAS_CONCEPTS)
1192       //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
1193       //   && defined(BOOST_ASIO_HAS_DECLTYPE)
1194
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
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
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,
1213   typename void_type<typename T::default_completion_token_type>::type>
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
1273 #endif // BOOST_ASIO_ASYNC_RESULT_HPP