/src/contrib/boost/asio/detail/buffer_sequence_adapter.hpp

http://pythonocc.googlecode.com/ · C++ Header · 254 lines · 203 code · 40 blank · 11 comment · 20 complexity · 8aa1f39f6c6450c24075b6594c8d645e MD5 · raw file

  1. //
  2. // buffer_sequence_adapter.hpp
  3. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4. //
  5. // Copyright (c) 2003-2010 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_BUFFER_SEQUENCE_ADAPTER_HPP
  11. #define BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_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/push_options.hpp>
  16. #include <boost/asio/buffer.hpp>
  17. namespace boost {
  18. namespace asio {
  19. namespace detail {
  20. class buffer_sequence_adapter_base
  21. {
  22. protected:
  23. #if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
  24. typedef WSABUF native_buffer_type;
  25. static void init_native_buffer(WSABUF& buf,
  26. const boost::asio::mutable_buffer& buffer)
  27. {
  28. buf.buf = boost::asio::buffer_cast<char*>(buffer);
  29. buf.len = boost::asio::buffer_size(buffer);
  30. }
  31. static void init_native_buffer(WSABUF& buf,
  32. const boost::asio::const_buffer& buffer)
  33. {
  34. buf.buf = const_cast<char*>(boost::asio::buffer_cast<const char*>(buffer));
  35. buf.len = boost::asio::buffer_size(buffer);
  36. }
  37. #else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
  38. typedef iovec native_buffer_type;
  39. static void init_iov_base(void*& base, void* addr)
  40. {
  41. base = addr;
  42. }
  43. template <typename T>
  44. static void init_iov_base(T& base, void* addr)
  45. {
  46. base = static_cast<T>(addr);
  47. }
  48. static void init_native_buffer(iovec& iov,
  49. const boost::asio::mutable_buffer& buffer)
  50. {
  51. init_iov_base(iov.iov_base, boost::asio::buffer_cast<void*>(buffer));
  52. iov.iov_len = boost::asio::buffer_size(buffer);
  53. }
  54. static void init_native_buffer(iovec& iov,
  55. const boost::asio::const_buffer& buffer)
  56. {
  57. init_iov_base(iov.iov_base, const_cast<void*>(
  58. boost::asio::buffer_cast<const void*>(buffer)));
  59. iov.iov_len = boost::asio::buffer_size(buffer);
  60. }
  61. #endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
  62. };
  63. // Helper class to translate buffers into the native buffer representation.
  64. template <typename Buffer, typename Buffers>
  65. class buffer_sequence_adapter
  66. : buffer_sequence_adapter_base
  67. {
  68. public:
  69. explicit buffer_sequence_adapter(const Buffers& buffers)
  70. : count_(0), total_buffer_size_(0)
  71. {
  72. typename Buffers::const_iterator iter = buffers.begin();
  73. typename Buffers::const_iterator end = buffers.end();
  74. for (; iter != end && count_ < max_buffers; ++iter, ++count_)
  75. {
  76. Buffer buffer(*iter);
  77. init_native_buffer(buffers_[count_], buffer);
  78. total_buffer_size_ += boost::asio::buffer_size(buffer);
  79. }
  80. }
  81. native_buffer_type* buffers()
  82. {
  83. return buffers_;
  84. }
  85. std::size_t count() const
  86. {
  87. return count_;
  88. }
  89. bool all_empty() const
  90. {
  91. return total_buffer_size_ == 0;
  92. }
  93. static bool all_empty(const Buffers& buffers)
  94. {
  95. typename Buffers::const_iterator iter = buffers.begin();
  96. typename Buffers::const_iterator end = buffers.end();
  97. std::size_t i = 0;
  98. for (; iter != end && i < max_buffers; ++iter, ++i)
  99. if (boost::asio::buffer_size(Buffer(*iter)) > 0)
  100. return false;
  101. return true;
  102. }
  103. static void validate(const Buffers& buffers)
  104. {
  105. typename Buffers::const_iterator iter = buffers.begin();
  106. typename Buffers::const_iterator end = buffers.end();
  107. for (; iter != end; ++iter)
  108. {
  109. Buffer buffer(*iter);
  110. boost::asio::buffer_cast<const void*>(buffer);
  111. }
  112. }
  113. static Buffer first(const Buffers& buffers)
  114. {
  115. typename Buffers::const_iterator iter = buffers.begin();
  116. typename Buffers::const_iterator end = buffers.end();
  117. for (; iter != end; ++iter)
  118. {
  119. Buffer buffer(*iter);
  120. if (boost::asio::buffer_size(buffer) != 0)
  121. return buffer;
  122. }
  123. return Buffer();
  124. }
  125. private:
  126. // The maximum number of buffers to support in a single operation.
  127. enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
  128. native_buffer_type buffers_[max_buffers];
  129. std::size_t count_;
  130. std::size_t total_buffer_size_;
  131. };
  132. template <typename Buffer>
  133. class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
  134. : buffer_sequence_adapter_base
  135. {
  136. public:
  137. explicit buffer_sequence_adapter(
  138. const boost::asio::mutable_buffers_1& buffers)
  139. {
  140. init_native_buffer(buffer_, buffers);
  141. total_buffer_size_ = boost::asio::buffer_size(buffers);
  142. }
  143. native_buffer_type* buffers()
  144. {
  145. return &buffer_;
  146. }
  147. std::size_t count() const
  148. {
  149. return 1;
  150. }
  151. bool all_empty() const
  152. {
  153. return total_buffer_size_ == 0;
  154. }
  155. static bool all_empty(const boost::asio::mutable_buffers_1& buffers)
  156. {
  157. return boost::asio::buffer_size(buffers) == 0;
  158. }
  159. static void validate(const boost::asio::mutable_buffers_1& buffers)
  160. {
  161. boost::asio::buffer_cast<const void*>(buffers);
  162. }
  163. static Buffer first(const boost::asio::mutable_buffers_1& buffers)
  164. {
  165. return Buffer(buffers);
  166. }
  167. private:
  168. native_buffer_type buffer_;
  169. std::size_t total_buffer_size_;
  170. };
  171. template <typename Buffer>
  172. class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
  173. : buffer_sequence_adapter_base
  174. {
  175. public:
  176. explicit buffer_sequence_adapter(
  177. const boost::asio::const_buffers_1& buffers)
  178. {
  179. init_native_buffer(buffer_, buffers);
  180. total_buffer_size_ = boost::asio::buffer_size(buffers);
  181. }
  182. native_buffer_type* buffers()
  183. {
  184. return &buffer_;
  185. }
  186. std::size_t count() const
  187. {
  188. return 1;
  189. }
  190. bool all_empty() const
  191. {
  192. return total_buffer_size_ == 0;
  193. }
  194. static bool all_empty(const boost::asio::const_buffers_1& buffers)
  195. {
  196. return boost::asio::buffer_size(buffers) == 0;
  197. }
  198. static void validate(const boost::asio::const_buffers_1& buffers)
  199. {
  200. boost::asio::buffer_cast<const void*>(buffers);
  201. }
  202. static Buffer first(const boost::asio::const_buffers_1& buffers)
  203. {
  204. return Buffer(buffers);
  205. }
  206. private:
  207. native_buffer_type buffer_;
  208. std::size_t total_buffer_size_;
  209. };
  210. } // namespace detail
  211. } // namespace asio
  212. } // namespace boost
  213. #include <boost/asio/detail/pop_options.hpp>
  214. #endif // BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP