falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6901 Commits
16 Branches
14GB
Tree: ade014c971
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ade014c971'
${ noResults }
Carla/source/modules/hylia/link/asio/detail/is_buffer_sequence.hpp

307 lines
7.5KB
Raw Blame History 

  1. //

  2. // detail/is_buffer_sequence.hpp

  3. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  4. //

  5. // Copyright (c) 2003-2019 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. template <typename>

  57. char (&buffer_sequence_begin_helper(...))[2];

  58. 

  59. #if defined(ASIO_HAS_DECLTYPE)

  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*);

  66. 

  67. #else // defined(ASIO_HAS_DECLTYPE)

  68. 

  69. template <typename T>

  70. char buffer_sequence_begin_helper(T* t,

  71.     buffer_sequence_memfns_check<

  72.       void (buffer_sequence_memfns_base::*)(),

  73.       &buffer_sequence_memfns_derived<T>::begin>*);

  74. 

  75. #endif // defined(ASIO_HAS_DECLTYPE)

  76. 

  77. template <typename>

  78. char (&buffer_sequence_end_helper(...))[2];

  79. 

  80. #if defined(ASIO_HAS_DECLTYPE)

  81. 

  82. template <typename T>

  83. char buffer_sequence_end_helper(T* t,

  84.     typename enable_if<!is_same<

  85.       decltype(asio::buffer_sequence_end(*t)),

  86.         void>::value>::type*);

  87. 

  88. #else // defined(ASIO_HAS_DECLTYPE)

  89. 

  90. template <typename T>

  91. char buffer_sequence_end_helper(T* t,

  92.     buffer_sequence_memfns_check<

  93.       void (buffer_sequence_memfns_base::*)(),

  94.       &buffer_sequence_memfns_derived<T>::end>*);

  95. 

  96. #endif // defined(ASIO_HAS_DECLTYPE)

  97. 

  98. template <typename>

  99. char (&size_memfn_helper(...))[2];

  100. 

  101. template <typename T>

  102. char size_memfn_helper(

  103.     buffer_sequence_memfns_check<

  104.       void (buffer_sequence_memfns_base::*)(),

  105.       &buffer_sequence_memfns_derived<T>::size>*);

  106. 

  107. template <typename>

  108. char (&max_size_memfn_helper(...))[2];

  109. 

  110. template <typename T>

  111. char max_size_memfn_helper(

  112.     buffer_sequence_memfns_check<

  113.       void (buffer_sequence_memfns_base::*)(),

  114.       &buffer_sequence_memfns_derived<T>::max_size>*);

  115. 

  116. template <typename>

  117. char (&capacity_memfn_helper(...))[2];

  118. 

  119. template <typename T>

  120. char capacity_memfn_helper(

  121.     buffer_sequence_memfns_check<

  122.       void (buffer_sequence_memfns_base::*)(),

  123.       &buffer_sequence_memfns_derived<T>::capacity>*);

  124. 

  125. template <typename>

  126. char (&data_memfn_helper(...))[2];

  127. 

  128. template <typename T>

  129. char data_memfn_helper(

  130.     buffer_sequence_memfns_check<

  131.       void (buffer_sequence_memfns_base::*)(),

  132.       &buffer_sequence_memfns_derived<T>::data>*);

  133. 

  134. template <typename>

  135. char (&prepare_memfn_helper(...))[2];

  136. 

  137. template <typename T>

  138. char prepare_memfn_helper(

  139.     buffer_sequence_memfns_check<

  140.       void (buffer_sequence_memfns_base::*)(),

  141.       &buffer_sequence_memfns_derived<T>::prepare>*);

  142. 

  143. template <typename>

  144. char (&commit_memfn_helper(...))[2];

  145. 

  146. template <typename T>

  147. char commit_memfn_helper(

  148.     buffer_sequence_memfns_check<

  149.       void (buffer_sequence_memfns_base::*)(),

  150.       &buffer_sequence_memfns_derived<T>::commit>*);

  151. 

  152. template <typename>

  153. char (&consume_memfn_helper(...))[2];

  154. 

  155. template <typename T>

  156. char consume_memfn_helper(

  157.     buffer_sequence_memfns_check<

  158.       void (buffer_sequence_memfns_base::*)(),

  159.       &buffer_sequence_memfns_derived<T>::consume>*);

  160. 

  161. template <typename>

  162. char (&grow_memfn_helper(...))[2];

  163. 

  164. template <typename T>

  165. char grow_memfn_helper(

  166.     buffer_sequence_memfns_check<

  167.       void (buffer_sequence_memfns_base::*)(),

  168.       &buffer_sequence_memfns_derived<T>::grow>*);

  169. 

  170. template <typename>

  171. char (&shrink_memfn_helper(...))[2];

  172. 

  173. template <typename T>

  174. char shrink_memfn_helper(

  175.     buffer_sequence_memfns_check<

  176.       void (buffer_sequence_memfns_base::*)(),

  177.       &buffer_sequence_memfns_derived<T>::shrink>*);

  178. 

  179. template <typename, typename>

  180. char (&buffer_sequence_element_type_helper(...))[2];

  181. 

  182. #if defined(ASIO_HAS_DECLTYPE)

  183. 

  184. template <typename T, typename Buffer>

  185. char buffer_sequence_element_type_helper(T* t,

  186.     typename enable_if<is_convertible<

  187.       decltype(*asio::buffer_sequence_begin(*t)),

  188.         Buffer>::value>::type*);

  189. 

  190. #else // defined(ASIO_HAS_DECLTYPE)

  191. 

  192. template <typename T, typename Buffer>

  193. char buffer_sequence_element_type_helper(

  194.     typename T::const_iterator*,

  195.     typename enable_if<is_convertible<

  196.       typename T::value_type, Buffer>::value>::type*);

  197. 

  198. #endif // defined(ASIO_HAS_DECLTYPE)

  199. 

  200. template <typename>

  201. char (&const_buffers_type_typedef_helper(...))[2];

  202. 

  203. template <typename T>

  204. char const_buffers_type_typedef_helper(

  205.     typename T::const_buffers_type*);

  206. 

  207. template <typename>

  208. char (&mutable_buffers_type_typedef_helper(...))[2];

  209. 

  210. template <typename T>

  211. char mutable_buffers_type_typedef_helper(

  212.     typename T::mutable_buffers_type*);

  213. 

  214. template <typename T, typename Buffer>

  215. struct is_buffer_sequence_class

  216.   : integral_constant<bool,

  217.       sizeof(buffer_sequence_begin_helper<T>(0)) != 1 &&

  218.       sizeof(buffer_sequence_end_helper<T>(0)) != 1 &&

  219.       sizeof(buffer_sequence_element_type_helper<T, Buffer>(0, 0)) == 1>

  220. {

  221. };

  222. 

  223. template <typename T, typename Buffer>

  224. struct is_buffer_sequence

  225.   : conditional<is_class<T>::value,

  226.       is_buffer_sequence_class<T, Buffer>,

  227.       false_type>::type

  228. {

  229. };

  230. 

  231. template <>

  232. struct is_buffer_sequence<mutable_buffer, mutable_buffer>

  233.   : true_type

  234. {

  235. };

  236. 

  237. template <>

  238. struct is_buffer_sequence<mutable_buffer, const_buffer>

  239.   : true_type

  240. {

  241. };

  242. 

  243. template <>

  244. struct is_buffer_sequence<const_buffer, const_buffer>

  245.   : true_type

  246. {

  247. };

  248. 

  249. template <>

  250. struct is_buffer_sequence<const_buffer, mutable_buffer>

  251.   : false_type

  252. {

  253. };

  254. 

  255. template <typename T>

  256. struct is_dynamic_buffer_class_v1

  257.   : integral_constant<bool,

  258.       sizeof(size_memfn_helper<T>(0)) != 1 &&

  259.       sizeof(max_size_memfn_helper<T>(0)) != 1 &&

  260.       sizeof(capacity_memfn_helper<T>(0)) != 1 &&

  261.       sizeof(data_memfn_helper<T>(0)) != 1 &&

  262.       sizeof(consume_memfn_helper<T>(0)) != 1 &&

  263.       sizeof(prepare_memfn_helper<T>(0)) != 1 &&

  264.       sizeof(commit_memfn_helper<T>(0)) != 1 &&

  265.       sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&

  266.       sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>

  267. {

  268. };

  269. 

  270. template <typename T>

  271. struct is_dynamic_buffer_v1

  272.   : conditional<is_class<T>::value,

  273.       is_dynamic_buffer_class_v1<T>,

  274.       false_type>::type

  275. {

  276. };

  277. 

  278. template <typename T>

  279. struct is_dynamic_buffer_class_v2

  280.   : integral_constant<bool,

  281.       sizeof(size_memfn_helper<T>(0)) != 1 &&

  282.       sizeof(max_size_memfn_helper<T>(0)) != 1 &&

  283.       sizeof(capacity_memfn_helper<T>(0)) != 1 &&

  284.       sizeof(data_memfn_helper<T>(0)) != 1 &&

  285.       sizeof(consume_memfn_helper<T>(0)) != 1 &&

  286.       sizeof(grow_memfn_helper<T>(0)) != 1 &&

  287.       sizeof(shrink_memfn_helper<T>(0)) != 1 &&

  288.       sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&

  289.       sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>

  290. {

  291. };

  292. 

  293. template <typename T>

  294. struct is_dynamic_buffer_v2

  295.   : conditional<is_class<T>::value,

  296.       is_dynamic_buffer_class_v2<T>,

  297.       false_type>::type

  298. {

  299. };

  300. 

  301. } // namespace detail

  302. } // namespace asio

  303. 

  304. #include "asio/detail/pop_options.hpp"

  305. 

  306. #endif // ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP