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

979 lines
34KB
Raw Blame History 

  1. //

  2. // impl/write.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_WRITE_HPP

  12. #define ASIO_IMPL_WRITE_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/associated_allocator.hpp"

  19. #include "asio/associated_executor.hpp"

  20. #include "asio/buffer.hpp"

  21. #include "asio/completion_condition.hpp"

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

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

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

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

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

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

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

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

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

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

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

  33. 

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

  35. 

  36. namespace asio {

  37. 

  38. namespace detail

  39. {

  40.   template <typename SyncWriteStream, typename ConstBufferSequence,

  41.       typename ConstBufferIterator, typename CompletionCondition>

  42.   std::size_t write_buffer_sequence(SyncWriteStream& s,

  43.       const ConstBufferSequence& buffers, const ConstBufferIterator&,

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

  45.   {

  46.     ec = asio::error_code();

  47.     asio::detail::consuming_buffers<const_buffer,

  48.         ConstBufferSequence, ConstBufferIterator> tmp(buffers);

  49.     while (!tmp.empty())

  50.     {

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

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

  53.         tmp.consume(s.write_some(tmp.prepare(max_size), ec));

  54.       else

  55.         break;

  56.     }

  57.     return tmp.total_consumed();;

  58.   }

  59. } // namespace detail

  60. 

  61. template <typename SyncWriteStream, typename ConstBufferSequence,

  62.     typename CompletionCondition>

  63. inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,

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

  65.     typename enable_if<

  66.       is_const_buffer_sequence<ConstBufferSequence>::value

  67.     >::type*)

  68. {

  69.   return detail::write_buffer_sequence(s, buffers,

  70.       asio::buffer_sequence_begin(buffers),

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

  72. }

  73. 

  74. template <typename SyncWriteStream, typename ConstBufferSequence>

  75. inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,

  76.     typename enable_if<

  77.       is_const_buffer_sequence<ConstBufferSequence>::value

  78.     >::type*)

  79. {

  80.   asio::error_code ec;

  81.   std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);

  82.   asio::detail::throw_error(ec, "write");

  83.   return bytes_transferred;

  84. }

  85. 

  86. template <typename SyncWriteStream, typename ConstBufferSequence>

  87. inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,

  88.     asio::error_code& ec,

  89.     typename enable_if<

  90.       is_const_buffer_sequence<ConstBufferSequence>::value

  91.     >::type*)

  92. {

  93.   return write(s, buffers, transfer_all(), ec);

  94. }

  95. 

  96. template <typename SyncWriteStream, typename ConstBufferSequence,

  97.     typename CompletionCondition>

  98. inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,

  99.     CompletionCondition completion_condition,

  100.     typename enable_if<

  101.       is_const_buffer_sequence<ConstBufferSequence>::value

  102.     >::type*)

  103. {

  104.   asio::error_code ec;

  105.   std::size_t bytes_transferred = write(s, buffers,

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

  107.   asio::detail::throw_error(ec, "write");

  108.   return bytes_transferred;

  109. }

  110. 

  111. #if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  112. 

  113. template <typename SyncWriteStream, typename DynamicBuffer_v1,

  114.     typename CompletionCondition>

  115. std::size_t write(SyncWriteStream& s,

  116.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

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

  118.     typename enable_if<

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

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

  121.     >::type*)

  122. {

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

  124.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers));

  125. 

  126.   std::size_t bytes_transferred = write(s, b.data(),

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

  128.   b.consume(bytes_transferred);

  129.   return bytes_transferred;

  130. }

  131. 

  132. template <typename SyncWriteStream, typename DynamicBuffer_v1>

  133. inline std::size_t write(SyncWriteStream& s,

  134.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  135.     typename enable_if<

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

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

  138.     >::type*)

  139. {

  140.   asio::error_code ec;

  141.   std::size_t bytes_transferred = write(s,

  142.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  143.       transfer_all(), ec);

  144.   asio::detail::throw_error(ec, "write");

  145.   return bytes_transferred;

  146. }

  147. 

  148. template <typename SyncWriteStream, typename DynamicBuffer_v1>

  149. inline std::size_t write(SyncWriteStream& s,

  150.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  151.     asio::error_code& ec,

  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.   return write(s, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  158.       transfer_all(), ec);

  159. }

  160. 

  161. template <typename SyncWriteStream, typename DynamicBuffer_v1,

  162.     typename CompletionCondition>

  163. inline std::size_t write(SyncWriteStream& s,

  164.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  165.     CompletionCondition completion_condition,

  166.     typename enable_if<

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

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

  169.     >::type*)

  170. {

  171.   asio::error_code ec;

  172.   std::size_t bytes_transferred = write(s,

  173.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

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

  175.   asio::detail::throw_error(ec, "write");

  176.   return bytes_transferred;

  177. }

  178. 

  179. #if !defined(ASIO_NO_EXTENSIONS)

  180. #if !defined(ASIO_NO_IOSTREAM)

  181. 

  182. template <typename SyncWriteStream, typename Allocator,

  183.     typename CompletionCondition>

  184. inline std::size_t write(SyncWriteStream& s,

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

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

  187. {

  188.   return write(s, basic_streambuf_ref<Allocator>(b),

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

  190. }

  191. 

  192. template <typename SyncWriteStream, typename Allocator>

  193. inline std::size_t write(SyncWriteStream& s,

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

  195. {

  196.   return write(s, basic_streambuf_ref<Allocator>(b));

  197. }

  198. 

  199. template <typename SyncWriteStream, typename Allocator>

  200. inline std::size_t write(SyncWriteStream& s,

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

  202.     asio::error_code& ec)

  203. {

  204.   return write(s, basic_streambuf_ref<Allocator>(b), ec);

  205. }

  206. 

  207. template <typename SyncWriteStream, typename Allocator,

  208.     typename CompletionCondition>

  209. inline std::size_t write(SyncWriteStream& s,

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

  211.     CompletionCondition completion_condition)

  212. {

  213.   return write(s, basic_streambuf_ref<Allocator>(b),

  214.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));

  215. }

  216. 

  217. #endif // !defined(ASIO_NO_IOSTREAM)

  218. #endif // !defined(ASIO_NO_EXTENSIONS)

  219. #endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  220. 

  221. template <typename SyncWriteStream, typename DynamicBuffer_v2,

  222.     typename CompletionCondition>

  223. std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,

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

  225.     typename enable_if<

  226.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  227.     >::type*)

  228. {

  229.   std::size_t bytes_transferred = write(s, buffers.data(0, buffers.size()),

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

  231.   buffers.consume(bytes_transferred);

  232.   return bytes_transferred;

  233. }

  234. 

  235. template <typename SyncWriteStream, typename DynamicBuffer_v2>

  236. inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,

  237.     typename enable_if<

  238.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  239.     >::type*)

  240. {

  241.   asio::error_code ec;

  242.   std::size_t bytes_transferred = write(s,

  243.       ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  244.       transfer_all(), ec);

  245.   asio::detail::throw_error(ec, "write");

  246.   return bytes_transferred;

  247. }

  248. 

  249. template <typename SyncWriteStream, typename DynamicBuffer_v2>

  250. inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,

  251.     asio::error_code& ec,

  252.     typename enable_if<

  253.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  254.     >::type*)

  255. {

  256.   return write(s, ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  257.       transfer_all(), ec);

  258. }

  259. 

  260. template <typename SyncWriteStream, typename DynamicBuffer_v2,

  261.     typename CompletionCondition>

  262. inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,

  263.     CompletionCondition completion_condition,

  264.     typename enable_if<

  265.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  266.     >::type*)

  267. {

  268.   asio::error_code ec;

  269.   std::size_t bytes_transferred = write(s,

  270.       ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

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

  272.   asio::detail::throw_error(ec, "write");

  273.   return bytes_transferred;

  274. }

  275. 

  276. namespace detail

  277. {

  278.   template <typename AsyncWriteStream, typename ConstBufferSequence,

  279.       typename ConstBufferIterator, typename CompletionCondition,

  280.       typename WriteHandler>

  281.   class write_op

  282.     : detail::base_from_completion_cond<CompletionCondition>

  283.   {

  284.   public:

  285.     write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,

  286.         CompletionCondition& completion_condition, WriteHandler& handler)

  287.       : detail::base_from_completion_cond<

  288.           CompletionCondition>(completion_condition),

  289.         stream_(stream),

  290.         buffers_(buffers),

  291.         start_(0),

  292.         handler_(ASIO_MOVE_CAST(WriteHandler)(handler))

  293.     {

  294.     }

  295. 

  296. #if defined(ASIO_HAS_MOVE)

  297.     write_op(const write_op& other)

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

  299.         stream_(other.stream_),

  300.         buffers_(other.buffers_),

  301.         start_(other.start_),

  302.         handler_(other.handler_)

  303.     {

  304.     }

  305. 

  306.     write_op(write_op&& other)

  307.       : detail::base_from_completion_cond<CompletionCondition>(

  308.           ASIO_MOVE_CAST(detail::base_from_completion_cond<

  309.             CompletionCondition>)(other)),

  310.         stream_(other.stream_),

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

  312.         start_(other.start_),

  313.         handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))

  314.     {

  315.     }

  316. #endif // defined(ASIO_HAS_MOVE)

  317. 

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

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

  320.     {

  321.       std::size_t max_size;

  322.       switch (start_ = start)

  323.       {

  324.         case 1:

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

  326.         do

  327.         {

  328.           stream_.async_write_some(buffers_.prepare(max_size),

  329.               ASIO_MOVE_CAST(write_op)(*this));

  330.           return; default:

  331.           buffers_.consume(bytes_transferred);

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

  333.             break;

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

  335.         } while (max_size > 0);

  336. 

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

  338.       }

  339.     }

  340. 

  341.   //private:

  342.     typedef asio::detail::consuming_buffers<const_buffer,

  343.         ConstBufferSequence, ConstBufferIterator> buffers_type;

  344. 

  345.     AsyncWriteStream& stream_;

  346.     buffers_type buffers_;

  347.     int start_;

  348.     WriteHandler handler_;

  349.   };

  350. 

  351.   template <typename AsyncWriteStream, typename ConstBufferSequence,

  352.       typename ConstBufferIterator, typename CompletionCondition,

  353.       typename WriteHandler>

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

  355.       write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,

  356.         CompletionCondition, WriteHandler>* this_handler)

  357.   {

  358.     return asio_handler_alloc_helpers::allocate(

  359.         size, this_handler->handler_);

  360.   }

  361. 

  362.   template <typename AsyncWriteStream, typename ConstBufferSequence,

  363.       typename ConstBufferIterator, typename CompletionCondition,

  364.       typename WriteHandler>

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

  366.       write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,

  367.         CompletionCondition, WriteHandler>* this_handler)

  368.   {

  369.     asio_handler_alloc_helpers::deallocate(

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

  371.   }

  372. 

  373.   template <typename AsyncWriteStream, typename ConstBufferSequence,

  374.       typename ConstBufferIterator, typename CompletionCondition,

  375.       typename WriteHandler>

  376.   inline bool asio_handler_is_continuation(

  377.       write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,

  378.         CompletionCondition, WriteHandler>* this_handler)

  379.   {

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

  381.       : asio_handler_cont_helpers::is_continuation(

  382.           this_handler->handler_);

  383.   }

  384. 

  385.   template <typename Function, typename AsyncWriteStream,

  386.       typename ConstBufferSequence, typename ConstBufferIterator,

  387.       typename CompletionCondition, typename WriteHandler>

  388.   inline void asio_handler_invoke(Function& function,

  389.       write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,

  390.         CompletionCondition, WriteHandler>* this_handler)

  391.   {

  392.     asio_handler_invoke_helpers::invoke(

  393.         function, this_handler->handler_);

  394.   }

  395. 

  396.   template <typename Function, typename AsyncWriteStream,

  397.       typename ConstBufferSequence, typename ConstBufferIterator,

  398.       typename CompletionCondition, typename WriteHandler>

  399.   inline void asio_handler_invoke(const Function& function,

  400.       write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,

  401.         CompletionCondition, WriteHandler>* this_handler)

  402.   {

  403.     asio_handler_invoke_helpers::invoke(

  404.         function, this_handler->handler_);

  405.   }

  406. 

  407.   template <typename AsyncWriteStream, typename ConstBufferSequence,

  408.       typename ConstBufferIterator, typename CompletionCondition,

  409.       typename WriteHandler>

  410.   inline void start_write_buffer_sequence_op(AsyncWriteStream& stream,

  411.       const ConstBufferSequence& buffers, const ConstBufferIterator&,

  412.       CompletionCondition& completion_condition, WriteHandler& handler)

  413.   {

  414.     detail::write_op<AsyncWriteStream, ConstBufferSequence,

  415.       ConstBufferIterator, CompletionCondition, WriteHandler>(

  416.         stream, buffers, completion_condition, handler)(

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

  418.   }

  419. 

  420.   struct initiate_async_write_buffer_sequence

  421.   {

  422.     template <typename WriteHandler, typename AsyncWriteStream,

  423.         typename ConstBufferSequence, typename CompletionCondition>

  424.     void operator()(ASIO_MOVE_ARG(WriteHandler) handler,

  425.         AsyncWriteStream* s, const ConstBufferSequence& buffers,

  426.         ASIO_MOVE_ARG(CompletionCondition) completion_cond) const

  427.     {

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

  429.       // does not meet the documented type requirements for a WriteHandler.

  430.       ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;

  431. 

  432.       non_const_lvalue<WriteHandler> handler2(handler);

  433.       non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);

  434.       start_write_buffer_sequence_op(*s, buffers,

  435.           asio::buffer_sequence_begin(buffers),

  436.           completion_cond2.value, handler2.value);

  437.     }

  438.   };

  439. } // namespace detail

  440. 

  441. #if !defined(GENERATING_DOCUMENTATION)

  442. 

  443. template <typename AsyncWriteStream, typename ConstBufferSequence,

  444.     typename ConstBufferIterator, typename CompletionCondition,

  445.     typename WriteHandler, typename Allocator>

  446. struct associated_allocator<

  447.     detail::write_op<AsyncWriteStream, ConstBufferSequence,

  448.       ConstBufferIterator, CompletionCondition, WriteHandler>,

  449.     Allocator>

  450. {

  451.   typedef typename associated_allocator<WriteHandler, Allocator>::type type;

  452. 

  453.   static type get(

  454.       const detail::write_op<AsyncWriteStream, ConstBufferSequence,

  455.         ConstBufferIterator, CompletionCondition, WriteHandler>& h,

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

  457.   {

  458.     return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);

  459.   }

  460. };

  461. 

  462. template <typename AsyncWriteStream, typename ConstBufferSequence,

  463.     typename ConstBufferIterator, typename CompletionCondition,

  464.     typename WriteHandler, typename Executor>

  465. struct associated_executor<

  466.     detail::write_op<AsyncWriteStream, ConstBufferSequence,

  467.       ConstBufferIterator, CompletionCondition, WriteHandler>,

  468.     Executor>

  469. {

  470.   typedef typename associated_executor<WriteHandler, Executor>::type type;

  471. 

  472.   static type get(

  473.       const detail::write_op<AsyncWriteStream, ConstBufferSequence,

  474.         ConstBufferIterator, CompletionCondition, WriteHandler>& h,

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

  476.   {

  477.     return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);

  478.   }

  479. };

  480. 

  481. #endif // !defined(GENERATING_DOCUMENTATION)

  482. 

  483. template <typename AsyncWriteStream, typename ConstBufferSequence,

  484.   typename CompletionCondition, typename WriteHandler>

  485. inline ASIO_INITFN_RESULT_TYPE(WriteHandler,

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

  487. async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,

  488.     CompletionCondition completion_condition,

  489.     ASIO_MOVE_ARG(WriteHandler) handler,

  490.     typename enable_if<

  491.       is_const_buffer_sequence<ConstBufferSequence>::value

  492.     >::type*)

  493. {

  494.   return async_initiate<WriteHandler,

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

  496.       detail::initiate_async_write_buffer_sequence(), handler, &s, buffers,

  497.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));

  498. }

  499. 

  500. template <typename AsyncWriteStream, typename ConstBufferSequence,

  501.     typename WriteHandler>

  502. inline ASIO_INITFN_RESULT_TYPE(WriteHandler,

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

  504. async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,

  505.     ASIO_MOVE_ARG(WriteHandler) handler,

  506.     typename enable_if<

  507.       is_const_buffer_sequence<ConstBufferSequence>::value

  508.     >::type*)

  509. {

  510.   return async_initiate<WriteHandler,

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

  512.       detail::initiate_async_write_buffer_sequence(),

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

  514. }

  515. 

  516. #if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  517. 

  518. namespace detail

  519. {

  520.   template <typename AsyncWriteStream, typename DynamicBuffer_v1,

  521.       typename CompletionCondition, typename WriteHandler>

  522.   class write_dynbuf_v1_op

  523.   {

  524.   public:

  525.     template <typename BufferSequence>

  526.     write_dynbuf_v1_op(AsyncWriteStream& stream,

  527.         ASIO_MOVE_ARG(BufferSequence) buffers,

  528.         CompletionCondition& completion_condition, WriteHandler& handler)

  529.       : stream_(stream),

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

  531.         completion_condition_(

  532.           ASIO_MOVE_CAST(CompletionCondition)(completion_condition)),

  533.         handler_(ASIO_MOVE_CAST(WriteHandler)(handler))

  534.     {

  535.     }

  536. 

  537. #if defined(ASIO_HAS_MOVE)

  538.     write_dynbuf_v1_op(const write_dynbuf_v1_op& other)

  539.       : stream_(other.stream_),

  540.         buffers_(other.buffers_),

  541.         completion_condition_(other.completion_condition_),

  542.         handler_(other.handler_)

  543.     {

  544.     }

  545. 

  546.     write_dynbuf_v1_op(write_dynbuf_v1_op&& other)

  547.       : stream_(other.stream_),

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

  549.         completion_condition_(

  550.           ASIO_MOVE_CAST(CompletionCondition)(

  551.             other.completion_condition_)),

  552.         handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))

  553.     {

  554.     }

  555. #endif // defined(ASIO_HAS_MOVE)

  556. 

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

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

  559.     {

  560.       switch (start)

  561.       {

  562.         case 1:

  563.         async_write(stream_, buffers_.data(),

  564.             ASIO_MOVE_CAST(CompletionCondition)(completion_condition_),

  565.             ASIO_MOVE_CAST(write_dynbuf_v1_op)(*this));

  566.         return; default:

  567.         buffers_.consume(bytes_transferred);

  568.         handler_(ec, static_cast<const std::size_t&>(bytes_transferred));

  569.       }

  570.     }

  571. 

  572.   //private:

  573.     AsyncWriteStream& stream_;

  574.     DynamicBuffer_v1 buffers_;

  575.     CompletionCondition completion_condition_;

  576.     WriteHandler handler_;

  577.   };

  578. 

  579.   template <typename AsyncWriteStream, typename DynamicBuffer_v1,

  580.       typename CompletionCondition, typename WriteHandler>

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

  582.       write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1,

  583.         CompletionCondition, WriteHandler>* this_handler)

  584.   {

  585.     return asio_handler_alloc_helpers::allocate(

  586.         size, this_handler->handler_);

  587.   }

  588. 

  589.   template <typename AsyncWriteStream, typename DynamicBuffer_v1,

  590.       typename CompletionCondition, typename WriteHandler>

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

  592.       write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1,

  593.         CompletionCondition, WriteHandler>* this_handler)

  594.   {

  595.     asio_handler_alloc_helpers::deallocate(

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

  597.   }

  598. 

  599.   template <typename AsyncWriteStream, typename DynamicBuffer_v1,

  600.       typename CompletionCondition, typename WriteHandler>

  601.   inline bool asio_handler_is_continuation(

  602.       write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1,

  603.         CompletionCondition, WriteHandler>* this_handler)

  604.   {

  605.     return asio_handler_cont_helpers::is_continuation(

  606.         this_handler->handler_);

  607.   }

  608. 

  609.   template <typename Function, typename AsyncWriteStream,

  610.       typename DynamicBuffer_v1, typename CompletionCondition,

  611.       typename WriteHandler>

  612.   inline void asio_handler_invoke(Function& function,

  613.       write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1,

  614.         CompletionCondition, WriteHandler>* this_handler)

  615.   {

  616.     asio_handler_invoke_helpers::invoke(

  617.         function, this_handler->handler_);

  618.   }

  619. 

  620.   template <typename Function, typename AsyncWriteStream,

  621.       typename DynamicBuffer_v1, typename CompletionCondition,

  622.       typename WriteHandler>

  623.   inline void asio_handler_invoke(const Function& function,

  624.       write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1,

  625.         CompletionCondition, WriteHandler>* this_handler)

  626.   {

  627.     asio_handler_invoke_helpers::invoke(

  628.         function, this_handler->handler_);

  629.   }

  630. 

  631.   struct initiate_async_write_dynbuf_v1

  632.   {

  633.     template <typename WriteHandler, typename AsyncWriteStream,

  634.         typename DynamicBuffer_v1, typename CompletionCondition>

  635.     void operator()(ASIO_MOVE_ARG(WriteHandler) handler,

  636.         AsyncWriteStream* s, ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  637.         ASIO_MOVE_ARG(CompletionCondition) completion_cond) const

  638.     {

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

  640.       // does not meet the documented type requirements for a WriteHandler.

  641.       ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;

  642. 

  643.       non_const_lvalue<WriteHandler> handler2(handler);

  644.       non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);

  645.       write_dynbuf_v1_op<AsyncWriteStream,

  646.         typename decay<DynamicBuffer_v1>::type,

  647.           CompletionCondition, typename decay<WriteHandler>::type>(

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

  649.               completion_cond2.value, handler2.value)(

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

  651.     }

  652.   };

  653. } // namespace detail

  654. 

  655. #if !defined(GENERATING_DOCUMENTATION)

  656. 

  657. template <typename AsyncWriteStream, typename DynamicBuffer_v1,

  658.     typename CompletionCondition, typename WriteHandler, typename Allocator>

  659. struct associated_allocator<

  660.     detail::write_dynbuf_v1_op<AsyncWriteStream,

  661.       DynamicBuffer_v1, CompletionCondition, WriteHandler>,

  662.     Allocator>

  663. {

  664.   typedef typename associated_allocator<WriteHandler, Allocator>::type type;

  665. 

  666.   static type get(

  667.       const detail::write_dynbuf_v1_op<AsyncWriteStream,

  668.         DynamicBuffer_v1, CompletionCondition, WriteHandler>& h,

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

  670.   {

  671.     return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);

  672.   }

  673. };

  674. 

  675. template <typename AsyncWriteStream, typename DynamicBuffer_v1,

  676.     typename CompletionCondition, typename WriteHandler, typename Executor>

  677. struct associated_executor<

  678.     detail::write_dynbuf_v1_op<AsyncWriteStream,

  679.       DynamicBuffer_v1, CompletionCondition, WriteHandler>,

  680.     Executor>

  681. {

  682.   typedef typename associated_executor<WriteHandler, Executor>::type type;

  683. 

  684.   static type get(

  685.       const detail::write_dynbuf_v1_op<AsyncWriteStream,

  686.         DynamicBuffer_v1, CompletionCondition, WriteHandler>& h,

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

  688.   {

  689.     return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);

  690.   }

  691. };

  692. 

  693. #endif // !defined(GENERATING_DOCUMENTATION)

  694. 

  695. template <typename AsyncWriteStream,

  696.     typename DynamicBuffer_v1, typename WriteHandler>

  697. inline ASIO_INITFN_RESULT_TYPE(WriteHandler,

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

  699. async_write(AsyncWriteStream& s,

  700.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  701.     ASIO_MOVE_ARG(WriteHandler) handler,

  702.     typename enable_if<

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

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

  705.     >::type*)

  706. {

  707.   return async_write(s,

  708.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  709.       transfer_all(), ASIO_MOVE_CAST(WriteHandler)(handler));

  710. }

  711. 

  712. template <typename AsyncWriteStream, typename DynamicBuffer_v1,

  713.     typename CompletionCondition, typename WriteHandler>

  714. inline ASIO_INITFN_RESULT_TYPE(WriteHandler,

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

  716. async_write(AsyncWriteStream& s,

  717.     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,

  718.     CompletionCondition completion_condition,

  719.     ASIO_MOVE_ARG(WriteHandler) handler,

  720.     typename enable_if<

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

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

  723.     >::type*)

  724. {

  725.   return async_initiate<WriteHandler,

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

  727.       detail::initiate_async_write_dynbuf_v1(), handler, &s,

  728.       ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),

  729.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));

  730. }

  731. 

  732. #if !defined(ASIO_NO_EXTENSIONS)

  733. #if !defined(ASIO_NO_IOSTREAM)

  734. 

  735. template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>

  736. inline ASIO_INITFN_RESULT_TYPE(WriteHandler,

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

  738. async_write(AsyncWriteStream& s,

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

  740.     ASIO_MOVE_ARG(WriteHandler) handler)

  741. {

  742.   return async_write(s, basic_streambuf_ref<Allocator>(b),

  743.       ASIO_MOVE_CAST(WriteHandler)(handler));

  744. }

  745. 

  746. template <typename AsyncWriteStream, typename Allocator,

  747.     typename CompletionCondition, typename WriteHandler>

  748. inline ASIO_INITFN_RESULT_TYPE(WriteHandler,

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

  750. async_write(AsyncWriteStream& s,

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

  752.     CompletionCondition completion_condition,

  753.     ASIO_MOVE_ARG(WriteHandler) handler)

  754. {

  755.   return async_write(s, basic_streambuf_ref<Allocator>(b),

  756.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition),

  757.       ASIO_MOVE_CAST(WriteHandler)(handler));

  758. }

  759. 

  760. #endif // !defined(ASIO_NO_IOSTREAM)

  761. #endif // !defined(ASIO_NO_EXTENSIONS)

  762. #endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  763. 

  764. namespace detail

  765. {

  766.   template <typename AsyncWriteStream, typename DynamicBuffer_v2,

  767.       typename CompletionCondition, typename WriteHandler>

  768.   class write_dynbuf_v2_op

  769.   {

  770.   public:

  771.     template <typename BufferSequence>

  772.     write_dynbuf_v2_op(AsyncWriteStream& stream,

  773.         ASIO_MOVE_ARG(BufferSequence) buffers,

  774.         CompletionCondition& completion_condition, WriteHandler& handler)

  775.       : stream_(stream),

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

  777.         completion_condition_(

  778.           ASIO_MOVE_CAST(CompletionCondition)(completion_condition)),

  779.         handler_(ASIO_MOVE_CAST(WriteHandler)(handler))

  780.     {

  781.     }

  782. 

  783. #if defined(ASIO_HAS_MOVE)

  784.     write_dynbuf_v2_op(const write_dynbuf_v2_op& other)

  785.       : stream_(other.stream_),

  786.         buffers_(other.buffers_),

  787.         completion_condition_(other.completion_condition_),

  788.         handler_(other.handler_)

  789.     {

  790.     }

  791. 

  792.     write_dynbuf_v2_op(write_dynbuf_v2_op&& other)

  793.       : stream_(other.stream_),

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

  795.         completion_condition_(

  796.           ASIO_MOVE_CAST(CompletionCondition)(

  797.             other.completion_condition_)),

  798.         handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_))

  799.     {

  800.     }

  801. #endif // defined(ASIO_HAS_MOVE)

  802. 

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

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

  805.     {

  806.       switch (start)

  807.       {

  808.         case 1:

  809.         async_write(stream_, buffers_.data(0, buffers_.size()),

  810.             ASIO_MOVE_CAST(CompletionCondition)(completion_condition_),

  811.             ASIO_MOVE_CAST(write_dynbuf_v2_op)(*this));

  812.         return; default:

  813.         buffers_.consume(bytes_transferred);

  814.         handler_(ec, static_cast<const std::size_t&>(bytes_transferred));

  815.       }

  816.     }

  817. 

  818.   //private:

  819.     AsyncWriteStream& stream_;

  820.     DynamicBuffer_v2 buffers_;

  821.     CompletionCondition completion_condition_;

  822.     WriteHandler handler_;

  823.   };

  824. 

  825.   template <typename AsyncWriteStream, typename DynamicBuffer_v2,

  826.       typename CompletionCondition, typename WriteHandler>

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

  828.       write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2,

  829.         CompletionCondition, WriteHandler>* this_handler)

  830.   {

  831.     return asio_handler_alloc_helpers::allocate(

  832.         size, this_handler->handler_);

  833.   }

  834. 

  835.   template <typename AsyncWriteStream, typename DynamicBuffer_v2,

  836.       typename CompletionCondition, typename WriteHandler>

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

  838.       write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2,

  839.         CompletionCondition, WriteHandler>* this_handler)

  840.   {

  841.     asio_handler_alloc_helpers::deallocate(

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

  843.   }

  844. 

  845.   template <typename AsyncWriteStream, typename DynamicBuffer_v2,

  846.       typename CompletionCondition, typename WriteHandler>

  847.   inline bool asio_handler_is_continuation(

  848.       write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2,

  849.         CompletionCondition, WriteHandler>* this_handler)

  850.   {

  851.     return asio_handler_cont_helpers::is_continuation(

  852.         this_handler->handler_);

  853.   }

  854. 

  855.   template <typename Function, typename AsyncWriteStream,

  856.       typename DynamicBuffer_v2, typename CompletionCondition,

  857.       typename WriteHandler>

  858.   inline void asio_handler_invoke(Function& function,

  859.       write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2,

  860.         CompletionCondition, WriteHandler>* this_handler)

  861.   {

  862.     asio_handler_invoke_helpers::invoke(

  863.         function, this_handler->handler_);

  864.   }

  865. 

  866.   template <typename Function, typename AsyncWriteStream,

  867.       typename DynamicBuffer_v2, typename CompletionCondition,

  868.       typename WriteHandler>

  869.   inline void asio_handler_invoke(const Function& function,

  870.       write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2,

  871.         CompletionCondition, WriteHandler>* this_handler)

  872.   {

  873.     asio_handler_invoke_helpers::invoke(

  874.         function, this_handler->handler_);

  875.   }

  876. 

  877.   struct initiate_async_write_dynbuf_v2

  878.   {

  879.     template <typename WriteHandler, typename AsyncWriteStream,

  880.         typename DynamicBuffer_v2, typename CompletionCondition>

  881.     void operator()(ASIO_MOVE_ARG(WriteHandler) handler,

  882.         AsyncWriteStream* s, ASIO_MOVE_ARG(DynamicBuffer_v2) buffers,

  883.         ASIO_MOVE_ARG(CompletionCondition) completion_cond) const

  884.     {

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

  886.       // does not meet the documented type requirements for a WriteHandler.

  887.       ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;

  888. 

  889.       non_const_lvalue<WriteHandler> handler2(handler);

  890.       non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);

  891.       write_dynbuf_v2_op<AsyncWriteStream,

  892.         typename decay<DynamicBuffer_v2>::type,

  893.           CompletionCondition, typename decay<WriteHandler>::type>(

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

  895.               completion_cond2.value, handler2.value)(

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

  897.     }

  898.   };

  899. } // namespace detail

  900. 

  901. #if !defined(GENERATING_DOCUMENTATION)

  902. 

  903. template <typename AsyncWriteStream, typename DynamicBuffer_v2,

  904.     typename CompletionCondition, typename WriteHandler, typename Allocator>

  905. struct associated_allocator<

  906.     detail::write_dynbuf_v2_op<AsyncWriteStream,

  907.       DynamicBuffer_v2, CompletionCondition, WriteHandler>,

  908.     Allocator>

  909. {

  910.   typedef typename associated_allocator<WriteHandler, Allocator>::type type;

  911. 

  912.   static type get(

  913.       const detail::write_dynbuf_v2_op<AsyncWriteStream,

  914.         DynamicBuffer_v2, CompletionCondition, WriteHandler>& h,

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

  916.   {

  917.     return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);

  918.   }

  919. };

  920. 

  921. template <typename AsyncWriteStream, typename DynamicBuffer_v2,

  922.     typename CompletionCondition, typename WriteHandler, typename Executor>

  923. struct associated_executor<

  924.     detail::write_dynbuf_v2_op<AsyncWriteStream,

  925.       DynamicBuffer_v2, CompletionCondition, WriteHandler>,

  926.     Executor>

  927. {

  928.   typedef typename associated_executor<WriteHandler, Executor>::type type;

  929. 

  930.   static type get(

  931.       const detail::write_dynbuf_v2_op<AsyncWriteStream,

  932.         DynamicBuffer_v2, CompletionCondition, WriteHandler>& h,

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

  934.   {

  935.     return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);

  936.   }

  937. };

  938. 

  939. #endif // !defined(GENERATING_DOCUMENTATION)

  940. 

  941. template <typename AsyncWriteStream,

  942.     typename DynamicBuffer_v2, typename WriteHandler>

  943. inline ASIO_INITFN_RESULT_TYPE(WriteHandler,

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

  945. async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,

  946.     ASIO_MOVE_ARG(WriteHandler) handler,

  947.     typename enable_if<

  948.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  949.     >::type*)

  950. {

  951.   return async_write(s,

  952.       ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  953.       transfer_all(), ASIO_MOVE_CAST(WriteHandler)(handler));

  954. }

  955. 

  956. template <typename AsyncWriteStream, typename DynamicBuffer_v2,

  957.     typename CompletionCondition, typename WriteHandler>

  958. inline ASIO_INITFN_RESULT_TYPE(WriteHandler,

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

  960. async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,

  961.     CompletionCondition completion_condition,

  962.     ASIO_MOVE_ARG(WriteHandler) handler,

  963.     typename enable_if<

  964.       is_dynamic_buffer_v2<DynamicBuffer_v2>::value

  965.     >::type*)

  966. {

  967.   return async_initiate<WriteHandler,

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

  969.       detail::initiate_async_write_dynbuf_v2(), handler, &s,

  970.       ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),

  971.       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));

  972. }

  973. 

  974. } // namespace asio

  975. 

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

  977. 

  978. #endif // ASIO_IMPL_WRITE_HPP