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

   1 //
   2 // detail/handler_type_requirements.hpp
   3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2016 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/handler_type.hpp>
  54 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
  55
  56 // Newer gcc, clang need special treatment to suppress unused typedef warnings.
  57 #if defined(__clang__)
  58 # if defined(__apple_build_version__)
  59 #  if (__clang_major__ >= 7)
  60 #   define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
  61 #  endif // (__clang_major__ >= 7)
  62 # elif ((__clang_major__ == 3) && (__clang_minor__ >= 6)) \
  63     || (__clang_major__ > 3)
  64 #  define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
  65 # endif // ((__clang_major__ == 3) && (__clang_minor__ >= 6))
  66         //   || (__clang_major__ > 3)
  67 #elif defined(__GNUC__)
  68 # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
  69 #  define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
  70 # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
  71 #endif // defined(__GNUC__)
  72 #if !defined(BOOST_ASIO_UNUSED_TYPEDEF)
  73 # define BOOST_ASIO_UNUSED_TYPEDEF
  74 #endif // !defined(BOOST_ASIO_UNUSED_TYPEDEF)
  75
  76 namespace boost {
  77 namespace asio {
  78 namespace detail {
  79
  80 #if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
  81
  82 # if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
  83
  84 template <typename Handler>
  85 auto zero_arg_handler_test(Handler h, void*)
  86   -> decltype(
  87     sizeof(Handler(static_cast<const Handler&>(h))),
  88     ((h)()),
  89     char(0));
  90
  91 template <typename Handler>
  92 char (&zero_arg_handler_test(Handler, ...))[2];
  93
  94 template <typename Handler, typename Arg1>
  95 auto one_arg_handler_test(Handler h, Arg1* a1)
  96   -> decltype(
  97     sizeof(Handler(static_cast<const Handler&>(h))),
  98     ((h)(*a1)),
  99     char(0));
 100
 101 template <typename Handler>
 102 char (&one_arg_handler_test(Handler h, ...))[2];
 103
 104 template <typename Handler, typename Arg1, typename Arg2>
 105 auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
 106   -> decltype(
 107     sizeof(Handler(static_cast<const Handler&>(h))),
 108     ((h)(*a1, *a2)),
 109     char(0));
 110
 111 template <typename Handler>
 112 char (&two_arg_handler_test(Handler, ...))[2];
 113
 114 #  define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) \
 115      static_assert(expr, msg);
 116
 117 # else // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
 118
 119 #  define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg)
 120
 121 # endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
 122
 123 template <typename T> T& lvref();
 124 template <typename T> T& lvref(T);
 125 template <typename T> const T& clvref();
 126 template <typename T> const T& clvref(T);
 127 template <typename T> char argbyv(T);
 128
 129 template <int>
 130 struct handler_type_requirements
 131 {
 132 };
 133
 134 #define BOOST_ASIO_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_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::lvref< \
 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::clvref< \
 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::clvref< \
 175             asio_true_handler_type>())) + \
 176       sizeof( \
 177         boost::asio::detail::lvref< \
 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
 184 #define BOOST_ASIO_WRITE_HANDLER_CHECK( \
 185     handler_type, handler) \
 186   \
 187   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 188       void(boost::system::error_code, std::size_t)) \
 189     asio_true_handler_type; \
 190   \
 191   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 192       sizeof(boost::asio::detail::two_arg_handler_test( \
 193           boost::asio::detail::clvref< \
 194             asio_true_handler_type>(), \
 195           static_cast<const boost::system::error_code*>(0), \
 196           static_cast<const std::size_t*>(0))) == 1, \
 197       "WriteHandler type requirements not met") \
 198   \
 199   typedef boost::asio::detail::handler_type_requirements< \
 200       sizeof( \
 201         boost::asio::detail::argbyv( \
 202           boost::asio::detail::clvref< \
 203             asio_true_handler_type>())) + \
 204       sizeof( \
 205         boost::asio::detail::lvref< \
 206           asio_true_handler_type>()( \
 207             boost::asio::detail::lvref<const boost::system::error_code>(), \
 208             boost::asio::detail::lvref<const std::size_t>()), \
 209         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 210
 211 #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
 212     handler_type, handler) \
 213   \
 214   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 215       void(boost::system::error_code)) \
 216     asio_true_handler_type; \
 217   \
 218   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 219       sizeof(boost::asio::detail::one_arg_handler_test( \
 220           boost::asio::detail::clvref< \
 221             asio_true_handler_type>(), \
 222           static_cast<const boost::system::error_code*>(0))) == 1, \
 223       "AcceptHandler type requirements not met") \
 224   \
 225   typedef boost::asio::detail::handler_type_requirements< \
 226       sizeof( \
 227         boost::asio::detail::argbyv( \
 228           boost::asio::detail::clvref< \
 229             asio_true_handler_type>())) + \
 230       sizeof( \
 231         boost::asio::detail::lvref< \
 232           asio_true_handler_type>()( \
 233             boost::asio::detail::lvref<const boost::system::error_code>()), \
 234         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 235
 236 #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
 237     handler_type, handler) \
 238   \
 239   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 240       void(boost::system::error_code)) \
 241     asio_true_handler_type; \
 242   \
 243   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 244       sizeof(boost::asio::detail::one_arg_handler_test( \
 245           boost::asio::detail::clvref< \
 246             asio_true_handler_type>(), \
 247           static_cast<const boost::system::error_code*>(0))) == 1, \
 248       "ConnectHandler type requirements not met") \
 249   \
 250   typedef boost::asio::detail::handler_type_requirements< \
 251       sizeof( \
 252         boost::asio::detail::argbyv( \
 253           boost::asio::detail::clvref< \
 254             asio_true_handler_type>())) + \
 255       sizeof( \
 256         boost::asio::detail::lvref< \
 257           asio_true_handler_type>()( \
 258             boost::asio::detail::lvref<const boost::system::error_code>()), \
 259         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 260
 261 #define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
 262     handler_type, handler, iter_type) \
 263   \
 264   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 265       void(boost::system::error_code, iter_type)) \
 266     asio_true_handler_type; \
 267   \
 268   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 269       sizeof(boost::asio::detail::two_arg_handler_test( \
 270           boost::asio::detail::clvref< \
 271             asio_true_handler_type>(), \
 272           static_cast<const boost::system::error_code*>(0), \
 273           static_cast<const iter_type*>(0))) == 1, \
 274       "ComposedConnectHandler type requirements not met") \
 275   \
 276   typedef boost::asio::detail::handler_type_requirements< \
 277       sizeof( \
 278         boost::asio::detail::argbyv( \
 279           boost::asio::detail::clvref< \
 280             asio_true_handler_type>())) + \
 281       sizeof( \
 282         boost::asio::detail::lvref< \
 283           asio_true_handler_type>()( \
 284             boost::asio::detail::lvref<const boost::system::error_code>(), \
 285             boost::asio::detail::lvref<const iter_type>()), \
 286         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 287
 288 #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
 289     handler_type, handler, iter_type) \
 290   \
 291   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 292       void(boost::system::error_code, iter_type)) \
 293     asio_true_handler_type; \
 294   \
 295   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 296       sizeof(boost::asio::detail::two_arg_handler_test( \
 297           boost::asio::detail::clvref< \
 298             asio_true_handler_type>(), \
 299           static_cast<const boost::system::error_code*>(0), \
 300           static_cast<const iter_type*>(0))) == 1, \
 301       "ResolveHandler type requirements not met") \
 302   \
 303   typedef boost::asio::detail::handler_type_requirements< \
 304       sizeof( \
 305         boost::asio::detail::argbyv( \
 306           boost::asio::detail::clvref< \
 307             asio_true_handler_type>())) + \
 308       sizeof( \
 309         boost::asio::detail::lvref< \
 310           asio_true_handler_type>()( \
 311             boost::asio::detail::lvref<const boost::system::error_code>(), \
 312             boost::asio::detail::lvref<const iter_type>()), \
 313         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 314
 315 #define BOOST_ASIO_WAIT_HANDLER_CHECK( \
 316     handler_type, handler) \
 317   \
 318   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 319       void(boost::system::error_code)) \
 320     asio_true_handler_type; \
 321   \
 322   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 323       sizeof(boost::asio::detail::one_arg_handler_test( \
 324           boost::asio::detail::clvref< \
 325             asio_true_handler_type>(), \
 326           static_cast<const boost::system::error_code*>(0))) == 1, \
 327       "WaitHandler type requirements not met") \
 328   \
 329   typedef boost::asio::detail::handler_type_requirements< \
 330       sizeof( \
 331         boost::asio::detail::argbyv( \
 332           boost::asio::detail::clvref< \
 333             asio_true_handler_type>())) + \
 334       sizeof( \
 335         boost::asio::detail::lvref< \
 336           asio_true_handler_type>()( \
 337             boost::asio::detail::lvref<const boost::system::error_code>()), \
 338         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 339
 340 #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
 341     handler_type, handler) \
 342   \
 343   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 344       void(boost::system::error_code, int)) \
 345     asio_true_handler_type; \
 346   \
 347   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 348       sizeof(boost::asio::detail::two_arg_handler_test( \
 349           boost::asio::detail::clvref< \
 350             asio_true_handler_type>(), \
 351           static_cast<const boost::system::error_code*>(0), \
 352           static_cast<const int*>(0))) == 1, \
 353       "SignalHandler type requirements not met") \
 354   \
 355   typedef boost::asio::detail::handler_type_requirements< \
 356       sizeof( \
 357         boost::asio::detail::argbyv( \
 358           boost::asio::detail::clvref< \
 359             asio_true_handler_type>())) + \
 360       sizeof( \
 361         boost::asio::detail::lvref< \
 362           asio_true_handler_type>()( \
 363             boost::asio::detail::lvref<const boost::system::error_code>(), \
 364             boost::asio::detail::lvref<const int>()), \
 365         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 366
 367 #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
 368     handler_type, handler) \
 369   \
 370   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 371       void(boost::system::error_code)) \
 372     asio_true_handler_type; \
 373   \
 374   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 375       sizeof(boost::asio::detail::one_arg_handler_test( \
 376           boost::asio::detail::clvref< \
 377             asio_true_handler_type>(), \
 378           static_cast<const boost::system::error_code*>(0))) == 1, \
 379       "HandshakeHandler type requirements not met") \
 380   \
 381   typedef boost::asio::detail::handler_type_requirements< \
 382       sizeof( \
 383         boost::asio::detail::argbyv( \
 384           boost::asio::detail::clvref< \
 385             asio_true_handler_type>())) + \
 386       sizeof( \
 387         boost::asio::detail::lvref< \
 388           asio_true_handler_type>()( \
 389             boost::asio::detail::lvref<const boost::system::error_code>()), \
 390         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 391
 392 #define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
 393     handler_type, handler) \
 394   \
 395   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 396       void(boost::system::error_code, std::size_t)) \
 397     asio_true_handler_type; \
 398   \
 399   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 400       sizeof(boost::asio::detail::two_arg_handler_test( \
 401           boost::asio::detail::clvref< \
 402             asio_true_handler_type>(), \
 403           static_cast<const boost::system::error_code*>(0), \
 404           static_cast<const std::size_t*>(0))) == 1, \
 405       "BufferedHandshakeHandler type requirements not met") \
 406   \
 407   typedef boost::asio::detail::handler_type_requirements< \
 408       sizeof( \
 409         boost::asio::detail::argbyv( \
 410           boost::asio::detail::clvref< \
 411             asio_true_handler_type>())) + \
 412       sizeof( \
 413         boost::asio::detail::lvref< \
 414           asio_true_handler_type>()( \
 415           boost::asio::detail::lvref<const boost::system::error_code>(), \
 416           boost::asio::detail::lvref<const std::size_t>()), \
 417         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 418
 419 #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
 420     handler_type, handler) \
 421   \
 422   typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
 423       void(boost::system::error_code)) \
 424     asio_true_handler_type; \
 425   \
 426   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
 427       sizeof(boost::asio::detail::one_arg_handler_test( \
 428           boost::asio::detail::clvref< \
 429             asio_true_handler_type>(), \
 430           static_cast<const boost::system::error_code*>(0))) == 1, \
 431       "ShutdownHandler type requirements not met") \
 432   \
 433   typedef boost::asio::detail::handler_type_requirements< \
 434       sizeof( \
 435         boost::asio::detail::argbyv( \
 436           boost::asio::detail::clvref< \
 437             asio_true_handler_type>())) + \
 438       sizeof( \
 439         boost::asio::detail::lvref< \
 440           asio_true_handler_type>()( \
 441             boost::asio::detail::lvref<const boost::system::error_code>()), \
 442         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 443
 444 #else // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 445
 446 #define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \
 447     handler_type, handler) \
 448   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 449
 450 #define BOOST_ASIO_READ_HANDLER_CHECK( \
 451     handler_type, handler) \
 452   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 453
 454 #define BOOST_ASIO_WRITE_HANDLER_CHECK( \
 455     handler_type, handler) \
 456   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 457
 458 #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
 459     handler_type, handler) \
 460   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 461
 462 #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
 463     handler_type, handler) \
 464   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 465
 466 #define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
 467     handler_type, handler, iter_type) \
 468   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 469
 470 #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
 471     handler_type, handler, iter_type) \
 472   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 473
 474 #define BOOST_ASIO_WAIT_HANDLER_CHECK( \
 475     handler_type, handler) \
 476   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 477
 478 #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
 479     handler_type, handler) \
 480   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 481
 482 #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
 483     handler_type, handler) \
 484   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 485
 486 #define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
 487     handler_type, handler) \
 488   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 489
 490 #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
 491     handler_type, handler) \
 492   typedef int BOOST_ASIO_UNUSED_TYPEDEF
 493
 494 #endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 495
 496 } // namespace detail
 497 } // namespace asio
 498 } // namespace boost
 499
 500 #endif // BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP