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.
5361 Commits
16 Branches
16GB
Tree: b082b8b508
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b082b8b508'
${ noResults }
Carla/source/modules/hylia/link/asio/impl/read.hpp

1080 lines
39KB
Raw Blame History 

  1. //

  2. // impl/read.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_IMPL_READ_HPP

  12. #define ASIO_IMPL_READ_HPP

  13. 

  14. #if defined(_MSC_VER) && (_MSC_VER >= 1200)

  15. # pragma once

  16. #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

  17. 

  18. #include <algorithm>

  19. #include "asio/associated_allocator.hpp"

  20. #include "asio/associated_executor.hpp"

  21. #include "asio/buffer.hpp"

  22. #include "asio/completion_condition.hpp"

  23. #include "asio/detail/array_fwd.hpp"

  24. #include "asio/detail/base_from_completion_cond.hpp"

  25. #include "asio/detail/bind_handler.hpp"

  26. #include "asio/detail/consuming_buffers.hpp"

  27. #include "asio/detail/dependent_type.hpp"

  28. #include "asio/detail/handler_alloc_helpers.hpp"

  29. #include "asio/detail/handler_cont_helpers.hpp"

  30. #include "asio/detail/handler_invoke_helpers.hpp"

  31. #include "asio/detail/handler_type_requirements.hpp"

  32. #include "asio/detail/non_const_lvalue.hpp"

  33. #include "asio/detail/throw_error.hpp"

  34. #include "asio/error.hpp"

  35. 

  36. #include "asio/detail/push_options.hpp"

  37. 

  38. namespace asio {

  39. 

  40. namespace detail

  41. {

  42.   template <typename SyncReadStream, typename MutableBufferSequence,

  43.       typename MutableBufferIterator, typename CompletionCondition>

  44.   std::size_t read_buffer_sequence(SyncReadStream& s,

  45.       const MutableBufferSequence& buffers, const MutableBufferIterator&,

  46.       CompletionCondition completion_condition, asio::error_code& ec)

  47.   {

  48.     ec = asio::error_code();

  49.     asio::detail::consuming_buffers<mutable_buffer,

  50.         MutableBufferSequence, MutableBufferIterator> tmp(buffers);

  51.     while (!tmp.empty())

  52.     {

  53.       if (std::size_t max_size = detail::adapt_completion_condition_result(

  54.             completion_condition(ec, tmp.total_consumed())))

  55.         tmp.consume(s.read_some(tmp.prepare(max_size), ec));

  56.       else

  57.         break;

  58.     }

  59.     return tmp.total_consumed();;

  60.   }

  61. } // namespace detail

  62. 

  63. template <typename SyncReadStream, typename MutableBufferSequence,

  64.     typename CompletionCondition>

  65. std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,

  66.     CompletionCondition completion_condition, asio::error_code& ec,

  67.     typename enable_if<

  68.       is_mutable_buffer_sequence<MutableBufferSequence>::value

  69.     >::type*)

  70. {

  71.   return detail::read_buffer_sequence(s, buffers,

  72.       asio::buffer_sequence_begin(buffers),

  73.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec);

  74. }

  75. 

  76. template <typename SyncReadStream, typename MutableBufferSequence>

  77. inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,

  78.     typename enable_if<

  79.       is_mutable_buffer_sequence<MutableBufferSequence>::value

  80.     >::type*)

  81. {

  82.   asio::error_code ec;

  83.   std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);

  84.   asio::detail::throw_error(ec, "read");

  85.   return bytes_transferred;

  86. }

  87. 

  88. template <typename SyncReadStream, typename MutableBufferSequence>

  89. inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,

  90.     asio::error_code& ec,

  91.     typename enable_if<

  92.       is_mutable_buffer_sequence<MutableBufferSequence>::value

  93.     >::type*)

  94. {

  95.   return read(s, buffers, transfer_all(), ec);

  96. }

  97. 

  98. template <typename SyncReadStream, typename MutableBufferSequence,

  99.     typename CompletionCondition>

  100. inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,

  101.     CompletionCondition completion_condition,

  102.     typename enable_if<

  103.       is_mutable_buffer_sequence<MutableBufferSequence>::value

  104.     >::type*)

  105. {

  106.   asio::error_code ec;

  107.   std::size_t bytes_transferred = read(s, buffers,

  108.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec);

  109.   asio::detail::throw_error(ec, "read");

  110.   return bytes_transferred;

  111. }

  112. 

  113. #if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  114. 

  115. template <typename SyncReadStream, typename DynamicBuffer_v1,

  116.     typename CompletionCondition>

  117. std::size_t read(SyncReadStream& s,

  118.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  119.     CompletionCondition completion_condition, asio::error_code& ec,

  120.     typename enable_if<

  121.       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value

  122.         && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value

  123.     >::type*)

  124. {

  125.   typename decay<DynamicBuffer_v1>::type b(

  126.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers));

  127. 

  128.   ec = asio::error_code();

  129.   std::size_t total_transferred = 0;

  130.   std::size_t max_size = detail::adapt_completion_condition_result(

  131.         completion_condition(ec, total_transferred));

  132.   std::size_t bytes_available = std::min<std::size_t>(

  133.         std::max<std::size_t>(512, b.capacity() - b.size()),

  134.         std::min<std::size_t>(max_size, b.max_size() - b.size()));

  135.   while (bytes_available > 0)

  136.   {

  137.     std::size_t bytes_transferred = s.read_some(b.prepare(bytes_available), ec);

  138.     b.commit(bytes_transferred);

  139.     total_transferred += bytes_transferred;

  140.     max_size = detail::adapt_completion_condition_result(

  141.           completion_condition(ec, total_transferred));

  142.     bytes_available = std::min<std::size_t>(

  143.           std::max<std::size_t>(512, b.capacity() - b.size()),

  144.           std::min<std::size_t>(max_size, b.max_size() - b.size()));

  145.   }

  146.   return total_transferred;

  147. }

  148. 

  149. template <typename SyncReadStream, typename DynamicBuffer_v1>

  150. inline std::size_t read(SyncReadStream& s,

  151.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  152.     typename enable_if<

  153.       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value

  154.         && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value

  155.     >::type*)

  156. {

  157.   asio::error_code ec;

  158.   std::size_t bytes_transferred = read(s,

  159.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers), transfer_all(), ec);

  160.   asio::detail::throw_error(ec, "read");

  161.   return bytes_transferred;

  162. }

  163. 

  164. template <typename SyncReadStream, typename DynamicBuffer_v1>

  165. inline std::size_t read(SyncReadStream& s,

  166.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  167.     asio::error_code& ec,

  168.     typename enable_if<

  169.       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value

  170.         && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value

  171.     >::type*)

  172. {

  173.   return read(s, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  174.       transfer_all(), ec);

  175. }

  176. 

  177. template <typename SyncReadStream, typename DynamicBuffer_v1,

  178.     typename CompletionCondition>

  179. inline std::size_t read(SyncReadStream& s,

  180.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  181.     CompletionCondition completion_condition,

  182.     typename enable_if<

  183.       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value

  184.         && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value

  185.     >::type*)

  186. {

  187.   asio::error_code ec;

  188.   std::size_t bytes_transferred = read(s,

  189.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  190.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec);

  191.   asio::detail::throw_error(ec, "read");

  192.   return bytes_transferred;

  193. }

  194. 

  195. #if !defined(ASIO_NO_EXTENSIONS)

  196. #if !defined(ASIO_NO_IOSTREAM)

  197. 

  198. template <typename SyncReadStream, typename Allocator,

  199.     typename CompletionCondition>

  200. inline std::size_t read(SyncReadStream& s,

  201.     asio::basic_streambuf<Allocator>& b,

  202.     CompletionCondition completion_condition, asio::error_code& ec)

  203. {

  204.   return read(s, basic_streambuf_ref<Allocator>(b),

  205.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec);

  206. }

  207. 

  208. template <typename SyncReadStream, typename Allocator>

  209. inline std::size_t read(SyncReadStream& s,

  210.     asio::basic_streambuf<Allocator>& b)

  211. {

  212.   return read(s, basic_streambuf_ref<Allocator>(b));

  213. }

  214. 

  215. template <typename SyncReadStream, typename Allocator>

  216. inline std::size_t read(SyncReadStream& s,

  217.     asio::basic_streambuf<Allocator>& b,

  218.     asio::error_code& ec)

  219. {

  220.   return read(s, basic_streambuf_ref<Allocator>(b), ec);

  221. }

  222. 

  223. template <typename SyncReadStream, typename Allocator,

  224.     typename CompletionCondition>

  225. inline std::size_t read(SyncReadStream& s,

  226.     asio::basic_streambuf<Allocator>& b,

  227.     CompletionCondition completion_condition)

  228. {

  229.   return read(s, basic_streambuf_ref<Allocator>(b),

  230.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));

  231. }

  232. 

  233. #endif // !defined(ASIO_NO_IOSTREAM)

  234. #endif // !defined(ASIO_NO_EXTENSIONS)

  235. #endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  236. 

  237. template <typename SyncReadStream, typename DynamicBuffer_v2,

  238.     typename CompletionCondition>

  239. std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,

  240.     CompletionCondition completion_condition, asio::error_code& ec,

  241.     typename enable_if<

  242.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  243.     >::type*)

  244. {

  245.   DynamicBuffer_v2& b = buffers;

  246. 

  247.   ec = asio::error_code();

  248.   std::size_t total_transferred = 0;

  249.   std::size_t max_size = detail::adapt_completion_condition_result(

  250.         completion_condition(ec, total_transferred));

  251.   std::size_t bytes_available = std::min<std::size_t>(

  252.         std::max<std::size_t>(512, b.capacity() - b.size()),

  253.         std::min<std::size_t>(max_size, b.max_size() - b.size()));

  254.   while (bytes_available > 0)

  255.   {

  256.     std::size_t pos = b.size();

  257.     b.grow(bytes_available);

  258.     std::size_t bytes_transferred = s.read_some(

  259.         b.data(pos, bytes_available), ec);

  260.     b.shrink(bytes_available - bytes_transferred);

  261.     total_transferred += bytes_transferred;

  262.     max_size = detail::adapt_completion_condition_result(

  263.           completion_condition(ec, total_transferred));

  264.     bytes_available = std::min<std::size_t>(

  265.           std::max<std::size_t>(512, b.capacity() - b.size()),

  266.           std::min<std::size_t>(max_size, b.max_size() - b.size()));

  267.   }

  268.   return total_transferred;

  269. }

  270. 

  271. template <typename SyncReadStream, typename DynamicBuffer_v2>

  272. inline std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,

  273.     typename enable_if<

  274.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  275.     >::type*)

  276. {

  277.   asio::error_code ec;

  278.   std::size_t bytes_transferred = read(s,

  279.       ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers), transfer_all(), ec);

  280.   asio::detail::throw_error(ec, "read");

  281.   return bytes_transferred;

  282. }

  283. 

  284. template <typename SyncReadStream, typename DynamicBuffer_v2>

  285. inline std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,

  286.     asio::error_code& ec,

  287.     typename enable_if<

  288.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  289.     >::type*)

  290. {

  291.   return read(s, ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  292.       transfer_all(), ec);

  293. }

  294. 

  295. template <typename SyncReadStream, typename DynamicBuffer_v2,

  296.     typename CompletionCondition>

  297. inline std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,

  298.     CompletionCondition completion_condition,

  299.     typename enable_if<

  300.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  301.     >::type*)

  302. {

  303.   asio::error_code ec;

  304.   std::size_t bytes_transferred = read(s,

  305.       ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  306.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec);

  307.   asio::detail::throw_error(ec, "read");

  308.   return bytes_transferred;

  309. }

  310. 

  311. namespace detail

  312. {

  313.   template <typename AsyncReadStream, typename MutableBufferSequence,

  314.       typename MutableBufferIterator, typename CompletionCondition,

  315.       typename ReadHandler>

  316.   class read_op

  317.     : detail::base_from_completion_cond<CompletionCondition>

  318.   {

  319.   public:

  320.     read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,

  321.         CompletionCondition& completion_condition, ReadHandler& handler)

  322.       : detail::base_from_completion_cond<

  323.           CompletionCondition>(completion_condition),

  324.         stream_(stream),

  325.         buffers_(buffers),

  326.         start_(0),

  327.         handler_(ASIO_MOVE_CAST(ReadHandler)(handler))

  328.     {

  329.     }

  330. 

  331. #if defined(ASIO_HAS_MOVE)

  332.     read_op(const read_op& other)

  333.       : detail::base_from_completion_cond<CompletionCondition>(other),

  334.         stream_(other.stream_),

  335.         buffers_(other.buffers_),

  336.         start_(other.start_),

  337.         handler_(other.handler_)

  338.     {

  339.     }

  340. 

  341.     read_op(read_op&& other)

  342.       : detail::base_from_completion_cond<CompletionCondition>(

  343.           ASIO_MOVE_CAST(detail::base_from_completion_cond<

  344.             CompletionCondition>)(other)),

  345.         stream_(other.stream_),

  346.         buffers_(ASIO_MOVE_CAST(buffers_type)(other.buffers_)),

  347.         start_(other.start_),

  348.         handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))

  349.     {

  350.     }

  351. #endif // defined(ASIO_HAS_MOVE)

  352. 

  353.     void operator()(const asio::error_code& ec,

  354.         std::size_t bytes_transferred, int start = 0)

  355.     {

  356.       std::size_t max_size;

  357.       switch (start_ = start)

  358.       {

  359.         case 1:

  360.         max_size = this->check_for_completion(ec, buffers_.total_consumed());

  361.         do

  362.         {

  363.           stream_.async_read_some(buffers_.prepare(max_size),

  364.               ASIO_MOVE_CAST(read_op)(*this));

  365.           return; default:

  366.           buffers_.consume(bytes_transferred);

  367.           if ((!ec && bytes_transferred == 0) || buffers_.empty())

  368.             break;

  369.           max_size = this->check_for_completion(ec, buffers_.total_consumed());

  370.         } while (max_size > 0);

  371. 

  372.         handler_(ec, buffers_.total_consumed());

  373.       }

  374.     }

  375. 

  376.   //private:

  377.     typedef asio::detail::consuming_buffers<mutable_buffer,

  378.         MutableBufferSequence, MutableBufferIterator> buffers_type;

  379. 

  380.     AsyncReadStream& stream_;

  381.     buffers_type buffers_;

  382.     int start_;

  383.     ReadHandler handler_;

  384.   };

  385. 

  386.   template <typename AsyncReadStream, typename MutableBufferSequence,

  387.       typename MutableBufferIterator, typename CompletionCondition,

  388.       typename ReadHandler>

  389.   inline void* asio_handler_allocate(std::size_t size,

  390.       read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,

  391.         CompletionCondition, ReadHandler>* this_handler)

  392.   {

  393.     return asio_handler_alloc_helpers::allocate(

  394.         size, this_handler->handler_);

  395.   }

  396. 

  397.   template <typename AsyncReadStream, typename MutableBufferSequence,

  398.       typename MutableBufferIterator, typename CompletionCondition,

  399.       typename ReadHandler>

  400.   inline void asio_handler_deallocate(void* pointer, std::size_t size,

  401.       read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,

  402.         CompletionCondition, ReadHandler>* this_handler)

  403.   {

  404.     asio_handler_alloc_helpers::deallocate(

  405.         pointer, size, this_handler->handler_);

  406.   }

  407. 

  408.   template <typename AsyncReadStream, typename MutableBufferSequence,

  409.       typename MutableBufferIterator, typename CompletionCondition,

  410.       typename ReadHandler>

  411.   inline bool asio_handler_is_continuation(

  412.       read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,

  413.         CompletionCondition, ReadHandler>* this_handler)

  414.   {

  415.     return this_handler->start_ == 0 ? true

  416.       : asio_handler_cont_helpers::is_continuation(

  417.           this_handler->handler_);

  418.   }

  419. 

  420.   template <typename Function, typename AsyncReadStream,

  421.       typename MutableBufferSequence, typename MutableBufferIterator,

  422.       typename CompletionCondition, typename ReadHandler>

  423.   inline void asio_handler_invoke(Function& function,

  424.       read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,

  425.         CompletionCondition, ReadHandler>* this_handler)

  426.   {

  427.     asio_handler_invoke_helpers::invoke(

  428.         function, this_handler->handler_);

  429.   }

  430. 

  431.   template <typename Function, typename AsyncReadStream,

  432.       typename MutableBufferSequence, typename MutableBufferIterator,

  433.       typename CompletionCondition, typename ReadHandler>

  434.   inline void asio_handler_invoke(const Function& function,

  435.       read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,

  436.         CompletionCondition, ReadHandler>* this_handler)

  437.   {

  438.     asio_handler_invoke_helpers::invoke(

  439.         function, this_handler->handler_);

  440.   }

  441. 

  442.   template <typename AsyncReadStream, typename MutableBufferSequence,

  443.       typename MutableBufferIterator, typename CompletionCondition,

  444.       typename ReadHandler>

  445.   inline void start_read_buffer_sequence_op(AsyncReadStream& stream,

  446.       const MutableBufferSequence& buffers, const MutableBufferIterator&,

  447.       CompletionCondition& completion_condition, ReadHandler& handler)

  448.   {

  449.     detail::read_op<AsyncReadStream, MutableBufferSequence,

  450.       MutableBufferIterator, CompletionCondition, ReadHandler>(

  451.         stream, buffers, completion_condition, handler)(

  452.           asio::error_code(), 0, 1);

  453.   }

  454. 

  455.   struct initiate_async_read_buffer_sequence

  456.   {

  457.     template <typename ReadHandler, typename AsyncReadStream,

  458.         typename MutableBufferSequence, typename CompletionCondition>

  459.     void operator()(ASIO_MOVE_ARG(ReadHandler) handler,

  460.         AsyncReadStream* s, const MutableBufferSequence& buffers,

  461.         ASIO_MOVE_ARG(CompletionCondition) completion_cond) const

  462.     {

  463.       // If you get an error on the following line it means that your handler

  464.       // does not meet the documented type requirements for a ReadHandler.

  465.       ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

  466. 

  467.       non_const_lvalue<ReadHandler> handler2(handler);

  468.       non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);

  469.       start_read_buffer_sequence_op(*s, buffers,

  470.           asio::buffer_sequence_begin(buffers),

  471.           completion_cond2.value, handler2.value);

  472.     }

  473.   };

  474. } // namespace detail

  475. 

  476. #if !defined(GENERATING_DOCUMENTATION)

  477. 

  478. template <typename AsyncReadStream, typename MutableBufferSequence,

  479.     typename MutableBufferIterator, typename CompletionCondition,

  480.     typename ReadHandler, typename Allocator>

  481. struct associated_allocator<

  482.     detail::read_op<AsyncReadStream, MutableBufferSequence,

  483.       MutableBufferIterator, CompletionCondition, ReadHandler>,

  484.     Allocator>

  485. {

  486.   typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  487. 

  488.   static type get(

  489.       const detail::read_op<AsyncReadStream, MutableBufferSequence,

  490.         MutableBufferIterator, CompletionCondition, ReadHandler>& h,

  491.       const Allocator& a = Allocator()) ASIO_NOEXCEPT

  492.   {

  493.     return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);

  494.   }

  495. };

  496. 

  497. template <typename AsyncReadStream, typename MutableBufferSequence,

  498.     typename MutableBufferIterator, typename CompletionCondition,

  499.     typename ReadHandler, typename Executor>

  500. struct associated_executor<

  501.     detail::read_op<AsyncReadStream, MutableBufferSequence,

  502.       MutableBufferIterator, CompletionCondition, ReadHandler>,

  503.     Executor>

  504. {

  505.   typedef typename associated_executor<ReadHandler, Executor>::type type;

  506. 

  507.   static type get(

  508.       const detail::read_op<AsyncReadStream, MutableBufferSequence,

  509.         MutableBufferIterator, CompletionCondition, ReadHandler>& h,

  510.       const Executor& ex = Executor()) ASIO_NOEXCEPT

  511.   {

  512.     return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);

  513.   }

  514. };

  515. 

  516. #endif // !defined(GENERATING_DOCUMENTATION)

  517. 

  518. template <typename AsyncReadStream, typename MutableBufferSequence,

  519.     typename CompletionCondition, typename ReadHandler>

  520. inline ASIO_INITFN_RESULT_TYPE(ReadHandler,

  521.     void (asio::error_code, std::size_t))

  522. async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,

  523.     CompletionCondition completion_condition,

  524.     ASIO_MOVE_ARG(ReadHandler) handler,

  525.     typename enable_if<

  526.       is_mutable_buffer_sequence<MutableBufferSequence>::value

  527.     >::type*)

  528. {

  529.   return async_initiate<ReadHandler,

  530.     void (asio::error_code, std::size_t)>(

  531.       detail::initiate_async_read_buffer_sequence(), handler, &s, buffers,

  532.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));

  533. }

  534. 

  535. template <typename AsyncReadStream, typename MutableBufferSequence,

  536.     typename ReadHandler>

  537. inline ASIO_INITFN_RESULT_TYPE(ReadHandler,

  538.     void (asio::error_code, std::size_t))

  539. async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,

  540.     ASIO_MOVE_ARG(ReadHandler) handler,

  541.     typename enable_if<

  542.       is_mutable_buffer_sequence<MutableBufferSequence>::value

  543.     >::type*)

  544. {

  545.   return async_initiate<ReadHandler,

  546.     void (asio::error_code, std::size_t)>(

  547.       detail::initiate_async_read_buffer_sequence(),

  548.       handler, &s, buffers, transfer_all());

  549. }

  550. 

  551. #if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  552. 

  553. namespace detail

  554. {

  555.   template <typename AsyncReadStream, typename DynamicBuffer_v1,

  556.       typename CompletionCondition, typename ReadHandler>

  557.   class read_dynbuf_v1_op

  558.     : detail::base_from_completion_cond<CompletionCondition>

  559.   {

  560.   public:

  561.     template <typename BufferSequence>

  562.     read_dynbuf_v1_op(AsyncReadStream& stream,

  563.         ASIO_MOVE_ARG(BufferSequence) buffers,

  564.         CompletionCondition& completion_condition, ReadHandler& handler)

  565.       : detail::base_from_completion_cond<

  566.           CompletionCondition>(completion_condition),

  567.         stream_(stream),

  568.         buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)),

  569.         start_(0),

  570.         total_transferred_(0),

  571.         handler_(ASIO_MOVE_CAST(ReadHandler)(handler))

  572.     {

  573.     }

  574. 

  575. #if defined(ASIO_HAS_MOVE)

  576.     read_dynbuf_v1_op(const read_dynbuf_v1_op& other)

  577.       : detail::base_from_completion_cond<CompletionCondition>(other),

  578.         stream_(other.stream_),

  579.         buffers_(other.buffers_),

  580.         start_(other.start_),

  581.         total_transferred_(other.total_transferred_),

  582.         handler_(other.handler_)

  583.     {

  584.     }

  585. 

  586.     read_dynbuf_v1_op(read_dynbuf_v1_op&& other)

  587.       : detail::base_from_completion_cond<CompletionCondition>(

  588.           ASIO_MOVE_CAST(detail::base_from_completion_cond<

  589.             CompletionCondition>)(other)),

  590.         stream_(other.stream_),

  591.         buffers_(ASIO_MOVE_CAST(DynamicBuffer_v1)(other.buffers_)),

  592.         start_(other.start_),

  593.         total_transferred_(other.total_transferred_),

  594.         handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))

  595.     {

  596.     }

  597. #endif // defined(ASIO_HAS_MOVE)

  598. 

  599.     void operator()(const asio::error_code& ec,

  600.         std::size_t bytes_transferred, int start = 0)

  601.     {

  602.       std::size_t max_size, bytes_available;

  603.       switch (start_ = start)

  604.       {

  605.         case 1:

  606.         max_size = this->check_for_completion(ec, total_transferred_);

  607.         bytes_available = std::min<std::size_t>(

  608.               std::max<std::size_t>(512,

  609.                 buffers_.capacity() - buffers_.size()),

  610.               std::min<std::size_t>(max_size,

  611.                 buffers_.max_size() - buffers_.size()));

  612.         for (;;)

  613.         {

  614.           stream_.async_read_some(buffers_.prepare(bytes_available),

  615.               ASIO_MOVE_CAST(read_dynbuf_v1_op)(*this));

  616.           return; default:

  617.           total_transferred_ += bytes_transferred;

  618.           buffers_.commit(bytes_transferred);

  619.           max_size = this->check_for_completion(ec, total_transferred_);

  620.           bytes_available = std::min<std::size_t>(

  621.                 std::max<std::size_t>(512,

  622.                   buffers_.capacity() - buffers_.size()),

  623.                 std::min<std::size_t>(max_size,

  624.                   buffers_.max_size() - buffers_.size()));

  625.           if ((!ec && bytes_transferred == 0) || bytes_available == 0)

  626.             break;

  627.         }

  628. 

  629.         handler_(ec, static_cast<const std::size_t&>(total_transferred_));

  630.       }

  631.     }

  632. 

  633.   //private:

  634.     AsyncReadStream& stream_;

  635.     DynamicBuffer_v1 buffers_;

  636.     int start_;

  637.     std::size_t total_transferred_;

  638.     ReadHandler handler_;

  639.   };

  640. 

  641.   template <typename AsyncReadStream, typename DynamicBuffer_v1,

  642.       typename CompletionCondition, typename ReadHandler>

  643.   inline void* asio_handler_allocate(std::size_t size,

  644.       read_dynbuf_v1_op<AsyncReadStream, DynamicBuffer_v1,

  645.         CompletionCondition, ReadHandler>* this_handler)

  646.   {

  647.     return asio_handler_alloc_helpers::allocate(

  648.         size, this_handler->handler_);

  649.   }

  650. 

  651.   template <typename AsyncReadStream, typename DynamicBuffer_v1,

  652.       typename CompletionCondition, typename ReadHandler>

  653.   inline void asio_handler_deallocate(void* pointer, std::size_t size,

  654.       read_dynbuf_v1_op<AsyncReadStream, DynamicBuffer_v1,

  655.         CompletionCondition, ReadHandler>* this_handler)

  656.   {

  657.     asio_handler_alloc_helpers::deallocate(

  658.         pointer, size, this_handler->handler_);

  659.   }

  660. 

  661.   template <typename AsyncReadStream, typename DynamicBuffer_v1,

  662.       typename CompletionCondition, typename ReadHandler>

  663.   inline bool asio_handler_is_continuation(

  664.       read_dynbuf_v1_op<AsyncReadStream, DynamicBuffer_v1,

  665.         CompletionCondition, ReadHandler>* this_handler)

  666.   {

  667.     return this_handler->start_ == 0 ? true

  668.       : asio_handler_cont_helpers::is_continuation(

  669.           this_handler->handler_);

  670.   }

  671. 

  672.   template <typename Function, typename AsyncReadStream,

  673.       typename DynamicBuffer_v1, typename CompletionCondition,

  674.       typename ReadHandler>

  675.   inline void asio_handler_invoke(Function& function,

  676.       read_dynbuf_v1_op<AsyncReadStream, DynamicBuffer_v1,

  677.         CompletionCondition, ReadHandler>* this_handler)

  678.   {

  679.     asio_handler_invoke_helpers::invoke(

  680.         function, this_handler->handler_);

  681.   }

  682. 

  683.   template <typename Function, typename AsyncReadStream,

  684.       typename DynamicBuffer_v1, typename CompletionCondition,

  685.       typename ReadHandler>

  686.   inline void asio_handler_invoke(const Function& function,

  687.       read_dynbuf_v1_op<AsyncReadStream, DynamicBuffer_v1,

  688.         CompletionCondition, ReadHandler>* this_handler)

  689.   {

  690.     asio_handler_invoke_helpers::invoke(

  691.         function, this_handler->handler_);

  692.   }

  693. 

  694.   struct initiate_async_read_dynbuf_v1

  695.   {

  696.     template <typename ReadHandler, typename AsyncReadStream,

  697.         typename DynamicBuffer_v1, typename CompletionCondition>

  698.     void operator()(ASIO_MOVE_ARG(ReadHandler) handler,

  699.         AsyncReadStream* s, ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  700.         ASIO_MOVE_ARG(CompletionCondition) completion_cond) const

  701.     {

  702.       // If you get an error on the following line it means that your handler

  703.       // does not meet the documented type requirements for a ReadHandler.

  704.       ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

  705. 

  706.       non_const_lvalue<ReadHandler> handler2(handler);

  707.       non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);

  708.       read_dynbuf_v1_op<AsyncReadStream, typename decay<DynamicBuffer_v1>::type,

  709.         CompletionCondition, typename decay<ReadHandler>::type>(

  710.           *s, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  711.             completion_cond2.value, handler2.value)(

  712.               asio::error_code(), 0, 1);

  713.     }

  714.   };

  715. } // namespace detail

  716. 

  717. #if !defined(GENERATING_DOCUMENTATION)

  718. 

  719. template <typename AsyncReadStream, typename DynamicBuffer_v1,

  720.     typename CompletionCondition, typename ReadHandler, typename Allocator>

  721. struct associated_allocator<

  722.     detail::read_dynbuf_v1_op<AsyncReadStream,

  723.       DynamicBuffer_v1, CompletionCondition, ReadHandler>,

  724.     Allocator>

  725. {

  726.   typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  727. 

  728.   static type get(

  729.       const detail::read_dynbuf_v1_op<AsyncReadStream,

  730.         DynamicBuffer_v1, CompletionCondition, ReadHandler>& h,

  731.       const Allocator& a = Allocator()) ASIO_NOEXCEPT

  732.   {

  733.     return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);

  734.   }

  735. };

  736. 

  737. template <typename AsyncReadStream, typename DynamicBuffer_v1,

  738.     typename CompletionCondition, typename ReadHandler, typename Executor>

  739. struct associated_executor<

  740.     detail::read_dynbuf_v1_op<AsyncReadStream,

  741.       DynamicBuffer_v1, CompletionCondition, ReadHandler>,

  742.     Executor>

  743. {

  744.   typedef typename associated_executor<ReadHandler, Executor>::type type;

  745. 

  746.   static type get(

  747.       const detail::read_dynbuf_v1_op<AsyncReadStream,

  748.         DynamicBuffer_v1, CompletionCondition, ReadHandler>& h,

  749.       const Executor& ex = Executor()) ASIO_NOEXCEPT

  750.   {

  751.     return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);

  752.   }

  753. };

  754. 

  755. #endif // !defined(GENERATING_DOCUMENTATION)

  756. 

  757. template <typename AsyncReadStream,

  758.     typename DynamicBuffer_v1, typename ReadHandler>

  759. inline ASIO_INITFN_RESULT_TYPE(ReadHandler,

  760.     void (asio::error_code, std::size_t))

  761. async_read(AsyncReadStream& s,

  762.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  763.     ASIO_MOVE_ARG(ReadHandler) handler,

  764.     typename enable_if<

  765.       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value

  766.         && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value

  767.     >::type*)

  768. {

  769.   return async_read(s,

  770.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  771.       transfer_all(), ASIO_MOVE_CAST(ReadHandler)(handler));

  772. }

  773. 

  774. template <typename AsyncReadStream, typename DynamicBuffer_v1,

  775.     typename CompletionCondition, typename ReadHandler>

  776. inline ASIO_INITFN_RESULT_TYPE(ReadHandler,

  777.     void (asio::error_code, std::size_t))

  778. async_read(AsyncReadStream& s,

  779.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  780.     CompletionCondition completion_condition,

  781.     ASIO_MOVE_ARG(ReadHandler) handler,

  782.     typename enable_if<

  783.       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value

  784.         && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value

  785.     >::type*)

  786. {

  787.   // If you get an error on the following line it means that your handler does

  788.   // not meet the documented type requirements for a ReadHandler.

  789.   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

  790. 

  791.   return async_initiate<ReadHandler,

  792.     void (asio::error_code, std::size_t)>(

  793.       detail::initiate_async_read_dynbuf_v1(), handler, &s,

  794.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  795.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));

  796. }

  797. 

  798. #if !defined(ASIO_NO_EXTENSIONS)

  799. #if !defined(ASIO_NO_IOSTREAM)

  800. 

  801. template <typename AsyncReadStream, typename Allocator, typename ReadHandler>

  802. inline ASIO_INITFN_RESULT_TYPE(ReadHandler,

  803.     void (asio::error_code, std::size_t))

  804. async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,

  805.     ASIO_MOVE_ARG(ReadHandler) handler)

  806. {

  807.   return async_read(s, basic_streambuf_ref<Allocator>(b),

  808.       ASIO_MOVE_CAST(ReadHandler)(handler));

  809. }

  810. 

  811. template <typename AsyncReadStream, typename Allocator,

  812.     typename CompletionCondition, typename ReadHandler>

  813. inline ASIO_INITFN_RESULT_TYPE(ReadHandler,

  814.     void (asio::error_code, std::size_t))

  815. async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,

  816.     CompletionCondition completion_condition,

  817.     ASIO_MOVE_ARG(ReadHandler) handler)

  818. {

  819.   return async_read(s, basic_streambuf_ref<Allocator>(b),

  820.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition),

  821.       ASIO_MOVE_CAST(ReadHandler)(handler));

  822. }

  823. 

  824. #endif // !defined(ASIO_NO_IOSTREAM)

  825. #endif // !defined(ASIO_NO_EXTENSIONS)

  826. #endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  827. 

  828. namespace detail

  829. {

  830.   template <typename AsyncReadStream, typename DynamicBuffer_v2,

  831.       typename CompletionCondition, typename ReadHandler>

  832.   class read_dynbuf_v2_op

  833.     : detail::base_from_completion_cond<CompletionCondition>

  834.   {

  835.   public:

  836.     template <typename BufferSequence>

  837.     read_dynbuf_v2_op(AsyncReadStream& stream,

  838.         ASIO_MOVE_ARG(BufferSequence) buffers,

  839.         CompletionCondition& completion_condition, ReadHandler& handler)

  840.       : detail::base_from_completion_cond<

  841.           CompletionCondition>(completion_condition),

  842.         stream_(stream),

  843.         buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)),

  844.         start_(0),

  845.         total_transferred_(0),

  846.         bytes_available_(0),

  847.         handler_(ASIO_MOVE_CAST(ReadHandler)(handler))

  848.     {

  849.     }

  850. 

  851. #if defined(ASIO_HAS_MOVE)

  852.     read_dynbuf_v2_op(const read_dynbuf_v2_op& other)

  853.       : detail::base_from_completion_cond<CompletionCondition>(other),

  854.         stream_(other.stream_),

  855.         buffers_(other.buffers_),

  856.         start_(other.start_),

  857.         total_transferred_(other.total_transferred_),

  858.         bytes_available_(other.bytes_available_),

  859.         handler_(other.handler_)

  860.     {

  861.     }

  862. 

  863.     read_dynbuf_v2_op(read_dynbuf_v2_op&& other)

  864.       : detail::base_from_completion_cond<CompletionCondition>(

  865.           ASIO_MOVE_CAST(detail::base_from_completion_cond<

  866.             CompletionCondition>)(other)),

  867.         stream_(other.stream_),

  868.         buffers_(ASIO_MOVE_CAST(DynamicBuffer_v2)(other.buffers_)),

  869.         start_(other.start_),

  870.         total_transferred_(other.total_transferred_),

  871.         bytes_available_(other.bytes_available_),

  872.         handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_))

  873.     {

  874.     }

  875. #endif // defined(ASIO_HAS_MOVE)

  876. 

  877.     void operator()(const asio::error_code& ec,

  878.         std::size_t bytes_transferred, int start = 0)

  879.     {

  880.       std::size_t max_size, pos;

  881.       switch (start_ = start)

  882.       {

  883.         case 1:

  884.         max_size = this->check_for_completion(ec, total_transferred_);

  885.         bytes_available_ = std::min<std::size_t>(

  886.               std::max<std::size_t>(512,

  887.                 buffers_.capacity() - buffers_.size()),

  888.               std::min<std::size_t>(max_size,

  889.                 buffers_.max_size() - buffers_.size()));

  890.         for (;;)

  891.         {

  892.           pos = buffers_.size();

  893.           buffers_.grow(bytes_available_);

  894.           stream_.async_read_some(buffers_.data(pos, bytes_available_),

  895.               ASIO_MOVE_CAST(read_dynbuf_v2_op)(*this));

  896.           return; default:

  897.           total_transferred_ += bytes_transferred;

  898.           buffers_.shrink(bytes_available_ - bytes_transferred);

  899.           max_size = this->check_for_completion(ec, total_transferred_);

  900.           bytes_available_ = std::min<std::size_t>(

  901.                 std::max<std::size_t>(512,

  902.                   buffers_.capacity() - buffers_.size()),

  903.                 std::min<std::size_t>(max_size,

  904.                   buffers_.max_size() - buffers_.size()));

  905.           if ((!ec && bytes_transferred == 0) || bytes_available_ == 0)

  906.             break;

  907.         }

  908. 

  909.         handler_(ec, static_cast<const std::size_t&>(total_transferred_));

  910.       }

  911.     }

  912. 

  913.   //private:

  914.     AsyncReadStream& stream_;

  915.     DynamicBuffer_v2 buffers_;

  916.     int start_;

  917.     std::size_t total_transferred_;

  918.     std::size_t bytes_available_;

  919.     ReadHandler handler_;

  920.   };

  921. 

  922.   template <typename AsyncReadStream, typename DynamicBuffer_v2,

  923.       typename CompletionCondition, typename ReadHandler>

  924.   inline void* asio_handler_allocate(std::size_t size,

  925.       read_dynbuf_v2_op<AsyncReadStream, DynamicBuffer_v2,

  926.         CompletionCondition, ReadHandler>* this_handler)

  927.   {

  928.     return asio_handler_alloc_helpers::allocate(

  929.         size, this_handler->handler_);

  930.   }

  931. 

  932.   template <typename AsyncReadStream, typename DynamicBuffer_v2,

  933.       typename CompletionCondition, typename ReadHandler>

  934.   inline void asio_handler_deallocate(void* pointer, std::size_t size,

  935.       read_dynbuf_v2_op<AsyncReadStream, DynamicBuffer_v2,

  936.         CompletionCondition, ReadHandler>* this_handler)

  937.   {

  938.     asio_handler_alloc_helpers::deallocate(

  939.         pointer, size, this_handler->handler_);

  940.   }

  941. 

  942.   template <typename AsyncReadStream, typename DynamicBuffer_v2,

  943.       typename CompletionCondition, typename ReadHandler>

  944.   inline bool asio_handler_is_continuation(

  945.       read_dynbuf_v2_op<AsyncReadStream, DynamicBuffer_v2,

  946.         CompletionCondition, ReadHandler>* this_handler)

  947.   {

  948.     return this_handler->start_ == 0 ? true

  949.       : asio_handler_cont_helpers::is_continuation(

  950.           this_handler->handler_);

  951.   }

  952. 

  953.   template <typename Function, typename AsyncReadStream,

  954.       typename DynamicBuffer_v2, typename CompletionCondition,

  955.       typename ReadHandler>

  956.   inline void asio_handler_invoke(Function& function,

  957.       read_dynbuf_v2_op<AsyncReadStream, DynamicBuffer_v2,

  958.         CompletionCondition, ReadHandler>* this_handler)

  959.   {

  960.     asio_handler_invoke_helpers::invoke(

  961.         function, this_handler->handler_);

  962.   }

  963. 

  964.   template <typename Function, typename AsyncReadStream,

  965.       typename DynamicBuffer_v2, typename CompletionCondition,

  966.       typename ReadHandler>

  967.   inline void asio_handler_invoke(const Function& function,

  968.       read_dynbuf_v2_op<AsyncReadStream, DynamicBuffer_v2,

  969.         CompletionCondition, ReadHandler>* this_handler)

  970.   {

  971.     asio_handler_invoke_helpers::invoke(

  972.         function, this_handler->handler_);

  973.   }

  974. 

  975.   struct initiate_async_read_dynbuf_v2

  976.   {

  977.     template <typename ReadHandler, typename AsyncReadStream,

  978.         typename DynamicBuffer_v2, typename CompletionCondition>

  979.     void operator()(ASIO_MOVE_ARG(ReadHandler) handler,

  980.         AsyncReadStream* s, ASIO_MOVE_ARG(DynamicBuffer_v2) buffers,

  981.         ASIO_MOVE_ARG(CompletionCondition) completion_cond) const

  982.     {

  983.       // If you get an error on the following line it means that your handler

  984.       // does not meet the documented type requirements for a ReadHandler.

  985.       ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

  986. 

  987.       non_const_lvalue<ReadHandler> handler2(handler);

  988.       non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);

  989.       read_dynbuf_v2_op<AsyncReadStream, typename decay<DynamicBuffer_v2>::type,

  990.         CompletionCondition, typename decay<ReadHandler>::type>(

  991.           *s, ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  992.             completion_cond2.value, handler2.value)(

  993.               asio::error_code(), 0, 1);

  994.     }

  995.   };

  996. } // namespace detail

  997. 

  998. #if !defined(GENERATING_DOCUMENTATION)

  999. 

  1000. template <typename AsyncReadStream, typename DynamicBuffer_v2,

  1001.     typename CompletionCondition, typename ReadHandler, typename Allocator>

  1002. struct associated_allocator<

  1003.     detail::read_dynbuf_v2_op<AsyncReadStream,

  1004.       DynamicBuffer_v2, CompletionCondition, ReadHandler>,

  1005.     Allocator>

  1006. {

  1007.   typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  1008. 

  1009.   static type get(

  1010.       const detail::read_dynbuf_v2_op<AsyncReadStream,

  1011.         DynamicBuffer_v2, CompletionCondition, ReadHandler>& h,

  1012.       const Allocator& a = Allocator()) ASIO_NOEXCEPT

  1013.   {

  1014.     return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);

  1015.   }

  1016. };

  1017. 

  1018. template <typename AsyncReadStream, typename DynamicBuffer_v2,

  1019.     typename CompletionCondition, typename ReadHandler, typename Executor>

  1020. struct associated_executor<

  1021.     detail::read_dynbuf_v2_op<AsyncReadStream,

  1022.       DynamicBuffer_v2, CompletionCondition, ReadHandler>,

  1023.     Executor>

  1024. {

  1025.   typedef typename associated_executor<ReadHandler, Executor>::type type;

  1026. 

  1027.   static type get(

  1028.       const detail::read_dynbuf_v2_op<AsyncReadStream,

  1029.         DynamicBuffer_v2, CompletionCondition, ReadHandler>& h,

  1030.       const Executor& ex = Executor()) ASIO_NOEXCEPT

  1031.   {

  1032.     return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);

  1033.   }

  1034. };

  1035. 

  1036. #endif // !defined(GENERATING_DOCUMENTATION)

  1037. 

  1038. template <typename AsyncReadStream,

  1039.     typename DynamicBuffer_v2, typename ReadHandler>

  1040. inline ASIO_INITFN_RESULT_TYPE(ReadHandler,

  1041.     void (asio::error_code, std::size_t))

  1042. async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,

  1043.     ASIO_MOVE_ARG(ReadHandler) handler,

  1044.     typename enable_if<

  1045.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  1046.     >::type*)

  1047. {

  1048.   return async_read(s,

  1049.       ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  1050.       transfer_all(), ASIO_MOVE_CAST(ReadHandler)(handler));

  1051. }

  1052. 

  1053. template <typename AsyncReadStream, typename DynamicBuffer_v2,

  1054.     typename CompletionCondition, typename ReadHandler>

  1055. inline ASIO_INITFN_RESULT_TYPE(ReadHandler,

  1056.     void (asio::error_code, std::size_t))

  1057. async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,

  1058.     CompletionCondition completion_condition,

  1059.     ASIO_MOVE_ARG(ReadHandler) handler,

  1060.     typename enable_if<

  1061.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  1062.     >::type*)

  1063. {

  1064.   // If you get an error on the following line it means that your handler does

  1065.   // not meet the documented type requirements for a ReadHandler.

  1066.   ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

  1067. 

  1068.   return async_initiate<ReadHandler,

  1069.     void (asio::error_code, std::size_t)>(

  1070.       detail::initiate_async_read_dynbuf_v2(), handler, &s,

  1071.       ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  1072.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));

  1073. }

  1074. 

  1075. } // namespace asio

  1076. 

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

  1078. 

  1079. #endif // ASIO_IMPL_READ_HPP