ceph/src/boost/boost/asio/detail/is_buffer_sequence.hpp

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