ceph/src/boost/boost/asio/detail/bind_handler.hpp

   1 //
   2 // detail/bind_handler.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_DETAIL_BIND_HANDLER_HPP
  12 #define BOOST_ASIO_DETAIL_BIND_HANDLER_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/associator.hpp>
  20 #include <boost/asio/detail/handler_alloc_helpers.hpp>
  21 #include <boost/asio/detail/handler_cont_helpers.hpp>
  22 #include <boost/asio/detail/handler_invoke_helpers.hpp>
  23 #include <boost/asio/detail/type_traits.hpp>
  24
  25 #include <boost/asio/detail/push_options.hpp>
  26
  27 namespace boost {
  28 namespace asio {
  29 namespace detail {
  30
  31 template <typename Handler>
  32 class binder0
  33 {
  34 public:
  35   template <typename T>
  36   binder0(int, BOOST_ASIO_MOVE_ARG(T) handler)
  37     : handler_(BOOST_ASIO_MOVE_CAST(T)(handler))
  38   {
  39   }
  40
  41   binder0(Handler& handler)
  42     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
  43   {
  44   }
  45
  46 #if defined(BOOST_ASIO_HAS_MOVE)
  47   binder0(const binder0& other)
  48     : handler_(other.handler_)
  49   {
  50   }
  51
  52   binder0(binder0&& other)
  53     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_))
  54   {
  55   }
  56 #endif // defined(BOOST_ASIO_HAS_MOVE)
  57
  58   void operator()()
  59   {
  60     BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
  61   }
  62
  63   void operator()() const
  64   {
  65     handler_();
  66   }
  67
  68 //private:
  69   Handler handler_;
  70 };
  71
  72 template <typename Handler>
  73 inline asio_handler_allocate_is_deprecated
  74 asio_handler_allocate(std::size_t size,
  75     binder0<Handler>* this_handler)
  76 {
  77 #if defined(BOOST_ASIO_NO_DEPRECATED)
  78   boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
  79   return asio_handler_allocate_is_no_longer_used();
  80 #else // defined(BOOST_ASIO_NO_DEPRECATED)
  81   return boost_asio_handler_alloc_helpers::allocate(
  82       size, this_handler->handler_);
  83 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
  84 }
  85
  86 template <typename Handler>
  87 inline asio_handler_deallocate_is_deprecated
  88 asio_handler_deallocate(void* pointer, std::size_t size,
  89     binder0<Handler>* this_handler)
  90 {
  91   boost_asio_handler_alloc_helpers::deallocate(
  92       pointer, size, this_handler->handler_);
  93 #if defined(BOOST_ASIO_NO_DEPRECATED)
  94   return asio_handler_deallocate_is_no_longer_used();
  95 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
  96 }
  97
  98 template <typename Handler>
  99 inline bool asio_handler_is_continuation(
 100     binder0<Handler>* this_handler)
 101 {
 102   return boost_asio_handler_cont_helpers::is_continuation(
 103       this_handler->handler_);
 104 }
 105
 106 template <typename Function, typename Handler>
 107 inline asio_handler_invoke_is_deprecated
 108 asio_handler_invoke(Function& function,
 109     binder0<Handler>* this_handler)
 110 {
 111   boost_asio_handler_invoke_helpers::invoke(
 112       function, this_handler->handler_);
 113 #if defined(BOOST_ASIO_NO_DEPRECATED)
 114   return asio_handler_invoke_is_no_longer_used();
 115 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 116 }
 117
 118 template <typename Function, typename Handler>
 119 inline asio_handler_invoke_is_deprecated
 120 asio_handler_invoke(const Function& function,
 121     binder0<Handler>* this_handler)
 122 {
 123   boost_asio_handler_invoke_helpers::invoke(
 124       function, this_handler->handler_);
 125 #if defined(BOOST_ASIO_NO_DEPRECATED)
 126   return asio_handler_invoke_is_no_longer_used();
 127 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 128 }
 129
 130 template <typename Handler>
 131 inline binder0<typename decay<Handler>::type> bind_handler(
 132     BOOST_ASIO_MOVE_ARG(Handler) handler)
 133 {
 134   return binder0<typename decay<Handler>::type>(
 135       0, BOOST_ASIO_MOVE_CAST(Handler)(handler));
 136 }
 137
 138 template <typename Handler, typename Arg1>
 139 class binder1
 140 {
 141 public:
 142   template <typename T>
 143   binder1(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1)
 144     : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)),
 145       arg1_(arg1)
 146   {
 147   }
 148
 149   binder1(Handler& handler, const Arg1& arg1)
 150     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
 151       arg1_(arg1)
 152   {
 153   }
 154
 155 #if defined(BOOST_ASIO_HAS_MOVE)
 156   binder1(const binder1& other)
 157     : handler_(other.handler_),
 158       arg1_(other.arg1_)
 159   {
 160   }
 161
 162   binder1(binder1&& other)
 163     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
 164       arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_))
 165   {
 166   }
 167 #endif // defined(BOOST_ASIO_HAS_MOVE)
 168
 169   void operator()()
 170   {
 171     BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
 172         static_cast<const Arg1&>(arg1_));
 173   }
 174
 175   void operator()() const
 176   {
 177     handler_(arg1_);
 178   }
 179
 180 //private:
 181   Handler handler_;
 182   Arg1 arg1_;
 183 };
 184
 185 template <typename Handler, typename Arg1>
 186 inline asio_handler_allocate_is_deprecated
 187 asio_handler_allocate(std::size_t size,
 188     binder1<Handler, Arg1>* this_handler)
 189 {
 190 #if defined(BOOST_ASIO_NO_DEPRECATED)
 191   boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
 192   return asio_handler_allocate_is_no_longer_used();
 193 #else // defined(BOOST_ASIO_NO_DEPRECATED)
 194   return boost_asio_handler_alloc_helpers::allocate(
 195       size, this_handler->handler_);
 196 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 197 }
 198
 199 template <typename Handler, typename Arg1>
 200 inline asio_handler_deallocate_is_deprecated
 201 asio_handler_deallocate(void* pointer, std::size_t size,
 202     binder1<Handler, Arg1>* this_handler)
 203 {
 204   boost_asio_handler_alloc_helpers::deallocate(
 205       pointer, size, this_handler->handler_);
 206 #if defined(BOOST_ASIO_NO_DEPRECATED)
 207   return asio_handler_deallocate_is_no_longer_used();
 208 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 209 }
 210
 211 template <typename Handler, typename Arg1>
 212 inline bool asio_handler_is_continuation(
 213     binder1<Handler, Arg1>* this_handler)
 214 {
 215   return boost_asio_handler_cont_helpers::is_continuation(
 216       this_handler->handler_);
 217 }
 218
 219 template <typename Function, typename Handler, typename Arg1>
 220 inline asio_handler_invoke_is_deprecated
 221 asio_handler_invoke(Function& function,
 222     binder1<Handler, Arg1>* this_handler)
 223 {
 224   boost_asio_handler_invoke_helpers::invoke(
 225       function, this_handler->handler_);
 226 #if defined(BOOST_ASIO_NO_DEPRECATED)
 227   return asio_handler_invoke_is_no_longer_used();
 228 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 229 }
 230
 231 template <typename Function, typename Handler, typename Arg1>
 232 inline asio_handler_invoke_is_deprecated
 233 asio_handler_invoke(const Function& function,
 234     binder1<Handler, Arg1>* this_handler)
 235 {
 236   boost_asio_handler_invoke_helpers::invoke(
 237       function, this_handler->handler_);
 238 #if defined(BOOST_ASIO_NO_DEPRECATED)
 239   return asio_handler_invoke_is_no_longer_used();
 240 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 241 }
 242
 243 template <typename Handler, typename Arg1>
 244 inline binder1<typename decay<Handler>::type, Arg1> bind_handler(
 245     BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1)
 246 {
 247   return binder1<typename decay<Handler>::type, Arg1>(0,
 248       BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1);
 249 }
 250
 251 template <typename Handler, typename Arg1, typename Arg2>
 252 class binder2
 253 {
 254 public:
 255   template <typename T>
 256   binder2(int, BOOST_ASIO_MOVE_ARG(T) handler,
 257       const Arg1& arg1, const Arg2& arg2)
 258     : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)),
 259       arg1_(arg1),
 260       arg2_(arg2)
 261   {
 262   }
 263
 264   binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
 265     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
 266       arg1_(arg1),
 267       arg2_(arg2)
 268   {
 269   }
 270
 271 #if defined(BOOST_ASIO_HAS_MOVE)
 272   binder2(const binder2& other)
 273     : handler_(other.handler_),
 274       arg1_(other.arg1_),
 275       arg2_(other.arg2_)
 276   {
 277   }
 278
 279   binder2(binder2&& other)
 280     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
 281       arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)),
 282       arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_))
 283   {
 284   }
 285 #endif // defined(BOOST_ASIO_HAS_MOVE)
 286
 287   void operator()()
 288   {
 289     BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
 290         static_cast<const Arg1&>(arg1_),
 291         static_cast<const Arg2&>(arg2_));
 292   }
 293
 294   void operator()() const
 295   {
 296     handler_(arg1_, arg2_);
 297   }
 298
 299 //private:
 300   Handler handler_;
 301   Arg1 arg1_;
 302   Arg2 arg2_;
 303 };
 304
 305 template <typename Handler, typename Arg1, typename Arg2>
 306 inline asio_handler_allocate_is_deprecated
 307 asio_handler_allocate(std::size_t size,
 308     binder2<Handler, Arg1, Arg2>* this_handler)
 309 {
 310 #if defined(BOOST_ASIO_NO_DEPRECATED)
 311   boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
 312   return asio_handler_allocate_is_no_longer_used();
 313 #else // defined(BOOST_ASIO_NO_DEPRECATED)
 314   return boost_asio_handler_alloc_helpers::allocate(
 315       size, this_handler->handler_);
 316 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 317 }
 318
 319 template <typename Handler, typename Arg1, typename Arg2>
 320 inline asio_handler_deallocate_is_deprecated
 321 asio_handler_deallocate(void* pointer, std::size_t size,
 322     binder2<Handler, Arg1, Arg2>* this_handler)
 323 {
 324   boost_asio_handler_alloc_helpers::deallocate(
 325       pointer, size, this_handler->handler_);
 326 #if defined(BOOST_ASIO_NO_DEPRECATED)
 327   return asio_handler_deallocate_is_no_longer_used();
 328 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 329 }
 330
 331 template <typename Handler, typename Arg1, typename Arg2>
 332 inline bool asio_handler_is_continuation(
 333     binder2<Handler, Arg1, Arg2>* this_handler)
 334 {
 335   return boost_asio_handler_cont_helpers::is_continuation(
 336       this_handler->handler_);
 337 }
 338
 339 template <typename Function, typename Handler, typename Arg1, typename Arg2>
 340 inline asio_handler_invoke_is_deprecated
 341 asio_handler_invoke(Function& function,
 342     binder2<Handler, Arg1, Arg2>* this_handler)
 343 {
 344   boost_asio_handler_invoke_helpers::invoke(
 345       function, this_handler->handler_);
 346 #if defined(BOOST_ASIO_NO_DEPRECATED)
 347   return asio_handler_invoke_is_no_longer_used();
 348 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 349 }
 350
 351 template <typename Function, typename Handler, typename Arg1, typename Arg2>
 352 inline asio_handler_invoke_is_deprecated
 353 asio_handler_invoke(const Function& function,
 354     binder2<Handler, Arg1, Arg2>* this_handler)
 355 {
 356   boost_asio_handler_invoke_helpers::invoke(
 357       function, this_handler->handler_);
 358 #if defined(BOOST_ASIO_NO_DEPRECATED)
 359   return asio_handler_invoke_is_no_longer_used();
 360 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 361 }
 362
 363 template <typename Handler, typename Arg1, typename Arg2>
 364 inline binder2<typename decay<Handler>::type, Arg1, Arg2> bind_handler(
 365     BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, const Arg2& arg2)
 366 {
 367   return binder2<typename decay<Handler>::type, Arg1, Arg2>(0,
 368       BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1, arg2);
 369 }
 370
 371 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 372 class binder3
 373 {
 374 public:
 375   template <typename T>
 376   binder3(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
 377       const Arg2& arg2, const Arg3& arg3)
 378     : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)),
 379       arg1_(arg1),
 380       arg2_(arg2),
 381       arg3_(arg3)
 382   {
 383   }
 384
 385   binder3(Handler& handler, const Arg1& arg1,
 386       const Arg2& arg2, const Arg3& arg3)
 387     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
 388       arg1_(arg1),
 389       arg2_(arg2),
 390       arg3_(arg3)
 391   {
 392   }
 393
 394 #if defined(BOOST_ASIO_HAS_MOVE)
 395   binder3(const binder3& other)
 396     : handler_(other.handler_),
 397       arg1_(other.arg1_),
 398       arg2_(other.arg2_),
 399       arg3_(other.arg3_)
 400   {
 401   }
 402
 403   binder3(binder3&& other)
 404     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
 405       arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)),
 406       arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_)),
 407       arg3_(BOOST_ASIO_MOVE_CAST(Arg3)(other.arg3_))
 408   {
 409   }
 410 #endif // defined(BOOST_ASIO_HAS_MOVE)
 411
 412   void operator()()
 413   {
 414     BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
 415         static_cast<const Arg1&>(arg1_),
 416         static_cast<const Arg2&>(arg2_),
 417         static_cast<const Arg3&>(arg3_));
 418   }
 419
 420   void operator()() const
 421   {
 422     handler_(arg1_, arg2_, arg3_);
 423   }
 424
 425 //private:
 426   Handler handler_;
 427   Arg1 arg1_;
 428   Arg2 arg2_;
 429   Arg3 arg3_;
 430 };
 431
 432 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 433 inline asio_handler_allocate_is_deprecated
 434 asio_handler_allocate(std::size_t size,
 435     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 436 {
 437 #if defined(BOOST_ASIO_NO_DEPRECATED)
 438   boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
 439   return asio_handler_allocate_is_no_longer_used();
 440 #else // defined(BOOST_ASIO_NO_DEPRECATED)
 441   return boost_asio_handler_alloc_helpers::allocate(
 442       size, this_handler->handler_);
 443 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 444 }
 445
 446 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 447 inline asio_handler_deallocate_is_deprecated
 448 asio_handler_deallocate(void* pointer, std::size_t size,
 449     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 450 {
 451   boost_asio_handler_alloc_helpers::deallocate(
 452       pointer, size, this_handler->handler_);
 453 #if defined(BOOST_ASIO_NO_DEPRECATED)
 454   return asio_handler_deallocate_is_no_longer_used();
 455 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 456 }
 457
 458 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 459 inline bool asio_handler_is_continuation(
 460     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 461 {
 462   return boost_asio_handler_cont_helpers::is_continuation(
 463       this_handler->handler_);
 464 }
 465
 466 template <typename Function, typename Handler,
 467     typename Arg1, typename Arg2, typename Arg3>
 468 inline asio_handler_invoke_is_deprecated
 469 asio_handler_invoke(Function& function,
 470     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 471 {
 472   boost_asio_handler_invoke_helpers::invoke(
 473       function, this_handler->handler_);
 474 #if defined(BOOST_ASIO_NO_DEPRECATED)
 475   return asio_handler_invoke_is_no_longer_used();
 476 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 477 }
 478
 479 template <typename Function, typename Handler,
 480     typename Arg1, typename Arg2, typename Arg3>
 481 inline asio_handler_invoke_is_deprecated
 482 asio_handler_invoke(const Function& function,
 483     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 484 {
 485   boost_asio_handler_invoke_helpers::invoke(
 486       function, this_handler->handler_);
 487 #if defined(BOOST_ASIO_NO_DEPRECATED)
 488   return asio_handler_invoke_is_no_longer_used();
 489 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 490 }
 491
 492 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 493 inline binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3> bind_handler(
 494     BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, const Arg2& arg2,
 495     const Arg3& arg3)
 496 {
 497   return binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3>(0,
 498       BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3);
 499 }
 500
 501 template <typename Handler, typename Arg1,
 502     typename Arg2, typename Arg3, typename Arg4>
 503 class binder4
 504 {
 505 public:
 506   template <typename T>
 507   binder4(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
 508       const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
 509     : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)),
 510       arg1_(arg1),
 511       arg2_(arg2),
 512       arg3_(arg3),
 513       arg4_(arg4)
 514   {
 515   }
 516
 517   binder4(Handler& handler, const Arg1& arg1,
 518       const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
 519     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
 520       arg1_(arg1),
 521       arg2_(arg2),
 522       arg3_(arg3),
 523       arg4_(arg4)
 524   {
 525   }
 526
 527 #if defined(BOOST_ASIO_HAS_MOVE)
 528   binder4(const binder4& other)
 529     : handler_(other.handler_),
 530       arg1_(other.arg1_),
 531       arg2_(other.arg2_),
 532       arg3_(other.arg3_),
 533       arg4_(other.arg4_)
 534   {
 535   }
 536
 537   binder4(binder4&& other)
 538     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
 539       arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)),
 540       arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_)),
 541       arg3_(BOOST_ASIO_MOVE_CAST(Arg3)(other.arg3_)),
 542       arg4_(BOOST_ASIO_MOVE_CAST(Arg4)(other.arg4_))
 543   {
 544   }
 545 #endif // defined(BOOST_ASIO_HAS_MOVE)
 546
 547   void operator()()
 548   {
 549     BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
 550         static_cast<const Arg1&>(arg1_),
 551         static_cast<const Arg2&>(arg2_),
 552         static_cast<const Arg3&>(arg3_),
 553         static_cast<const Arg4&>(arg4_));
 554   }
 555
 556   void operator()() const
 557   {
 558     handler_(arg1_, arg2_, arg3_, arg4_);
 559   }
 560
 561 //private:
 562   Handler handler_;
 563   Arg1 arg1_;
 564   Arg2 arg2_;
 565   Arg3 arg3_;
 566   Arg4 arg4_;
 567 };
 568
 569 template <typename Handler, typename Arg1,
 570     typename Arg2, typename Arg3, typename Arg4>
 571 inline asio_handler_allocate_is_deprecated
 572 asio_handler_allocate(std::size_t size,
 573     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 574 {
 575 #if defined(BOOST_ASIO_NO_DEPRECATED)
 576   boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
 577   return asio_handler_allocate_is_no_longer_used();
 578 #else // defined(BOOST_ASIO_NO_DEPRECATED)
 579   return boost_asio_handler_alloc_helpers::allocate(
 580       size, this_handler->handler_);
 581 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 582 }
 583
 584 template <typename Handler, typename Arg1,
 585     typename Arg2, typename Arg3, typename Arg4>
 586 inline asio_handler_deallocate_is_deprecated
 587 asio_handler_deallocate(void* pointer, std::size_t size,
 588     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 589 {
 590   boost_asio_handler_alloc_helpers::deallocate(
 591       pointer, size, this_handler->handler_);
 592 #if defined(BOOST_ASIO_NO_DEPRECATED)
 593   return asio_handler_deallocate_is_no_longer_used();
 594 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 595 }
 596
 597 template <typename Handler, typename Arg1,
 598     typename Arg2, typename Arg3, typename Arg4>
 599 inline bool asio_handler_is_continuation(
 600     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 601 {
 602   return boost_asio_handler_cont_helpers::is_continuation(
 603       this_handler->handler_);
 604 }
 605
 606 template <typename Function, typename Handler, typename Arg1,
 607     typename Arg2, typename Arg3, typename Arg4>
 608 inline asio_handler_invoke_is_deprecated
 609 asio_handler_invoke(Function& function,
 610     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 611 {
 612   boost_asio_handler_invoke_helpers::invoke(
 613       function, this_handler->handler_);
 614 #if defined(BOOST_ASIO_NO_DEPRECATED)
 615   return asio_handler_invoke_is_no_longer_used();
 616 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 617 }
 618
 619 template <typename Function, typename Handler, typename Arg1,
 620     typename Arg2, typename Arg3, typename Arg4>
 621 inline asio_handler_invoke_is_deprecated
 622 asio_handler_invoke(const Function& function,
 623     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 624 {
 625   boost_asio_handler_invoke_helpers::invoke(
 626       function, this_handler->handler_);
 627 #if defined(BOOST_ASIO_NO_DEPRECATED)
 628   return asio_handler_invoke_is_no_longer_used();
 629 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 630 }
 631
 632 template <typename Handler, typename Arg1,
 633     typename Arg2, typename Arg3, typename Arg4>
 634 inline binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>
 635 bind_handler(BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1,
 636     const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
 637 {
 638   return binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>(0,
 639       BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3, arg4);
 640 }
 641
 642 template <typename Handler, typename Arg1, typename Arg2,
 643     typename Arg3, typename Arg4, typename Arg5>
 644 class binder5
 645 {
 646 public:
 647   template <typename T>
 648   binder5(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
 649       const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
 650     : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)),
 651       arg1_(arg1),
 652       arg2_(arg2),
 653       arg3_(arg3),
 654       arg4_(arg4),
 655       arg5_(arg5)
 656   {
 657   }
 658
 659   binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
 660       const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
 661     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
 662       arg1_(arg1),
 663       arg2_(arg2),
 664       arg3_(arg3),
 665       arg4_(arg4),
 666       arg5_(arg5)
 667   {
 668   }
 669
 670 #if defined(BOOST_ASIO_HAS_MOVE)
 671   binder5(const binder5& other)
 672     : handler_(other.handler_),
 673       arg1_(other.arg1_),
 674       arg2_(other.arg2_),
 675       arg3_(other.arg3_),
 676       arg4_(other.arg4_),
 677       arg5_(other.arg5_)
 678   {
 679   }
 680
 681   binder5(binder5&& other)
 682     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
 683       arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)),
 684       arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_)),
 685       arg3_(BOOST_ASIO_MOVE_CAST(Arg3)(other.arg3_)),
 686       arg4_(BOOST_ASIO_MOVE_CAST(Arg4)(other.arg4_)),
 687       arg5_(BOOST_ASIO_MOVE_CAST(Arg5)(other.arg5_))
 688   {
 689   }
 690 #endif // defined(BOOST_ASIO_HAS_MOVE)
 691
 692   void operator()()
 693   {
 694     BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
 695         static_cast<const Arg1&>(arg1_),
 696         static_cast<const Arg2&>(arg2_),
 697         static_cast<const Arg3&>(arg3_),
 698         static_cast<const Arg4&>(arg4_),
 699         static_cast<const Arg5&>(arg5_));
 700   }
 701
 702   void operator()() const
 703   {
 704     handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
 705   }
 706
 707 //private:
 708   Handler handler_;
 709   Arg1 arg1_;
 710   Arg2 arg2_;
 711   Arg3 arg3_;
 712   Arg4 arg4_;
 713   Arg5 arg5_;
 714 };
 715
 716 template <typename Handler, typename Arg1, typename Arg2,
 717     typename Arg3, typename Arg4, typename Arg5>
 718 inline asio_handler_allocate_is_deprecated
 719 asio_handler_allocate(std::size_t size,
 720     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 721 {
 722 #if defined(BOOST_ASIO_NO_DEPRECATED)
 723   boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
 724   return asio_handler_allocate_is_no_longer_used();
 725 #else // defined(BOOST_ASIO_NO_DEPRECATED)
 726   return boost_asio_handler_alloc_helpers::allocate(
 727       size, this_handler->handler_);
 728 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 729 }
 730
 731 template <typename Handler, typename Arg1, typename Arg2,
 732     typename Arg3, typename Arg4, typename Arg5>
 733 inline asio_handler_deallocate_is_deprecated
 734 asio_handler_deallocate(void* pointer, std::size_t size,
 735     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 736 {
 737   boost_asio_handler_alloc_helpers::deallocate(
 738       pointer, size, this_handler->handler_);
 739 #if defined(BOOST_ASIO_NO_DEPRECATED)
 740   return asio_handler_deallocate_is_no_longer_used();
 741 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 742 }
 743
 744 template <typename Handler, typename Arg1, typename Arg2,
 745     typename Arg3, typename Arg4, typename Arg5>
 746 inline bool asio_handler_is_continuation(
 747     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 748 {
 749   return boost_asio_handler_cont_helpers::is_continuation(
 750       this_handler->handler_);
 751 }
 752
 753 template <typename Function, typename Handler, typename Arg1,
 754     typename Arg2, typename Arg3, typename Arg4, typename Arg5>
 755 inline asio_handler_invoke_is_deprecated
 756 asio_handler_invoke(Function& function,
 757     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 758 {
 759   boost_asio_handler_invoke_helpers::invoke(
 760       function, this_handler->handler_);
 761 #if defined(BOOST_ASIO_NO_DEPRECATED)
 762   return asio_handler_invoke_is_no_longer_used();
 763 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 764 }
 765
 766 template <typename Function, typename Handler, typename Arg1,
 767     typename Arg2, typename Arg3, typename Arg4, typename Arg5>
 768 inline asio_handler_invoke_is_deprecated
 769 asio_handler_invoke(const Function& function,
 770     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 771 {
 772   boost_asio_handler_invoke_helpers::invoke(
 773       function, this_handler->handler_);
 774 #if defined(BOOST_ASIO_NO_DEPRECATED)
 775   return asio_handler_invoke_is_no_longer_used();
 776 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 777 }
 778
 779 template <typename Handler, typename Arg1, typename Arg2,
 780     typename Arg3, typename Arg4, typename Arg5>
 781 inline binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>
 782 bind_handler(BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1,
 783     const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
 784 {
 785   return binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>(0,
 786       BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3, arg4, arg5);
 787 }
 788
 789 #if defined(BOOST_ASIO_HAS_MOVE)
 790
 791 template <typename Handler, typename Arg1>
 792 class move_binder1
 793 {
 794 public:
 795   move_binder1(int, BOOST_ASIO_MOVE_ARG(Handler) handler,
 796       BOOST_ASIO_MOVE_ARG(Arg1) arg1)
 797     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
 798       arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(arg1))
 799   {
 800   }
 801
 802   move_binder1(move_binder1&& other)
 803     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
 804       arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_))
 805   {
 806   }
 807
 808   void operator()()
 809   {
 810     BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
 811         BOOST_ASIO_MOVE_CAST(Arg1)(arg1_));
 812   }
 813
 814 //private:
 815   Handler handler_;
 816   Arg1 arg1_;
 817 };
 818
 819 template <typename Handler, typename Arg1>
 820 inline asio_handler_allocate_is_deprecated
 821 asio_handler_allocate(std::size_t size,
 822     move_binder1<Handler, Arg1>* this_handler)
 823 {
 824 #if defined(BOOST_ASIO_NO_DEPRECATED)
 825   boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
 826   return asio_handler_allocate_is_no_longer_used();
 827 #else // defined(BOOST_ASIO_NO_DEPRECATED)
 828   return boost_asio_handler_alloc_helpers::allocate(
 829       size, this_handler->handler_);
 830 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 831 }
 832
 833 template <typename Handler, typename Arg1>
 834 inline asio_handler_deallocate_is_deprecated
 835 asio_handler_deallocate(void* pointer, std::size_t size,
 836     move_binder1<Handler, Arg1>* this_handler)
 837 {
 838   boost_asio_handler_alloc_helpers::deallocate(
 839       pointer, size, this_handler->handler_);
 840 #if defined(BOOST_ASIO_NO_DEPRECATED)
 841   return asio_handler_deallocate_is_no_longer_used();
 842 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 843 }
 844
 845 template <typename Handler, typename Arg1>
 846 inline bool asio_handler_is_continuation(
 847     move_binder1<Handler, Arg1>* this_handler)
 848 {
 849   return boost_asio_handler_cont_helpers::is_continuation(
 850       this_handler->handler_);
 851 }
 852
 853 template <typename Function, typename Handler, typename Arg1>
 854 inline asio_handler_invoke_is_deprecated
 855 asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function,
 856     move_binder1<Handler, Arg1>* this_handler)
 857 {
 858   boost_asio_handler_invoke_helpers::invoke(
 859       BOOST_ASIO_MOVE_CAST(Function)(function), this_handler->handler_);
 860 #if defined(BOOST_ASIO_NO_DEPRECATED)
 861   return asio_handler_invoke_is_no_longer_used();
 862 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 863 }
 864
 865 template <typename Handler, typename Arg1, typename Arg2>
 866 class move_binder2
 867 {
 868 public:
 869   move_binder2(int, BOOST_ASIO_MOVE_ARG(Handler) handler,
 870       const Arg1& arg1, BOOST_ASIO_MOVE_ARG(Arg2) arg2)
 871     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
 872       arg1_(arg1),
 873       arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(arg2))
 874   {
 875   }
 876
 877   move_binder2(move_binder2&& other)
 878     : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
 879       arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)),
 880       arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_))
 881   {
 882   }
 883
 884   void operator()()
 885   {
 886     BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
 887         static_cast<const Arg1&>(arg1_),
 888         BOOST_ASIO_MOVE_CAST(Arg2)(arg2_));
 889   }
 890
 891 //private:
 892   Handler handler_;
 893   Arg1 arg1_;
 894   Arg2 arg2_;
 895 };
 896
 897 template <typename Handler, typename Arg1, typename Arg2>
 898 inline asio_handler_allocate_is_deprecated
 899 asio_handler_allocate(std::size_t size,
 900     move_binder2<Handler, Arg1, Arg2>* this_handler)
 901 {
 902 #if defined(BOOST_ASIO_NO_DEPRECATED)
 903   boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
 904   return asio_handler_allocate_is_no_longer_used();
 905 #else // defined(BOOST_ASIO_NO_DEPRECATED)
 906   return boost_asio_handler_alloc_helpers::allocate(
 907       size, this_handler->handler_);
 908 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 909 }
 910
 911 template <typename Handler, typename Arg1, typename Arg2>
 912 inline asio_handler_deallocate_is_deprecated
 913 asio_handler_deallocate(void* pointer, std::size_t size,
 914     move_binder2<Handler, Arg1, Arg2>* this_handler)
 915 {
 916   boost_asio_handler_alloc_helpers::deallocate(
 917       pointer, size, this_handler->handler_);
 918 #if defined(BOOST_ASIO_NO_DEPRECATED)
 919   return asio_handler_deallocate_is_no_longer_used();
 920 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 921 }
 922
 923 template <typename Handler, typename Arg1, typename Arg2>
 924 inline bool asio_handler_is_continuation(
 925     move_binder2<Handler, Arg1, Arg2>* this_handler)
 926 {
 927   return boost_asio_handler_cont_helpers::is_continuation(
 928       this_handler->handler_);
 929 }
 930
 931 template <typename Function, typename Handler, typename Arg1, typename Arg2>
 932 inline asio_handler_invoke_is_deprecated
 933 asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function,
 934     move_binder2<Handler, Arg1, Arg2>* this_handler)
 935 {
 936   boost_asio_handler_invoke_helpers::invoke(
 937       BOOST_ASIO_MOVE_CAST(Function)(function), this_handler->handler_);
 938 #if defined(BOOST_ASIO_NO_DEPRECATED)
 939   return asio_handler_invoke_is_no_longer_used();
 940 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 941 }
 942
 943 #endif // defined(BOOST_ASIO_HAS_MOVE)
 944
 945 } // namespace detail
 946
 947 template <template <typename, typename> class Associator,
 948     typename Handler, typename DefaultCandidate>
 949 struct associator<Associator,
 950     detail::binder0<Handler>, DefaultCandidate>
 951   : Associator<Handler, DefaultCandidate>
 952 {
 953   static typename Associator<Handler, DefaultCandidate>::type get(
 954       const detail::binder0<Handler>& h,
 955       const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
 956   {
 957     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
 958   }
 959 };
 960
 961 template <template <typename, typename> class Associator,
 962     typename Handler, typename Arg1, typename DefaultCandidate>
 963 struct associator<Associator,
 964     detail::binder1<Handler, Arg1>, DefaultCandidate>
 965   : Associator<Handler, DefaultCandidate>
 966 {
 967   static typename Associator<Handler, DefaultCandidate>::type get(
 968       const detail::binder1<Handler, Arg1>& h,
 969       const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
 970   {
 971     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
 972   }
 973 };
 974
 975 template <template <typename, typename> class Associator,
 976     typename Handler, typename Arg1, typename Arg2,
 977     typename DefaultCandidate>
 978 struct associator<Associator,
 979     detail::binder2<Handler, Arg1, Arg2>, DefaultCandidate>
 980   : Associator<Handler, DefaultCandidate>
 981 {
 982   static typename Associator<Handler, DefaultCandidate>::type get(
 983       const detail::binder2<Handler, Arg1, Arg2>& h,
 984       const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
 985   {
 986     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
 987   }
 988 };
 989
 990 template <template <typename, typename> class Associator,
 991     typename Handler, typename Arg1, typename Arg2, typename Arg3,
 992     typename DefaultCandidate>
 993 struct associator<Associator,
 994     detail::binder3<Handler, Arg1, Arg2, Arg3>, DefaultCandidate>
 995   : Associator<Handler, DefaultCandidate>
 996 {
 997   static typename Associator<Handler, DefaultCandidate>::type get(
 998       const detail::binder3<Handler, Arg1, Arg2, Arg3>& h,
 999       const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
1000   {
1001     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
1002   }
1003 };
1004
1005 template <template <typename, typename> class Associator,
1006     typename Handler, typename Arg1, typename Arg2, typename Arg3,
1007     typename Arg4, typename DefaultCandidate>
1008 struct associator<Associator,
1009     detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>, DefaultCandidate>
1010   : Associator<Handler, DefaultCandidate>
1011 {
1012   static typename Associator<Handler, DefaultCandidate>::type get(
1013       const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h,
1014       const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
1015   {
1016     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
1017   }
1018 };
1019
1020 template <template <typename, typename> class Associator,
1021     typename Handler, typename Arg1, typename Arg2, typename Arg3,
1022     typename Arg4, typename Arg5, typename DefaultCandidate>
1023 struct associator<Associator,
1024     detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>, DefaultCandidate>
1025   : Associator<Handler, DefaultCandidate>
1026 {
1027   static typename Associator<Handler, DefaultCandidate>::type get(
1028       const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h,
1029       const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
1030   {
1031     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
1032   }
1033 };
1034
1035 #if defined(BOOST_ASIO_HAS_MOVE)
1036
1037 template <template <typename, typename> class Associator,
1038     typename Handler, typename Arg1, typename DefaultCandidate>
1039 struct associator<Associator,
1040     detail::move_binder1<Handler, Arg1>, DefaultCandidate>
1041   : Associator<Handler, DefaultCandidate>
1042 {
1043   static typename Associator<Handler, DefaultCandidate>::type get(
1044       const detail::move_binder1<Handler, Arg1>& h,
1045       const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
1046   {
1047     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
1048   }
1049 };
1050
1051 template <template <typename, typename> class Associator,
1052     typename Handler, typename Arg1, typename Arg2,
1053     typename DefaultCandidate>
1054 struct associator<Associator,
1055     detail::move_binder2<Handler, Arg1, Arg2>, DefaultCandidate>
1056   : Associator<Handler, DefaultCandidate>
1057 {
1058   static typename Associator<Handler, DefaultCandidate>::type get(
1059       const detail::move_binder2<Handler, Arg1, Arg2>& h,
1060       const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
1061   {
1062     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
1063   }
1064 };
1065
1066 #endif // defined(BOOST_ASIO_HAS_MOVE)
1067
1068 } // namespace asio
1069 } // namespace boost
1070
1071 #include <boost/asio/detail/pop_options.hpp>
1072
1073 #endif // BOOST_ASIO_DETAIL_BIND_HANDLER_HPP