Realistic 3D camera system
3D camera system components
handler_type_requirements.hpp
Go to the documentation of this file.
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 ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
12 #define 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 "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(ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
24 # if !defined(__GNUC__) || (__GNUC__ >= 4)
25 # define ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1
26 # endif // !defined(__GNUC__) || (__GNUC__ >= 4)
27 #endif // !defined(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(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 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(ASIO_MSVC)
41 # if (_MSC_VER >= 1600)
42 # define ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
43 # endif // (_MSC_VER >= 1600)
44 # endif // defined(ASIO_MSVC)
45 # if defined(__clang__)
46 # if __has_feature(__cxx_static_assert__)
47 # define ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
48 # endif // __has_feature(cxx_static_assert)
49 # endif // defined(__clang__)
50 #endif // !defined(ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
51 
52 #if defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
53 # include "asio/handler_type.hpp"
54 #endif // defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
55 
56 // Newer gcc needs special treatment to suppress unused typedef warnings.
57 #if defined(__GNUC__)
58 # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
59 # define ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
60 # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
61 #endif // defined(__GNUC__)
62 #if !defined(ASIO_UNUSED_TYPEDEF)
63 # define ASIO_UNUSED_TYPEDEF
64 #endif // !defined(ASIO_UNUSED_TYPEDEF)
65 
66 namespace asio {
67 namespace detail {
68 
69 #if defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
70 
71 # if defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
72 
73 template <typename Handler>
74 auto zero_arg_handler_test(Handler h, void*)
75  -> decltype(
76  sizeof(Handler(static_cast<const Handler&>(h))),
77  ((h)()),
78  char(0));
79 
80 template <typename Handler>
81 char (&zero_arg_handler_test(Handler, ...))[2];
82 
83 template <typename Handler, typename Arg1>
84 auto one_arg_handler_test(Handler h, Arg1* a1)
85  -> decltype(
86  sizeof(Handler(static_cast<const Handler&>(h))),
87  ((h)(*a1)),
88  char(0));
89 
90 template <typename Handler>
91 char (&one_arg_handler_test(Handler h, ...))[2];
92 
93 template <typename Handler, typename Arg1, typename Arg2>
94 auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
95  -> decltype(
96  sizeof(Handler(static_cast<const Handler&>(h))),
97  ((h)(*a1, *a2)),
98  char(0));
99 
100 template <typename Handler>
101 char (&two_arg_handler_test(Handler, ...))[2];
102 
103 # define ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) \
104  static_assert(expr, msg);
105 
106 # else // defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
107 
108 # define ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg)
109 
110 # endif // defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
111 
112 template <typename T> T& lvref();
113 template <typename T> T& lvref(T);
114 template <typename T> const T& clvref();
115 template <typename T> const T& clvref(T);
116 template <typename T> char argbyv(T);
117 
118 template <int>
119 struct handler_type_requirements
120 {
121 };
122 
123 #define ASIO_COMPLETION_HANDLER_CHECK( \
124  handler_type, handler) \
125  \
126  typedef ASIO_HANDLER_TYPE(handler_type, \
127  void()) asio_true_handler_type; \
128  \
129  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
130  sizeof(asio::detail::zero_arg_handler_test( \
131  asio::detail::clvref< \
132  asio_true_handler_type>(), 0)) == 1, \
133  "CompletionHandler type requirements not met") \
134  \
135  typedef asio::detail::handler_type_requirements< \
136  sizeof( \
137  asio::detail::argbyv( \
138  asio::detail::clvref< \
139  asio_true_handler_type>())) + \
140  sizeof( \
141  asio::detail::lvref< \
142  asio_true_handler_type>()(), \
143  char(0))> ASIO_UNUSED_TYPEDEF
144 
145 #define ASIO_READ_HANDLER_CHECK( \
146  handler_type, handler) \
147  \
148  typedef ASIO_HANDLER_TYPE(handler_type, \
149  void(asio::error_code, std::size_t)) \
150  asio_true_handler_type; \
151  \
152  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
153  sizeof(asio::detail::two_arg_handler_test( \
154  asio::detail::clvref< \
155  asio_true_handler_type>(), \
156  static_cast<const asio::error_code*>(0), \
157  static_cast<const std::size_t*>(0))) == 1, \
158  "ReadHandler type requirements not met") \
159  \
160  typedef asio::detail::handler_type_requirements< \
161  sizeof( \
162  asio::detail::argbyv( \
163  asio::detail::clvref< \
164  asio_true_handler_type>())) + \
165  sizeof( \
166  asio::detail::lvref< \
167  asio_true_handler_type>()( \
168  asio::detail::lvref<const asio::error_code>(), \
169  asio::detail::lvref<const std::size_t>()), \
170  char(0))> ASIO_UNUSED_TYPEDEF
171 
172 
173 #define ASIO_WRITE_HANDLER_CHECK( \
174  handler_type, handler) \
175  \
176  typedef ASIO_HANDLER_TYPE(handler_type, \
177  void(asio::error_code, std::size_t)) \
178  asio_true_handler_type; \
179  \
180  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
181  sizeof(asio::detail::two_arg_handler_test( \
182  asio::detail::clvref< \
183  asio_true_handler_type>(), \
184  static_cast<const asio::error_code*>(0), \
185  static_cast<const std::size_t*>(0))) == 1, \
186  "WriteHandler type requirements not met") \
187  \
188  typedef asio::detail::handler_type_requirements< \
189  sizeof( \
190  asio::detail::argbyv( \
191  asio::detail::clvref< \
192  asio_true_handler_type>())) + \
193  sizeof( \
194  asio::detail::lvref< \
195  asio_true_handler_type>()( \
196  asio::detail::lvref<const asio::error_code>(), \
197  asio::detail::lvref<const std::size_t>()), \
198  char(0))> ASIO_UNUSED_TYPEDEF
199 
200 #define ASIO_ACCEPT_HANDLER_CHECK( \
201  handler_type, handler) \
202  \
203  typedef ASIO_HANDLER_TYPE(handler_type, \
204  void(asio::error_code)) \
205  asio_true_handler_type; \
206  \
207  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
208  sizeof(asio::detail::one_arg_handler_test( \
209  asio::detail::clvref< \
210  asio_true_handler_type>(), \
211  static_cast<const asio::error_code*>(0))) == 1, \
212  "AcceptHandler type requirements not met") \
213  \
214  typedef asio::detail::handler_type_requirements< \
215  sizeof( \
216  asio::detail::argbyv( \
217  asio::detail::clvref< \
218  asio_true_handler_type>())) + \
219  sizeof( \
220  asio::detail::lvref< \
221  asio_true_handler_type>()( \
222  asio::detail::lvref<const asio::error_code>()), \
223  char(0))> ASIO_UNUSED_TYPEDEF
224 
225 #define ASIO_CONNECT_HANDLER_CHECK( \
226  handler_type, handler) \
227  \
228  typedef ASIO_HANDLER_TYPE(handler_type, \
229  void(asio::error_code)) \
230  asio_true_handler_type; \
231  \
232  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
233  sizeof(asio::detail::one_arg_handler_test( \
234  asio::detail::clvref< \
235  asio_true_handler_type>(), \
236  static_cast<const asio::error_code*>(0))) == 1, \
237  "ConnectHandler type requirements not met") \
238  \
239  typedef asio::detail::handler_type_requirements< \
240  sizeof( \
241  asio::detail::argbyv( \
242  asio::detail::clvref< \
243  asio_true_handler_type>())) + \
244  sizeof( \
245  asio::detail::lvref< \
246  asio_true_handler_type>()( \
247  asio::detail::lvref<const asio::error_code>()), \
248  char(0))> ASIO_UNUSED_TYPEDEF
249 
250 #define ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
251  handler_type, handler, iter_type) \
252  \
253  typedef ASIO_HANDLER_TYPE(handler_type, \
254  void(asio::error_code, iter_type)) \
255  asio_true_handler_type; \
256  \
257  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
258  sizeof(asio::detail::two_arg_handler_test( \
259  asio::detail::clvref< \
260  asio_true_handler_type>(), \
261  static_cast<const asio::error_code*>(0), \
262  static_cast<const iter_type*>(0))) == 1, \
263  "ComposedConnectHandler type requirements not met") \
264  \
265  typedef asio::detail::handler_type_requirements< \
266  sizeof( \
267  asio::detail::argbyv( \
268  asio::detail::clvref< \
269  asio_true_handler_type>())) + \
270  sizeof( \
271  asio::detail::lvref< \
272  asio_true_handler_type>()( \
273  asio::detail::lvref<const asio::error_code>(), \
274  asio::detail::lvref<const iter_type>()), \
275  char(0))> ASIO_UNUSED_TYPEDEF
276 
277 #define ASIO_RESOLVE_HANDLER_CHECK( \
278  handler_type, handler, iter_type) \
279  \
280  typedef ASIO_HANDLER_TYPE(handler_type, \
281  void(asio::error_code, iter_type)) \
282  asio_true_handler_type; \
283  \
284  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
285  sizeof(asio::detail::two_arg_handler_test( \
286  asio::detail::clvref< \
287  asio_true_handler_type>(), \
288  static_cast<const asio::error_code*>(0), \
289  static_cast<const iter_type*>(0))) == 1, \
290  "ResolveHandler type requirements not met") \
291  \
292  typedef asio::detail::handler_type_requirements< \
293  sizeof( \
294  asio::detail::argbyv( \
295  asio::detail::clvref< \
296  asio_true_handler_type>())) + \
297  sizeof( \
298  asio::detail::lvref< \
299  asio_true_handler_type>()( \
300  asio::detail::lvref<const asio::error_code>(), \
301  asio::detail::lvref<const iter_type>()), \
302  char(0))> ASIO_UNUSED_TYPEDEF
303 
304 #define ASIO_WAIT_HANDLER_CHECK( \
305  handler_type, handler) \
306  \
307  typedef ASIO_HANDLER_TYPE(handler_type, \
308  void(asio::error_code)) \
309  asio_true_handler_type; \
310  \
311  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
312  sizeof(asio::detail::one_arg_handler_test( \
313  asio::detail::clvref< \
314  asio_true_handler_type>(), \
315  static_cast<const asio::error_code*>(0))) == 1, \
316  "WaitHandler type requirements not met") \
317  \
318  typedef asio::detail::handler_type_requirements< \
319  sizeof( \
320  asio::detail::argbyv( \
321  asio::detail::clvref< \
322  asio_true_handler_type>())) + \
323  sizeof( \
324  asio::detail::lvref< \
325  asio_true_handler_type>()( \
326  asio::detail::lvref<const asio::error_code>()), \
327  char(0))> ASIO_UNUSED_TYPEDEF
328 
329 #define ASIO_SIGNAL_HANDLER_CHECK( \
330  handler_type, handler) \
331  \
332  typedef ASIO_HANDLER_TYPE(handler_type, \
333  void(asio::error_code, int)) \
334  asio_true_handler_type; \
335  \
336  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
337  sizeof(asio::detail::two_arg_handler_test( \
338  asio::detail::clvref< \
339  asio_true_handler_type>(), \
340  static_cast<const asio::error_code*>(0), \
341  static_cast<const int*>(0))) == 1, \
342  "SignalHandler type requirements not met") \
343  \
344  typedef asio::detail::handler_type_requirements< \
345  sizeof( \
346  asio::detail::argbyv( \
347  asio::detail::clvref< \
348  asio_true_handler_type>())) + \
349  sizeof( \
350  asio::detail::lvref< \
351  asio_true_handler_type>()( \
352  asio::detail::lvref<const asio::error_code>(), \
353  asio::detail::lvref<const int>()), \
354  char(0))> ASIO_UNUSED_TYPEDEF
355 
356 #define ASIO_HANDSHAKE_HANDLER_CHECK( \
357  handler_type, handler) \
358  \
359  typedef ASIO_HANDLER_TYPE(handler_type, \
360  void(asio::error_code)) \
361  asio_true_handler_type; \
362  \
363  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
364  sizeof(asio::detail::one_arg_handler_test( \
365  asio::detail::clvref< \
366  asio_true_handler_type>(), \
367  static_cast<const asio::error_code*>(0))) == 1, \
368  "HandshakeHandler type requirements not met") \
369  \
370  typedef asio::detail::handler_type_requirements< \
371  sizeof( \
372  asio::detail::argbyv( \
373  asio::detail::clvref< \
374  asio_true_handler_type>())) + \
375  sizeof( \
376  asio::detail::lvref< \
377  asio_true_handler_type>()( \
378  asio::detail::lvref<const asio::error_code>()), \
379  char(0))> ASIO_UNUSED_TYPEDEF
380 
381 #define ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
382  handler_type, handler) \
383  \
384  typedef ASIO_HANDLER_TYPE(handler_type, \
385  void(asio::error_code, std::size_t)) \
386  asio_true_handler_type; \
387  \
388  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
389  sizeof(asio::detail::two_arg_handler_test( \
390  asio::detail::clvref< \
391  asio_true_handler_type>(), \
392  static_cast<const asio::error_code*>(0), \
393  static_cast<const std::size_t*>(0))) == 1, \
394  "BufferedHandshakeHandler type requirements not met") \
395  \
396  typedef asio::detail::handler_type_requirements< \
397  sizeof( \
398  asio::detail::argbyv( \
399  asio::detail::clvref< \
400  asio_true_handler_type>())) + \
401  sizeof( \
402  asio::detail::lvref< \
403  asio_true_handler_type>()( \
404  asio::detail::lvref<const asio::error_code>(), \
405  asio::detail::lvref<const std::size_t>()), \
406  char(0))> ASIO_UNUSED_TYPEDEF
407 
408 #define ASIO_SHUTDOWN_HANDLER_CHECK( \
409  handler_type, handler) \
410  \
411  typedef ASIO_HANDLER_TYPE(handler_type, \
412  void(asio::error_code)) \
413  asio_true_handler_type; \
414  \
415  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
416  sizeof(asio::detail::one_arg_handler_test( \
417  asio::detail::clvref< \
418  asio_true_handler_type>(), \
419  static_cast<const asio::error_code*>(0))) == 1, \
420  "ShutdownHandler type requirements not met") \
421  \
422  typedef asio::detail::handler_type_requirements< \
423  sizeof( \
424  asio::detail::argbyv( \
425  asio::detail::clvref< \
426  asio_true_handler_type>())) + \
427  sizeof( \
428  asio::detail::lvref< \
429  asio_true_handler_type>()( \
430  asio::detail::lvref<const asio::error_code>()), \
431  char(0))> ASIO_UNUSED_TYPEDEF
432 
433 #else // !defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
434 
435 #define ASIO_COMPLETION_HANDLER_CHECK( \
436  handler_type, handler) \
437  typedef int ASIO_UNUSED_TYPEDEF
438 
439 #define ASIO_READ_HANDLER_CHECK( \
440  handler_type, handler) \
441  typedef int ASIO_UNUSED_TYPEDEF
442 
443 #define ASIO_WRITE_HANDLER_CHECK( \
444  handler_type, handler) \
445  typedef int ASIO_UNUSED_TYPEDEF
446 
447 #define ASIO_ACCEPT_HANDLER_CHECK( \
448  handler_type, handler) \
449  typedef int ASIO_UNUSED_TYPEDEF
450 
451 #define ASIO_CONNECT_HANDLER_CHECK( \
452  handler_type, handler) \
453  typedef int ASIO_UNUSED_TYPEDEF
454 
455 #define ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
456  handler_type, handler, iter_type) \
457  typedef int ASIO_UNUSED_TYPEDEF
458 
459 #define ASIO_RESOLVE_HANDLER_CHECK( \
460  handler_type, handler, iter_type) \
461  typedef int ASIO_UNUSED_TYPEDEF
462 
463 #define ASIO_WAIT_HANDLER_CHECK( \
464  handler_type, handler) \
465  typedef int ASIO_UNUSED_TYPEDEF
466 
467 #define ASIO_SIGNAL_HANDLER_CHECK( \
468  handler_type, handler) \
469  typedef int ASIO_UNUSED_TYPEDEF
470 
471 #define ASIO_HANDSHAKE_HANDLER_CHECK( \
472  handler_type, handler) \
473  typedef int ASIO_UNUSED_TYPEDEF
474 
475 #define ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
476  handler_type, handler) \
477  typedef int ASIO_UNUSED_TYPEDEF
478 
479 #define ASIO_SHUTDOWN_HANDLER_CHECK( \
480  handler_type, handler) \
481  typedef int ASIO_UNUSED_TYPEDEF
482 
483 #endif // !defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
484 
485 } // namespace detail
486 } // namespace asio
487 
488 #endif // ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
asio::detail::clvref
const T & clvref()
asio::detail::argbyv
char argbyv(T)
asio::detail::handler_type_requirements
Definition: handler_type_requirements.hpp:119
handler_type.hpp
Generated by   doxygen 1.8.11