Statistics
| Revision:

root / tmp / org.txm.statsengine.r.core.win32 / res / win32 / library / BH / include / boost / asio / detail / handler_type_requirements.hpp @ 2486

History | View | Annotate | Download (17.8 kB)

1
//
2
// detail/handler_type_requirements.hpp
3
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4
//
5
// Copyright (c) 2003-2015 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