is_buffer_sequence.hpp 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241
  1. //
  2. // detail/is_buffer_sequence.hpp
  3. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4. //
  5. // Copyright (c) 2003-2018 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. #ifndef BOOST_ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
  11. #define BOOST_ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
  12. #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  13. # pragma once
  14. #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  15. #include <boost/asio/detail/config.hpp>
  16. #include <boost/asio/detail/type_traits.hpp>
  17. #include <boost/asio/detail/push_options.hpp>
  18. namespace boost {
  19. namespace asio {
  20. class mutable_buffer;
  21. class const_buffer;
  22. namespace detail {
  23. struct buffer_sequence_memfns_base
  24. {
  25. void begin();
  26. void end();
  27. void size();
  28. void max_size();
  29. void capacity();
  30. void data();
  31. void prepare();
  32. void commit();
  33. void consume();
  34. };
  35. template <typename T>
  36. struct buffer_sequence_memfns_derived
  37. : T, buffer_sequence_memfns_base
  38. {
  39. };
  40. template <typename T, T>
  41. struct buffer_sequence_memfns_check
  42. {
  43. };
  44. template <typename>
  45. char (&begin_memfn_helper(...))[2];
  46. template <typename T>
  47. char begin_memfn_helper(
  48. buffer_sequence_memfns_check<
  49. void (buffer_sequence_memfns_base::*)(),
  50. &buffer_sequence_memfns_derived<T>::begin>*);
  51. template <typename>
  52. char (&end_memfn_helper(...))[2];
  53. template <typename T>
  54. char end_memfn_helper(
  55. buffer_sequence_memfns_check<
  56. void (buffer_sequence_memfns_base::*)(),
  57. &buffer_sequence_memfns_derived<T>::end>*);
  58. template <typename>
  59. char (&size_memfn_helper(...))[2];
  60. template <typename T>
  61. char size_memfn_helper(
  62. buffer_sequence_memfns_check<
  63. void (buffer_sequence_memfns_base::*)(),
  64. &buffer_sequence_memfns_derived<T>::size>*);
  65. template <typename>
  66. char (&max_size_memfn_helper(...))[2];
  67. template <typename T>
  68. char max_size_memfn_helper(
  69. buffer_sequence_memfns_check<
  70. void (buffer_sequence_memfns_base::*)(),
  71. &buffer_sequence_memfns_derived<T>::max_size>*);
  72. template <typename>
  73. char (&capacity_memfn_helper(...))[2];
  74. template <typename T>
  75. char capacity_memfn_helper(
  76. buffer_sequence_memfns_check<
  77. void (buffer_sequence_memfns_base::*)(),
  78. &buffer_sequence_memfns_derived<T>::capacity>*);
  79. template <typename>
  80. char (&data_memfn_helper(...))[2];
  81. template <typename T>
  82. char data_memfn_helper(
  83. buffer_sequence_memfns_check<
  84. void (buffer_sequence_memfns_base::*)(),
  85. &buffer_sequence_memfns_derived<T>::data>*);
  86. template <typename>
  87. char (&prepare_memfn_helper(...))[2];
  88. template <typename T>
  89. char prepare_memfn_helper(
  90. buffer_sequence_memfns_check<
  91. void (buffer_sequence_memfns_base::*)(),
  92. &buffer_sequence_memfns_derived<T>::prepare>*);
  93. template <typename>
  94. char (&commit_memfn_helper(...))[2];
  95. template <typename T>
  96. char commit_memfn_helper(
  97. buffer_sequence_memfns_check<
  98. void (buffer_sequence_memfns_base::*)(),
  99. &buffer_sequence_memfns_derived<T>::commit>*);
  100. template <typename>
  101. char (&consume_memfn_helper(...))[2];
  102. template <typename T>
  103. char consume_memfn_helper(
  104. buffer_sequence_memfns_check<
  105. void (buffer_sequence_memfns_base::*)(),
  106. &buffer_sequence_memfns_derived<T>::consume>*);
  107. template <typename, typename>
  108. char (&buffer_element_type_helper(...))[2];
  109. #if defined(BOOST_ASIO_HAS_DECL_TYPE)
  110. template <typename T, typename Buffer>
  111. char buffer_element_type_helper(T* t,
  112. typename enable_if<is_convertible<
  113. decltype(*buffer_sequence_begin(*t)),
  114. Buffer>::value>::type*);
  115. #else // defined(BOOST_ASIO_HAS_DECL_TYPE)
  116. template <typename T, typename Buffer>
  117. char buffer_element_type_helper(
  118. typename T::const_iterator*,
  119. typename enable_if<is_convertible<
  120. typename T::value_type, Buffer>::value>::type*);
  121. #endif // defined(BOOST_ASIO_HAS_DECL_TYPE)
  122. template <typename>
  123. char (&const_buffers_type_typedef_helper(...))[2];
  124. template <typename T>
  125. char const_buffers_type_typedef_helper(
  126. typename T::const_buffers_type*);
  127. template <typename>
  128. char (&mutable_buffers_type_typedef_helper(...))[2];
  129. template <typename T>
  130. char mutable_buffers_type_typedef_helper(
  131. typename T::mutable_buffers_type*);
  132. template <typename T, typename Buffer>
  133. struct is_buffer_sequence_class
  134. : integral_constant<bool,
  135. sizeof(begin_memfn_helper<T>(0)) != 1 &&
  136. sizeof(end_memfn_helper<T>(0)) != 1 &&
  137. sizeof(buffer_element_type_helper<T, Buffer>(0, 0)) == 1>
  138. {
  139. };
  140. template <typename T, typename Buffer>
  141. struct is_buffer_sequence
  142. : conditional<is_class<T>::value,
  143. is_buffer_sequence_class<T, Buffer>,
  144. false_type>::type
  145. {
  146. };
  147. template <>
  148. struct is_buffer_sequence<mutable_buffer, mutable_buffer>
  149. : true_type
  150. {
  151. };
  152. template <>
  153. struct is_buffer_sequence<mutable_buffer, const_buffer>
  154. : true_type
  155. {
  156. };
  157. template <>
  158. struct is_buffer_sequence<const_buffer, const_buffer>
  159. : true_type
  160. {
  161. };
  162. template <>
  163. struct is_buffer_sequence<const_buffer, mutable_buffer>
  164. : false_type
  165. {
  166. };
  167. template <typename T>
  168. struct is_dynamic_buffer_class
  169. : integral_constant<bool,
  170. sizeof(size_memfn_helper<T>(0)) != 1 &&
  171. sizeof(max_size_memfn_helper<T>(0)) != 1 &&
  172. sizeof(capacity_memfn_helper<T>(0)) != 1 &&
  173. sizeof(data_memfn_helper<T>(0)) != 1 &&
  174. sizeof(consume_memfn_helper<T>(0)) != 1 &&
  175. sizeof(prepare_memfn_helper<T>(0)) != 1 &&
  176. sizeof(commit_memfn_helper<T>(0)) != 1 &&
  177. sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&
  178. sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>
  179. {
  180. };
  181. template <typename T>
  182. struct is_dynamic_buffer
  183. : conditional<is_class<T>::value,
  184. is_dynamic_buffer_class<T>,
  185. false_type>::type
  186. {
  187. };
  188. } // namespace detail
  189. } // namespace asio
  190. } // namespace boost
  191. #include <boost/asio/detail/pop_options.hpp>
  192. #endif // BOOST_ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP