Imported Upstream version 1.66.0upstream/1.66.0

1 files changed, 357 insertions, 448 deletions

diff --git a/boost/asio/impl/write.hpp b/boost/asio/impl/write.hpp
index 84313fed09..8048380f9f 100644
--- a/boost/asio/impl/write.hpp
+++ b/boost/asio/impl/write.hpp
@@ -15,6 +15,8 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associated_executor.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
@@ -33,30 +35,46 @@
 namespace boost {
 namespace asio {
 
-template <typename SyncWriteStream, typename ConstBufferSequence,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, boost::system::error_code& ec)
+namespace detail
 {
-  ec = boost::system::error_code();
-  boost::asio::detail::consuming_buffers<
-    const_buffer, ConstBufferSequence> tmp(buffers);
-  std::size_t total_transferred = 0;
-  tmp.prepare(detail::adapt_completion_condition_result(
-        completion_condition(ec, total_transferred)));
-  while (tmp.begin() != tmp.end())
+  template <typename SyncWriteStream, typename ConstBufferSequence,
+      typename ConstBufferIterator, typename CompletionCondition>
+  std::size_t write_buffer_sequence(SyncWriteStream& s,
+      const ConstBufferSequence& buffers, const ConstBufferIterator&,
+      CompletionCondition completion_condition, boost::system::error_code& ec)
   {
-    std::size_t bytes_transferred = s.write_some(tmp, ec);
-    tmp.consume(bytes_transferred);
-    total_transferred += bytes_transferred;
-    tmp.prepare(detail::adapt_completion_condition_result(
-          completion_condition(ec, total_transferred)));
+    ec = boost::system::error_code();
+    boost::asio::detail::consuming_buffers<const_buffer,
+        ConstBufferSequence, ConstBufferIterator> tmp(buffers);
+    while (!tmp.empty())
+    {
+      if (std::size_t max_size = detail::adapt_completion_condition_result(
+            completion_condition(ec, tmp.total_consumed())))
+        tmp.consume(s.write_some(tmp.prepare(max_size), ec));
+      else
+        break;
+    }
+    return tmp.total_consumed();;
   }
-  return total_transferred;
+} // namespace detail
+
+template <typename SyncWriteStream, typename ConstBufferSequence,
+    typename CompletionCondition>
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    CompletionCondition completion_condition, boost::system::error_code& ec,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
+{
+  return detail::write_buffer_sequence(s, buffers,
+      boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
 }
 
 template <typename SyncWriteStream, typename ConstBufferSequence>
-inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
@@ -66,7 +84,10 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
 
 template <typename SyncWriteStream, typename ConstBufferSequence>
 inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    boost::system::error_code& ec)
+    boost::system::error_code& ec,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   return write(s, buffers, transfer_all(), ec);
 }
@@ -74,7 +95,10 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
 template <typename SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition)
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
@@ -82,35 +106,92 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
   return bytes_transferred;
 }
 
-#if !defined(BOOST_ASIO_NO_IOSTREAM)
-
-template <typename SyncWriteStream, typename Allocator,
+template <typename SyncWriteStream, typename DynamicBuffer,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s,
-    boost::asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, boost::system::error_code& ec)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition, boost::system::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<DynamicBuffer>::value
+    >::type*)
 {
+  typename decay<DynamicBuffer>::type b(
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec);
   b.consume(bytes_transferred);
   return bytes_transferred;
 }
 
-template <typename SyncWriteStream, typename Allocator>
+template <typename SyncWriteStream, typename DynamicBuffer>
 inline std::size_t write(SyncWriteStream& s,
-    boost::asio::basic_streambuf<Allocator>& b)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    typename enable_if<
+      is_dynamic_buffer<DynamicBuffer>::value
+    >::type*)
 {
   boost::system::error_code ec;
-  std::size_t bytes_transferred = write(s, b, transfer_all(), ec);
+  std::size_t bytes_transferred = write(s,
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      transfer_all(), ec);
   boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
+template <typename SyncWriteStream, typename DynamicBuffer>
+inline std::size_t write(SyncWriteStream& s,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    boost::system::error_code& ec,
+    typename enable_if<
+      is_dynamic_buffer<DynamicBuffer>::value
+    >::type*)
+{
+  return write(s, BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      transfer_all(), ec);
+}
+
+template <typename SyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition>
+inline std::size_t write(SyncWriteStream& s,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    CompletionCondition completion_condition,
+    typename enable_if<
+      is_dynamic_buffer<DynamicBuffer>::value
+    >::type*)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write(s,
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "write");
+  return bytes_transferred;
+}
+
+#if !defined(BOOST_ASIO_NO_EXTENSIONS)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
+
+template <typename SyncWriteStream, typename Allocator,
+    typename CompletionCondition>
+inline std::size_t write(SyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  return write(s, basic_streambuf_ref<Allocator>(b), completion_condition, ec);
+}
+
+template <typename SyncWriteStream, typename Allocator>
+inline std::size_t write(SyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b)
+{
+  return write(s, basic_streambuf_ref<Allocator>(b));
+}
+
 template <typename SyncWriteStream, typename Allocator>
 inline std::size_t write(SyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     boost::system::error_code& ec)
 {
-  return write(s, b, transfer_all(), ec);
+  return write(s, basic_streambuf_ref<Allocator>(b), ec);
 }
 
 template <typename SyncWriteStream, typename Allocator,
@@ -119,18 +200,17 @@ inline std::size_t write(SyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition)
 {
-  boost::system::error_code ec;
-  std::size_t bytes_transferred = write(s, b, completion_condition, ec);
-  boost::asio::detail::throw_error(ec, "write");
-  return bytes_transferred;
+  return write(s, basic_streambuf_ref<Allocator>(b), completion_condition);
 }
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
 
 namespace detail
 {
   template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
   class write_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
@@ -142,7 +222,6 @@ namespace detail
         stream_(stream),
         buffers_(buffers),
         start_(0),
-        total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
@@ -153,7 +232,6 @@ namespace detail
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
@@ -163,7 +241,6 @@ namespace detail
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
-        total_transferred_(other.total_transferred_),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
     }
@@ -172,362 +249,39 @@ namespace detail
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
+      std::size_t max_size;
       switch (start_ = start)
       {
         case 1:
-        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-        for (;;)
+        max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        do
         {
-          stream_.async_write_some(buffers_,
+          stream_.async_write_some(buffers_.prepare(max_size),
               BOOST_ASIO_MOVE_CAST(write_op)(*this));
           return; default:
-          total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
-          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
-          if ((!ec && bytes_transferred == 0)
-              || buffers_.begin() == buffers_.end())
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    boost::asio::detail::consuming_buffers<
-      const_buffer, ConstBufferSequence> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, boost::asio::mutable_buffers_1,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream,
-        const boost::asio::mutable_buffers_1& buffers,
-        CompletionCondition completion_condition,
-        WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffer_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-    write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_op(write_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
-    void operator()(const boost::system::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          stream_.async_write_some(
-              boost::asio::buffer(buffer_ + total_transferred_, n),
-              BOOST_ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == boost::asio::buffer_size(buffer_))
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    boost::asio::mutable_buffer buffer_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, boost::asio::const_buffers_1,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream,
-        const boost::asio::const_buffers_1& buffers,
-        CompletionCondition completion_condition,
-        WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffer_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-    write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_op(write_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
-    void operator()(const boost::system::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          stream_.async_write_some(
-              boost::asio::buffer(buffer_ + total_transferred_, n),
-              BOOST_ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == boost::asio::buffer_size(buffer_))
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    boost::asio::const_buffer buffer_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, boost::array<Elem, 2>,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream, const boost::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-    write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_op(write_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
-    void operator()(const boost::system::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
-        boost::asio::const_buffer(buffers_[0]),
-        boost::asio::const_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          stream_.async_write_some(bufs, BOOST_ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
+          if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
-        }
+          max_size = this->check_for_completion(ec, buffers_.total_consumed());
+        } while (max_size > 0);
 
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+        handler_(ec, buffers_.total_consumed());
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
-    boost::array<Elem, 2> buffers_;
+    boost::asio::detail::consuming_buffers<const_buffer,
+        ConstBufferSequence, ConstBufferIterator> buffers_;
     int start_;
-    std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncWriteStream, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, std::array<Elem, 2>,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream, const std::array<Elem, 2>& buffers,
-        CompletionCondition completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(buffers),
-        start_(0),
-        total_transferred_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-    write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_op(write_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
-    {
-    }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
-    void operator()(const boost::system::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          std::array<boost::asio::const_buffer, 2> >::type bufs = {{
-        boost::asio::const_buffer(buffers_[0]),
-        boost::asio::const_buffer(buffers_[1]) }};
-      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
-      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
-      std::size_t n = 0;
-      switch (start_ = start)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          stream_.async_write_some(bufs, BOOST_ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    std::array<Elem, 2> buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
   template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
@@ -535,9 +289,10 @@ namespace detail
   }
 
   template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
@@ -545,9 +300,10 @@ namespace detail
   }
 
   template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename CompletionCondition, typename WriteHandler>
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
   inline bool asio_handler_is_continuation(
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
@@ -556,10 +312,10 @@ namespace detail
   }
 
   template <typename Function, typename AsyncWriteStream,
-      typename ConstBufferSequence, typename CompletionCondition,
-      typename WriteHandler>
+      typename ConstBufferSequence, typename ConstBufferIterator,
+      typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_invoke(Function& function,
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
@@ -567,38 +323,94 @@ namespace detail
   }
 
   template <typename Function, typename AsyncWriteStream,
-      typename ConstBufferSequence, typename CompletionCondition,
-      typename WriteHandler>
+      typename ConstBufferSequence, typename ConstBufferIterator,
+      typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_op<AsyncWriteStream, ConstBufferSequence,
+      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename ConstBufferIterator, typename CompletionCondition,
+      typename WriteHandler>
+  inline void start_write_buffer_sequence_op(AsyncWriteStream& stream,
+      const ConstBufferSequence& buffers, const ConstBufferIterator&,
+      CompletionCondition completion_condition, WriteHandler& handler)
+  {
+    detail::write_op<AsyncWriteStream, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>(
+        stream, buffers, completion_condition, handler)(
+          boost::system::error_code(), 0, 1);
+  }
+
 } // namespace detail
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncWriteStream, typename ConstBufferSequence,
+    typename ConstBufferIterator, typename CompletionCondition,
+    typename WriteHandler, typename Allocator>
+struct associated_allocator<
+    detail::write_op<AsyncWriteStream, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+
+  static type get(
+      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
+        ConstBufferIterator, CompletionCondition, WriteHandler>& h,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncWriteStream, typename ConstBufferSequence,
+    typename ConstBufferIterator, typename CompletionCondition,
+    typename WriteHandler, typename Executor>
+struct associated_executor<
+    detail::write_op<AsyncWriteStream, ConstBufferSequence,
+      ConstBufferIterator, CompletionCondition, WriteHandler>,
+    Executor>
+{
+  typedef typename associated_executor<WriteHandler, Executor>::type type;
+
+  static type get(
+      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
+        ConstBufferIterator, CompletionCondition, WriteHandler>& h,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 template <typename AsyncWriteStream, typename ConstBufferSequence,
   typename CompletionCondition, typename WriteHandler>
 inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
-  detail::write_op<AsyncWriteStream, ConstBufferSequence,
-    CompletionCondition, BOOST_ASIO_HANDLER_TYPE(
-      WriteHandler, void (boost::system::error_code, std::size_t))>(
-        s, buffers, completion_condition, init.handler)(
-          boost::system::error_code(), 0, 1);
+  detail::start_write_buffer_sequence_op(s, buffers,
+      boost::asio::buffer_sequence_begin(buffers), completion_condition,
+      init.completion_handler);
 
   return init.result.get();
 }
@@ -608,132 +420,227 @@ template <typename AsyncWriteStream, typename ConstBufferSequence,
 inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_const_buffer_sequence<ConstBufferSequence>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
-  detail::write_op<AsyncWriteStream, ConstBufferSequence,
-    detail::transfer_all_t, BOOST_ASIO_HANDLER_TYPE(
-      WriteHandler, void (boost::system::error_code, std::size_t))>(
-        s, buffers, transfer_all(), init.handler)(
-          boost::system::error_code(), 0, 1);
+  detail::start_write_buffer_sequence_op(s, buffers,
+      boost::asio::buffer_sequence_begin(buffers), transfer_all(),
+      init.completion_handler);
 
   return init.result.get();
 }
 
-#if !defined(BOOST_ASIO_NO_IOSTREAM)
-
 namespace detail
 {
-  template <typename Allocator, typename WriteHandler>
-  class write_streambuf_handler
+  template <typename AsyncWriteStream, typename DynamicBuffer,
+      typename CompletionCondition, typename WriteHandler>
+  class write_dynbuf_op
   {
   public:
-    write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
-        WriteHandler& handler)
-      : streambuf_(streambuf),
+    template <typename BufferSequence>
+    write_dynbuf_op(AsyncWriteStream& stream,
+        BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
+        CompletionCondition completion_condition, WriteHandler& handler)
+      : stream_(stream),
+        buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
+        completion_condition_(
+          BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition)),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
-    write_streambuf_handler(const write_streambuf_handler& other)
-      : streambuf_(other.streambuf_),
+    write_dynbuf_op(const write_dynbuf_op& other)
+      : stream_(other.stream_),
+        buffers_(other.buffers_),
+        completion_condition_(other.completion_condition_),
         handler_(other.handler_)
     {
     }
 
-    write_streambuf_handler(write_streambuf_handler&& other)
-      : streambuf_(other.streambuf_),
+    write_dynbuf_op(write_dynbuf_op&& other)
+      : stream_(other.stream_),
+        buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
+        completion_condition_(
+          BOOST_ASIO_MOVE_CAST(CompletionCondition)(
+            other.completion_condition_)),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
-        const std::size_t bytes_transferred)
+        std::size_t bytes_transferred, int start = 0)
     {
-      streambuf_.consume(bytes_transferred);
-      handler_(ec, bytes_transferred);
+      switch (start)
+      {
+        case 1:
+        async_write(stream_, buffers_.data(), completion_condition_,
+            BOOST_ASIO_MOVE_CAST(write_dynbuf_op)(*this));
+        return; default:
+        buffers_.consume(bytes_transferred);
+        handler_(ec, static_cast<const std::size_t&>(bytes_transferred));
+      }
     }
 
   //private:
-    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    AsyncWriteStream& stream_;
+    DynamicBuffer buffers_;
+    CompletionCondition completion_condition_;
     WriteHandler handler_;
   };
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename DynamicBuffer,
+      typename CompletionCondition, typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename DynamicBuffer,
+      typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename DynamicBuffer,
+      typename CompletionCondition, typename WriteHandler>
   inline bool asio_handler_is_continuation(
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     return boost_asio_handler_cont_helpers::is_continuation(
         this_handler->handler_);
   }
 
-  template <typename Function, typename Allocator, typename WriteHandler>
+  template <typename Function, typename AsyncWriteStream,
+      typename DynamicBuffer, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_invoke(Function& function,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename Allocator, typename WriteHandler>
+  template <typename Function, typename AsyncWriteStream,
+      typename DynamicBuffer, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
+        CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncWriteStream, typename Allocator,
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition, typename WriteHandler, typename Allocator>
+struct associated_allocator<
+    detail::write_dynbuf_op<AsyncWriteStream,
+      DynamicBuffer, CompletionCondition, WriteHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+
+  static type get(
+      const detail::write_dynbuf_op<AsyncWriteStream,
+        DynamicBuffer, CompletionCondition, WriteHandler>& h,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncWriteStream, typename DynamicBuffer,
+    typename CompletionCondition, typename WriteHandler, typename Executor>
+struct associated_executor<
+    detail::write_dynbuf_op<AsyncWriteStream,
+      DynamicBuffer, CompletionCondition, WriteHandler>,
+    Executor>
+{
+  typedef typename associated_executor<WriteHandler, Executor>::type type;
+
+  static type get(
+      const detail::write_dynbuf_op<AsyncWriteStream,
+        DynamicBuffer, CompletionCondition, WriteHandler>& h,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncWriteStream,
+    typename DynamicBuffer, typename WriteHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write(AsyncWriteStream& s,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<DynamicBuffer>::value
+    >::type*)
+{
+  return async_write(s,
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      transfer_all(), BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+}
+
+template <typename AsyncWriteStream, typename DynamicBuffer,
     typename CompletionCondition, typename WriteHandler>
 inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s,
-    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    typename enable_if<
+      is_dynamic_buffer<DynamicBuffer>::value
+    >::type*)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a WriteHandler.
   BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
 
-  detail::async_result_init<
-    WriteHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+  async_completion<WriteHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
-  async_write(s, b.data(), completion_condition,
-    detail::write_streambuf_handler<Allocator, BOOST_ASIO_HANDLER_TYPE(
-      WriteHandler, void (boost::system::error_code, std::size_t))>(
-        b, init.handler));
+  detail::write_dynbuf_op<AsyncWriteStream,
+    typename decay<DynamicBuffer>::type,
+      CompletionCondition, BOOST_ASIO_HANDLER_TYPE(
+        WriteHandler, void (boost::system::error_code, std::size_t))>(
+          s, BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            completion_condition, init.completion_handler)(
+              boost::system::error_code(), 0, 1);
 
   return init.result.get();
 }
 
+#if !defined(BOOST_ASIO_NO_EXTENSIONS)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
+
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
 inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
     void (boost::system::error_code, std::size_t))
@@ -741,23 +648,25 @@ async_write(AsyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  // If you get an error on the following line it means that your handler does
-  // not meet the documented type requirements for a WriteHandler.
-  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-  detail::async_result_init<
-    WriteHandler, void (boost::system::error_code, std::size_t)> init(
+  return async_write(s, basic_streambuf_ref<Allocator>(b),
       BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+}
 
-  async_write(s, b.data(), transfer_all(),
-    detail::write_streambuf_handler<Allocator, BOOST_ASIO_HANDLER_TYPE(
-      WriteHandler, void (boost::system::error_code, std::size_t))>(
-        b, init.handler));
-
-  return init.result.get();
+template <typename AsyncWriteStream, typename Allocator,
+    typename CompletionCondition, typename WriteHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write(AsyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  return async_write(s, basic_streambuf_ref<Allocator>(b),
+      completion_condition, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
 }
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
 
 } // namespace asio
 } // namespace boost