Clementine
is_buffer_sequence.hpp
1 //
2 // detail/is_buffer_sequence.hpp
3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4 //
5 // Copyright (c) 2003-2020 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_IS_BUFFER_SEQUENCE_HPP
12 #define ASIO_DETAIL_IS_BUFFER_SEQUENCE_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 #include "asio/detail/type_traits.hpp"
20 
21 #include "asio/detail/push_options.hpp"
22 
23 namespace asio {
24 
25 class mutable_buffer;
26 class const_buffer;
27 
28 namespace detail {
29 
30 struct buffer_sequence_memfns_base
31 {
32  void begin();
33  void end();
34  void size();
35  void max_size();
36  void capacity();
37  void data();
38  void prepare();
39  void commit();
40  void consume();
41  void grow();
42  void shrink();
43 };
44 
45 template <typename T>
46 struct buffer_sequence_memfns_derived
47  : T, buffer_sequence_memfns_base
48 {
49 };
50 
51 template <typename T, T>
52 struct buffer_sequence_memfns_check
53 {
54 };
55 
56 #if defined(ASIO_HAS_DECLTYPE)
57 
58 template <typename>
59 char buffer_sequence_begin_helper(...);
60 
61 template <typename T>
62 char (&buffer_sequence_begin_helper(T* t,
63  typename enable_if<!is_same<
64  decltype(asio::buffer_sequence_begin(*t)),
65  void>::value>::type*))[2];
66 
67 #else // defined(ASIO_HAS_DECLTYPE)
68 
69 template <typename>
70 char (&buffer_sequence_begin_helper(...))[2];
71 
72 template <typename T>
73 char buffer_sequence_begin_helper(T* t,
74  buffer_sequence_memfns_check<
75  void (buffer_sequence_memfns_base::*)(),
76  &buffer_sequence_memfns_derived<T>::begin>*);
77 
78 #endif // defined(ASIO_HAS_DECLTYPE)
79 
80 #if defined(ASIO_HAS_DECLTYPE)
81 
82 template <typename>
83 char buffer_sequence_end_helper(...);
84 
85 template <typename T>
86 char (&buffer_sequence_end_helper(T* t,
87  typename enable_if<!is_same<
88  decltype(asio::buffer_sequence_end(*t)),
89  void>::value>::type*))[2];
90 
91 #else // defined(ASIO_HAS_DECLTYPE)
92 
93 template <typename>
94 char (&buffer_sequence_end_helper(...))[2];
95 
96 template <typename T>
97 char buffer_sequence_end_helper(T* t,
98  buffer_sequence_memfns_check<
99  void (buffer_sequence_memfns_base::*)(),
100  &buffer_sequence_memfns_derived<T>::end>*);
101 
102 #endif // defined(ASIO_HAS_DECLTYPE)
103 
104 template <typename>
105 char (&size_memfn_helper(...))[2];
106 
107 template <typename T>
108 char size_memfn_helper(
109  buffer_sequence_memfns_check<
110  void (buffer_sequence_memfns_base::*)(),
111  &buffer_sequence_memfns_derived<T>::size>*);
112 
113 template <typename>
114 char (&max_size_memfn_helper(...))[2];
115 
116 template <typename T>
117 char max_size_memfn_helper(
118  buffer_sequence_memfns_check<
119  void (buffer_sequence_memfns_base::*)(),
120  &buffer_sequence_memfns_derived<T>::max_size>*);
121 
122 template <typename>
123 char (&capacity_memfn_helper(...))[2];
124 
125 template <typename T>
126 char capacity_memfn_helper(
127  buffer_sequence_memfns_check<
128  void (buffer_sequence_memfns_base::*)(),
129  &buffer_sequence_memfns_derived<T>::capacity>*);
130 
131 template <typename>
132 char (&data_memfn_helper(...))[2];
133 
134 template <typename T>
135 char data_memfn_helper(
136  buffer_sequence_memfns_check<
137  void (buffer_sequence_memfns_base::*)(),
138  &buffer_sequence_memfns_derived<T>::data>*);
139 
140 template <typename>
141 char (&prepare_memfn_helper(...))[2];
142 
143 template <typename T>
144 char prepare_memfn_helper(
145  buffer_sequence_memfns_check<
146  void (buffer_sequence_memfns_base::*)(),
147  &buffer_sequence_memfns_derived<T>::prepare>*);
148 
149 template <typename>
150 char (&commit_memfn_helper(...))[2];
151 
152 template <typename T>
153 char commit_memfn_helper(
154  buffer_sequence_memfns_check<
155  void (buffer_sequence_memfns_base::*)(),
156  &buffer_sequence_memfns_derived<T>::commit>*);
157 
158 template <typename>
159 char (&consume_memfn_helper(...))[2];
160 
161 template <typename T>
162 char consume_memfn_helper(
163  buffer_sequence_memfns_check<
164  void (buffer_sequence_memfns_base::*)(),
165  &buffer_sequence_memfns_derived<T>::consume>*);
166 
167 template <typename>
168 char (&grow_memfn_helper(...))[2];
169 
170 template <typename T>
171 char grow_memfn_helper(
172  buffer_sequence_memfns_check<
173  void (buffer_sequence_memfns_base::*)(),
174  &buffer_sequence_memfns_derived<T>::grow>*);
175 
176 template <typename>
177 char (&shrink_memfn_helper(...))[2];
178 
179 template <typename T>
180 char shrink_memfn_helper(
181  buffer_sequence_memfns_check<
182  void (buffer_sequence_memfns_base::*)(),
183  &buffer_sequence_memfns_derived<T>::shrink>*);
184 
185 template <typename, typename>
186 char (&buffer_sequence_element_type_helper(...))[2];
187 
188 #if defined(ASIO_HAS_DECLTYPE)
189 
190 template <typename T, typename Buffer>
191 char buffer_sequence_element_type_helper(T* t,
192  typename enable_if<is_convertible<
193  decltype(*asio::buffer_sequence_begin(*t)),
194  Buffer>::value>::type*);
195 
196 #else // defined(ASIO_HAS_DECLTYPE)
197 
198 template <typename T, typename Buffer>
199 char buffer_sequence_element_type_helper(
200  typename T::const_iterator*,
201  typename enable_if<is_convertible<
202  typename T::value_type, Buffer>::value>::type*);
203 
204 #endif // defined(ASIO_HAS_DECLTYPE)
205 
206 template <typename>
207 char (&const_buffers_type_typedef_helper(...))[2];
208 
209 template <typename T>
210 char const_buffers_type_typedef_helper(
211  typename T::const_buffers_type*);
212 
213 template <typename>
214 char (&mutable_buffers_type_typedef_helper(...))[2];
215 
216 template <typename T>
217 char mutable_buffers_type_typedef_helper(
218  typename T::mutable_buffers_type*);
219 
220 template <typename T, typename Buffer>
221 struct is_buffer_sequence_class
222  : integral_constant<bool,
223  sizeof(buffer_sequence_begin_helper<T>(0, 0)) != 1 &&
224  sizeof(buffer_sequence_end_helper<T>(0, 0)) != 1 &&
225  sizeof(buffer_sequence_element_type_helper<T, Buffer>(0, 0)) == 1>
226 {
227 };
228 
229 template <typename T, typename Buffer>
230 struct is_buffer_sequence
231  : conditional<is_class<T>::value,
232  is_buffer_sequence_class<T, Buffer>,
233  false_type>::type
234 {
235 };
236 
237 template <>
238 struct is_buffer_sequence<mutable_buffer, mutable_buffer>
239  : true_type
240 {
241 };
242 
243 template <>
244 struct is_buffer_sequence<mutable_buffer, const_buffer>
245  : true_type
246 {
247 };
248 
249 template <>
250 struct is_buffer_sequence<const_buffer, const_buffer>
251  : true_type
252 {
253 };
254 
255 template <>
256 struct is_buffer_sequence<const_buffer, mutable_buffer>
257  : false_type
258 {
259 };
260 
261 template <typename T>
262 struct is_dynamic_buffer_class_v1
263  : integral_constant<bool,
264  sizeof(size_memfn_helper<T>(0)) != 1 &&
265  sizeof(max_size_memfn_helper<T>(0)) != 1 &&
266  sizeof(capacity_memfn_helper<T>(0)) != 1 &&
267  sizeof(data_memfn_helper<T>(0)) != 1 &&
268  sizeof(consume_memfn_helper<T>(0)) != 1 &&
269  sizeof(prepare_memfn_helper<T>(0)) != 1 &&
270  sizeof(commit_memfn_helper<T>(0)) != 1 &&
271  sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&
272  sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>
273 {
274 };
275 
276 template <typename T>
277 struct is_dynamic_buffer_v1
278  : conditional<is_class<T>::value,
279  is_dynamic_buffer_class_v1<T>,
280  false_type>::type
281 {
282 };
283 
284 template <typename T>
285 struct is_dynamic_buffer_class_v2
286  : integral_constant<bool,
287  sizeof(size_memfn_helper<T>(0)) != 1 &&
288  sizeof(max_size_memfn_helper<T>(0)) != 1 &&
289  sizeof(capacity_memfn_helper<T>(0)) != 1 &&
290  sizeof(data_memfn_helper<T>(0)) != 1 &&
291  sizeof(consume_memfn_helper<T>(0)) != 1 &&
292  sizeof(grow_memfn_helper<T>(0)) != 1 &&
293  sizeof(shrink_memfn_helper<T>(0)) != 1 &&
294  sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&
295  sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>
296 {
297 };
298 
299 template <typename T>
300 struct is_dynamic_buffer_v2
301  : conditional<is_class<T>::value,
302  is_dynamic_buffer_class_v2<T>,
303  false_type>::type
304 {
305 };
306 
307 } // namespace detail
308 } // namespace asio
309 
310 #include "asio/detail/pop_options.hpp"
311 
312 #endif // ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
asio::detail::is_dynamic_buffer_class_v1
Definition: is_buffer_sequence.hpp:262
asio::const_buffer
Holds a buffer that cannot be modified.
Definition: buffer.hpp:226
asio::detail::is_dynamic_buffer_class_v2
Definition: is_buffer_sequence.hpp:285
asio::detail::buffer_sequence_memfns_base
Definition: is_buffer_sequence.hpp:30
detail
Definition: chrono.h:284
asio::detail::is_buffer_sequence_class
Definition: is_buffer_sequence.hpp:221
asio::detail::buffer_sequence_memfns_check
Definition: is_buffer_sequence.hpp:52
asio::detail::is_dynamic_buffer_v2
Definition: is_buffer_sequence.hpp:300
asio::enable_if
Definition: type_traits.hpp:97
asio::mutable_buffer
Holds a buffer that can be modified.
Definition: buffer.hpp:92
asio::detail::is_dynamic_buffer_v1
Definition: is_buffer_sequence.hpp:277
asio::detail::is_buffer_sequence
Definition: is_buffer_sequence.hpp:230
asio::buffer_sequence_begin
const mutable_buffer * buffer_sequence_begin(const MutableBuffer &b, typename enable_if< is_convertible< const MutableBuffer *, const mutable_buffer *>::value >::type *=0) ASIO_NOEXCEPT
Get an iterator to the first element in a buffer sequence.
Definition: buffer.hpp:388
asio::detail::buffer_sequence_memfns_derived
Definition: is_buffer_sequence.hpp:46
asio::buffer_sequence_end
const mutable_buffer * buffer_sequence_end(const MutableBuffer &b, typename enable_if< is_convertible< const MutableBuffer *, const mutable_buffer *>::value >::type *=0) ASIO_NOEXCEPT
Get an iterator to one past the end element in a buffer sequence.
Definition: buffer.hpp:465
asio
Definition: any_io_executor.hpp:28
Generated by   doxygen 1.8.13