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

   1 //
   2 // detail/handler_type_requirements.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_HANDLER_TYPE_REQUIREMENTS_HPP
  12 #define BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_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
  20 // Older versions of gcc have difficulty compiling the sizeof expressions where
  21 // we test the handler type requirements. We'll disable checking of handler type
  22 // requirements for those compilers, but otherwise enable it by default.
  23 #if !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
  24 # if !defined(__GNUC__) || (__GNUC__ >= 4)
  25 #  define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1
  26 # endif // !defined(__GNUC__) || (__GNUC__ >= 4)
  27 #endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
  28
  29 // With C++0x we can use a combination of enhanced SFINAE and static_assert to
  30 // generate better template error messages. As this technique is not yet widely
  31 // portable, we'll only enable it for tested compilers.
  32 #if !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
  33 # if defined(__GNUC__)
  34 #  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
  35 #   if defined(__GXX_EXPERIMENTAL_CXX0X__)
  36 #    define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
  37 #   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
  38 #  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
  39 # endif // defined(__GNUC__)
  40 # if defined(BOOST_ASIO_MSVC)
  41 #  if (_MSC_VER >= 1600)
  42 #   define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
  43 #  endif // (_MSC_VER >= 1600)
  44 # endif // defined(BOOST_ASIO_MSVC)
  45 # if defined(__clang__)
  46 #  if __has_feature(__cxx_static_assert__)
  47 #   define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
  48 #  endif // __has_feature(cxx_static_assert)
  49 # endif // defined(__clang__)
  50 #endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
  51
  52 #if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
  53 # include <boost/asio/async_result.hpp>
  54 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
  55
  56 namespace boost {
  57 namespace asio {
  58 namespace detail {
  59
  60 #if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
  61
  62 # if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
  63
  64 template <typename Handler>
  65 auto zero_arg_copyable_handler_test(Handler h, void*)
  66   -> decltype(
  67     sizeof(Handler(static_cast<const Handler&>(h))),
  68     (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)()),
  69     char(0));
  70
  71 template <typename Handler>
  72 char (&zero_arg_copyable_handler_test(Handler, ...))[2];
  73
  74 template <typename Handler, typename Arg1>
  75 auto one_arg_handler_test(Handler h, Arg1* a1)
  76   -> decltype(
  77     sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
  78     (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(*a1)),
  79     char(0));
  80
  81 template <typename Handler>
  82 char (&one_arg_handler_test(Handler h, ...))[2];
  83
  84 template <typename Handler, typename Arg1, typename Arg2>
  85 auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
  86   -> decltype(
  87     sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
  88     (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(*a1, *a2)),
  89     char(0));
  90
  91 template <typename Handler>
  92 char (&two_arg_handler_test(Handler, ...))[2];
  93
  94 template <typename Handler, typename Arg1, typename Arg2>
  95 auto two_arg_move_handler_test(Handler h, Arg1* a1, Arg2* a2)
  96   -> decltype(
  97     sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
  98     (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(
  99       *a1, BOOST_ASIO_MOVE_CAST(Arg2)(*a2))),
 100     char(0));
 101
 102 template <typename Handler>
 103 char (&two_arg_move_handler_test(Handler, ...))[2];
 104
 105 #  define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) \
 106      static_assert(expr, msg);
 107
 108 # else // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
 109
 110 #  define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg)
 111
 112 # endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
 113
 114 template <typename T> T& lvref();
 115 template <typename T> T& lvref(T);
 116 template <typename T> const T& clvref();
 117 template <typename T> const T& clvref(T);
 118 #if defined(BOOST_ASIO_HAS_MOVE)
 119 template <typename T> T rvref();
 120 template <typename T> T rvref(T);
 121 template <typename T> T rorlvref();
 122 #else // defined(BOOST_ASIO_HAS_MOVE)
 123 template <typename T> const T& rvref();
 124 template <typename T> const T& rvref(T);
 125 template <typename T> T& rorlvref();
 126 #endif // defined(BOOST_ASIO_HAS_MOVE)
 127 template <typename T> char argbyv(T);
 128
 129 template <int>
 130 struct handler_type_requirements
 131 {
 132 };
 133
 134 #define BOOST_ASIO_LEGACY_COMPLETION_HANDLER_CHECK( \
 135     handler_type, handler) \
 136   \
 137   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 138       void()) asio_true_handler_type; \
 139   \
 140   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 141       sizeof(boost::asio::detail::zero_arg_copyable_handler_test( \
 142           boost::asio::detail::clvref< \
 143             asio_true_handler_type>(), 0)) == 1, \
 144       "CompletionHandler type requirements not met") \
 145   \
 146   typedef boost::asio::detail::handler_type_requirements< \
 147       sizeof( \
 148         boost::asio::detail::argbyv( \
 149           boost::asio::detail::clvref< \
 150             asio_true_handler_type>())) + \
 151       sizeof( \
 152         boost::asio::detail::rorlvref< \
 153           asio_true_handler_type>()(), \
 154         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 155
 156 #define BOOST_ASIO_READ_HANDLER_CHECK( \
 157     handler_type, handler) \
 158   \
 159   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 160       void(boost::system::error_code, std::size_t)) \
 161     asio_true_handler_type; \
 162   \
 163   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 164       sizeof(boost::asio::detail::two_arg_handler_test( \
 165           boost::asio::detail::rvref< \
 166             asio_true_handler_type>(), \
 167           static_cast<const boost::system::error_code*>(0), \
 168           static_cast<const std::size_t*>(0))) == 1, \
 169       "ReadHandler type requirements not met") \
 170   \
 171   typedef boost::asio::detail::handler_type_requirements< \
 172       sizeof( \
 173         boost::asio::detail::argbyv( \
 174           boost::asio::detail::rvref< \
 175             asio_true_handler_type>())) + \
 176       sizeof( \
 177         boost::asio::detail::rorlvref< \
 178           asio_true_handler_type>()( \
 179             boost::asio::detail::lvref<const boost::system::error_code>(), \
 180             boost::asio::detail::lvref<const std::size_t>()), \
 181         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 182
 183 #define BOOST_ASIO_WRITE_HANDLER_CHECK( \
 184     handler_type, handler) \
 185   \
 186   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 187       void(boost::system::error_code, std::size_t)) \
 188     asio_true_handler_type; \
 189   \
 190   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 191       sizeof(boost::asio::detail::two_arg_handler_test( \
 192           boost::asio::detail::rvref< \
 193             asio_true_handler_type>(), \
 194           static_cast<const boost::system::error_code*>(0), \
 195           static_cast<const std::size_t*>(0))) == 1, \
 196       "WriteHandler type requirements not met") \
 197   \
 198   typedef boost::asio::detail::handler_type_requirements< \
 199       sizeof( \
 200         boost::asio::detail::argbyv( \
 201           boost::asio::detail::rvref< \
 202             asio_true_handler_type>())) + \
 203       sizeof( \
 204         boost::asio::detail::rorlvref< \
 205           asio_true_handler_type>()( \
 206             boost::asio::detail::lvref<const boost::system::error_code>(), \
 207             boost::asio::detail::lvref<const std::size_t>()), \
 208         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 209
 210 #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
 211     handler_type, handler) \
 212   \
 213   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 214       void(boost::system::error_code)) \
 215     asio_true_handler_type; \
 216   \
 217   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 218       sizeof(boost::asio::detail::one_arg_handler_test( \
 219           boost::asio::detail::rvref< \
 220             asio_true_handler_type>(), \
 221           static_cast<const boost::system::error_code*>(0))) == 1, \
 222       "AcceptHandler type requirements not met") \
 223   \
 224   typedef boost::asio::detail::handler_type_requirements< \
 225       sizeof( \
 226         boost::asio::detail::argbyv( \
 227           boost::asio::detail::rvref< \
 228             asio_true_handler_type>())) + \
 229       sizeof( \
 230         boost::asio::detail::rorlvref< \
 231           asio_true_handler_type>()( \
 232             boost::asio::detail::lvref<const boost::system::error_code>()), \
 233         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 234
 235 #define BOOST_ASIO_MOVE_ACCEPT_HANDLER_CHECK( \
 236     handler_type, handler, socket_type) \
 237   \
 238   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 239       void(boost::system::error_code, socket_type)) \
 240     asio_true_handler_type; \
 241   \
 242   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 243       sizeof(boost::asio::detail::two_arg_move_handler_test( \
 244           boost::asio::detail::rvref< \
 245             asio_true_handler_type>(), \
 246           static_cast<const boost::system::error_code*>(0), \
 247           static_cast<socket_type*>(0))) == 1, \
 248       "MoveAcceptHandler type requirements not met") \
 249   \
 250   typedef boost::asio::detail::handler_type_requirements< \
 251       sizeof( \
 252         boost::asio::detail::argbyv( \
 253           boost::asio::detail::rvref< \
 254             asio_true_handler_type>())) + \
 255       sizeof( \
 256         boost::asio::detail::rorlvref< \
 257           asio_true_handler_type>()( \
 258             boost::asio::detail::lvref<const boost::system::error_code>(), \
 259             boost::asio::detail::rvref<socket_type>()), \
 260         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 261
 262 #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
 263     handler_type, handler) \
 264   \
 265   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 266       void(boost::system::error_code)) \
 267     asio_true_handler_type; \
 268   \
 269   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 270       sizeof(boost::asio::detail::one_arg_handler_test( \
 271           boost::asio::detail::rvref< \
 272             asio_true_handler_type>(), \
 273           static_cast<const boost::system::error_code*>(0))) == 1, \
 274       "ConnectHandler type requirements not met") \
 275   \
 276   typedef boost::asio::detail::handler_type_requirements< \
 277       sizeof( \
 278         boost::asio::detail::argbyv( \
 279           boost::asio::detail::rvref< \
 280             asio_true_handler_type>())) + \
 281       sizeof( \
 282         boost::asio::detail::rorlvref< \
 283           asio_true_handler_type>()( \
 284             boost::asio::detail::lvref<const boost::system::error_code>()), \
 285         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 286
 287 #define BOOST_ASIO_RANGE_CONNECT_HANDLER_CHECK( \
 288     handler_type, handler, endpoint_type) \
 289   \
 290   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 291       void(boost::system::error_code, endpoint_type)) \
 292     asio_true_handler_type; \
 293   \
 294   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 295       sizeof(boost::asio::detail::two_arg_handler_test( \
 296           boost::asio::detail::rvref< \
 297             asio_true_handler_type>(), \
 298           static_cast<const boost::system::error_code*>(0), \
 299           static_cast<const endpoint_type*>(0))) == 1, \
 300       "RangeConnectHandler type requirements not met") \
 301   \
 302   typedef boost::asio::detail::handler_type_requirements< \
 303       sizeof( \
 304         boost::asio::detail::argbyv( \
 305           boost::asio::detail::rvref< \
 306             asio_true_handler_type>())) + \
 307       sizeof( \
 308         boost::asio::detail::rorlvref< \
 309           asio_true_handler_type>()( \
 310             boost::asio::detail::lvref<const boost::system::error_code>(), \
 311             boost::asio::detail::lvref<const endpoint_type>()), \
 312         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 313
 314 #define BOOST_ASIO_ITERATOR_CONNECT_HANDLER_CHECK( \
 315     handler_type, handler, iter_type) \
 316   \
 317   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 318       void(boost::system::error_code, iter_type)) \
 319     asio_true_handler_type; \
 320   \
 321   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 322       sizeof(boost::asio::detail::two_arg_handler_test( \
 323           boost::asio::detail::rvref< \
 324             asio_true_handler_type>(), \
 325           static_cast<const boost::system::error_code*>(0), \
 326           static_cast<const iter_type*>(0))) == 1, \
 327       "IteratorConnectHandler type requirements not met") \
 328   \
 329   typedef boost::asio::detail::handler_type_requirements< \
 330       sizeof( \
 331         boost::asio::detail::argbyv( \
 332           boost::asio::detail::rvref< \
 333             asio_true_handler_type>())) + \
 334       sizeof( \
 335         boost::asio::detail::rorlvref< \
 336           asio_true_handler_type>()( \
 337             boost::asio::detail::lvref<const boost::system::error_code>(), \
 338             boost::asio::detail::lvref<const iter_type>()), \
 339         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 340
 341 #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
 342     handler_type, handler, range_type) \
 343   \
 344   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 345       void(boost::system::error_code, range_type)) \
 346     asio_true_handler_type; \
 347   \
 348   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 349       sizeof(boost::asio::detail::two_arg_handler_test( \
 350           boost::asio::detail::rvref< \
 351             asio_true_handler_type>(), \
 352           static_cast<const boost::system::error_code*>(0), \
 353           static_cast<const range_type*>(0))) == 1, \
 354       "ResolveHandler type requirements not met") \
 355   \
 356   typedef boost::asio::detail::handler_type_requirements< \
 357       sizeof( \
 358         boost::asio::detail::argbyv( \
 359           boost::asio::detail::rvref< \
 360             asio_true_handler_type>())) + \
 361       sizeof( \
 362         boost::asio::detail::rorlvref< \
 363           asio_true_handler_type>()( \
 364             boost::asio::detail::lvref<const boost::system::error_code>(), \
 365             boost::asio::detail::lvref<const range_type>()), \
 366         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 367
 368 #define BOOST_ASIO_WAIT_HANDLER_CHECK( \
 369     handler_type, handler) \
 370   \
 371   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 372       void(boost::system::error_code)) \
 373     asio_true_handler_type; \
 374   \
 375   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 376       sizeof(boost::asio::detail::one_arg_handler_test( \
 377           boost::asio::detail::rvref< \
 378             asio_true_handler_type>(), \
 379           static_cast<const boost::system::error_code*>(0))) == 1, \
 380       "WaitHandler type requirements not met") \
 381   \
 382   typedef boost::asio::detail::handler_type_requirements< \
 383       sizeof( \
 384         boost::asio::detail::argbyv( \
 385           boost::asio::detail::rvref< \
 386             asio_true_handler_type>())) + \
 387       sizeof( \
 388         boost::asio::detail::rorlvref< \
 389           asio_true_handler_type>()( \
 390             boost::asio::detail::lvref<const boost::system::error_code>()), \
 391         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 392
 393 #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
 394     handler_type, handler) \
 395   \
 396   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 397       void(boost::system::error_code, int)) \
 398     asio_true_handler_type; \
 399   \
 400   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 401       sizeof(boost::asio::detail::two_arg_handler_test( \
 402           boost::asio::detail::rvref< \
 403             asio_true_handler_type>(), \
 404           static_cast<const boost::system::error_code*>(0), \
 405           static_cast<const int*>(0))) == 1, \
 406       "SignalHandler type requirements not met") \
 407   \
 408   typedef boost::asio::detail::handler_type_requirements< \
 409       sizeof( \
 410         boost::asio::detail::argbyv( \
 411           boost::asio::detail::rvref< \
 412             asio_true_handler_type>())) + \
 413       sizeof( \
 414         boost::asio::detail::rorlvref< \
 415           asio_true_handler_type>()( \
 416             boost::asio::detail::lvref<const boost::system::error_code>(), \
 417             boost::asio::detail::lvref<const int>()), \
 418         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 419
 420 #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
 421     handler_type, handler) \
 422   \
 423   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 424       void(boost::system::error_code)) \
 425     asio_true_handler_type; \
 426   \
 427   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 428       sizeof(boost::asio::detail::one_arg_handler_test( \
 429           boost::asio::detail::rvref< \
 430             asio_true_handler_type>(), \
 431           static_cast<const boost::system::error_code*>(0))) == 1, \
 432       "HandshakeHandler type requirements not met") \
 433   \
 434   typedef boost::asio::detail::handler_type_requirements< \
 435       sizeof( \
 436         boost::asio::detail::argbyv( \
 437           boost::asio::detail::rvref< \
 438             asio_true_handler_type>())) + \
 439       sizeof( \
 440         boost::asio::detail::rorlvref< \
 441           asio_true_handler_type>()( \
 442             boost::asio::detail::lvref<const boost::system::error_code>()), \
 443         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 444
 445 #define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
 446     handler_type, handler) \
 447   \
 448   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 449       void(boost::system::error_code, std::size_t)) \
 450     asio_true_handler_type; \
 451   \
 452   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 453       sizeof(boost::asio::detail::two_arg_handler_test( \
 454           boost::asio::detail::rvref< \
 455             asio_true_handler_type>(), \
 456           static_cast<const boost::system::error_code*>(0), \
 457           static_cast<const std::size_t*>(0))) == 1, \
 458       "BufferedHandshakeHandler type requirements not met") \
 459   \
 460   typedef boost::asio::detail::handler_type_requirements< \
 461       sizeof( \
 462         boost::asio::detail::argbyv( \
 463           boost::asio::detail::rvref< \
 464             asio_true_handler_type>())) + \
 465       sizeof( \
 466         boost::asio::detail::rorlvref< \
 467           asio_true_handler_type>()( \
 468           boost::asio::detail::lvref<const boost::system::error_code>(), \
 469           boost::asio::detail::lvref<const std::size_t>()), \
 470         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 471
 472 #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
 473     handler_type, handler) \
 474   \
 475   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 476       void(boost::system::error_code)) \
 477     asio_true_handler_type; \
 478   \
 479   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 480       sizeof(boost::asio::detail::one_arg_handler_test( \
 481           boost::asio::detail::rvref< \
 482             asio_true_handler_type>(), \
 483           static_cast<const boost::system::error_code*>(0))) == 1, \
 484       "ShutdownHandler type requirements not met") \
 485   \
 486   typedef boost::asio::detail::handler_type_requirements< \
 487       sizeof( \
 488         boost::asio::detail::argbyv( \
 489           boost::asio::detail::rvref< \
 490             asio_true_handler_type>())) + \
 491       sizeof( \
 492         boost::asio::detail::rorlvref< \
 493           asio_true_handler_type>()( \
 494             boost::asio::detail::lvref<const boost::system::error_code>()), \
 495         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 496
 497 #else // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 498
 499 #define BOOST_ASIO_LEGACY_COMPLETION_HANDLER_CHECK( \
 500     handler_type, handler) \
 501   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 502
 503 #define BOOST_ASIO_READ_HANDLER_CHECK( \
 504     handler_type, handler) \
 505   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 506
 507 #define BOOST_ASIO_WRITE_HANDLER_CHECK( \
 508     handler_type, handler) \
 509   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 510
 511 #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
 512     handler_type, handler) \
 513   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 514
 515 #define BOOST_ASIO_MOVE_ACCEPT_HANDLER_CHECK( \
 516     handler_type, handler, socket_type) \
 517   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 518
 519 #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
 520     handler_type, handler) \
 521   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 522
 523 #define BOOST_ASIO_RANGE_CONNECT_HANDLER_CHECK( \
 524     handler_type, handler, iter_type) \
 525   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 526
 527 #define BOOST_ASIO_ITERATOR_CONNECT_HANDLER_CHECK( \
 528     handler_type, handler, iter_type) \
 529   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 530
 531 #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
 532     handler_type, handler, iter_type) \
 533   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 534
 535 #define BOOST_ASIO_WAIT_HANDLER_CHECK( \
 536     handler_type, handler) \
 537   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 538
 539 #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
 540     handler_type, handler) \
 541   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 542
 543 #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
 544     handler_type, handler) \
 545   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 546
 547 #define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
 548     handler_type, handler) \
 549   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 550
 551 #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
 552     handler_type, handler) \
 553   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 554
 555 #endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 556
 557 } // namespace detail
 558 } // namespace asio
 559 } // namespace boost
 560
 561 #endif // BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP