1 files changed, 189 insertions, 42 deletions
diff --git a/3rdParty/Boost/src/boost/asio/impl/write.hpp b/3rdParty/Boost/src/boost/asio/impl/write.hpp
index ae420bc..2c5c595 100644
--- a/3rdParty/Boost/src/boost/asio/impl/write.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/write.hpp
@@ -22,6 +22,7 @@
 #include <boost/asio/detail/consuming_buffers.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -56,10 +57,17 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
+template <typename SyncWriteStream, typename ConstBufferSequence>
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return write(s, buffers, transfer_all(), ec);
+}
+
 template <typename SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
@@ -67,7 +75,7 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
@@ -90,10 +98,18 @@ inline std::size_t write(SyncWriteStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, b, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
+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);
+}
+
 template <typename SyncWriteStream, typename Allocator,
     typename CompletionCondition>
 inline std::size_t write(SyncWriteStream& s,
@@ -102,7 +118,7 @@ inline std::size_t write(SyncWriteStream& s,
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, b, completion_condition, ec);
-  boost::asio::detail::throw_error(ec);
+  boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
@@ -117,15 +133,35 @@ namespace detail
   {
   public:
     write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
-        CompletionCondition completion_condition, WriteHandler handler)
+        CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        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_),
+        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_),
+        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)
@@ -136,7 +172,8 @@ namespace detail
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
         for (;;)
         {
-          stream_.async_write_some(buffers_, *this);
+          stream_.async_write_some(buffers_,
+              BOOST_ASIO_MOVE_CAST(write_op)(*this));
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
@@ -168,16 +205,36 @@ namespace detail
     write_op(AsyncWriteStream& stream,
         const boost::asio::mutable_buffers_1& buffers,
         CompletionCondition completion_condition,
-        WriteHandler handler)
+        WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        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_),
+        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_),
+        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)
     {
@@ -188,8 +245,9 @@ namespace detail
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
-          stream_.async_write_some(boost::asio::buffer(
-                buffer_ + total_transferred_, n), *this);
+          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)
@@ -219,16 +277,36 @@ namespace detail
     write_op(AsyncWriteStream& stream,
         const boost::asio::const_buffers_1& buffers,
         CompletionCondition completion_condition,
-        WriteHandler handler)
+        WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(handler)
+        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_),
+        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_),
+        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)
     {
@@ -239,8 +317,9 @@ namespace detail
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
-          stream_.async_write_some(boost::asio::buffer(
-                buffer_ + total_transferred_, n), *this);
+          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)
@@ -283,6 +362,17 @@ namespace detail
   template <typename Function, typename AsyncWriteStream,
       typename ConstBufferSequence, typename CompletionCondition,
       typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_op<AsyncWriteStream, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncWriteStream,
+      typename ConstBufferSequence, typename CompletionCondition,
+      typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
       write_op<AsyncWriteStream, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
@@ -290,43 +380,78 @@ namespace detail
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline write_op<AsyncWriteStream, ConstBufferSequence,
+      CompletionCondition, WriteHandler>
+  make_write_op(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+      CompletionCondition completion_condition, WriteHandler handler)
+  {
+    return write_op<AsyncWriteStream, ConstBufferSequence, CompletionCondition,
+      WriteHandler>(s, buffers, completion_condition, handler);
+  }
 } // namespace detail
 
 template <typename AsyncWriteStream, typename ConstBufferSequence,
   typename CompletionCondition, typename WriteHandler>
 inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, WriteHandler handler)
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  detail::write_op<AsyncWriteStream, ConstBufferSequence,
-    CompletionCondition, WriteHandler>(
-      s, buffers, completion_condition, 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::make_write_op(
+    s, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
         boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     typename WriteHandler>
 inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    WriteHandler handler)
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  async_write(s, buffers, transfer_all(), 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::make_write_op(
+    s, buffers, transfer_all(), BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
+      boost::system::error_code(), 0, 1);
 }
 
 #if !defined(BOOST_NO_IOSTREAM)
 
 namespace detail
 {
-  template <typename AsyncWriteStream, typename Allocator,
-      typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   class write_streambuf_handler
   {
   public:
     write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
-        WriteHandler handler)
+        WriteHandler& handler)
       : streambuf_(streambuf),
-        handler_(handler)
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_streambuf_handler(const write_streambuf_handler& other)
+      : streambuf_(other.streambuf_),
+        handler_(other.handler_)
     {
     }
 
+    write_streambuf_handler(write_streambuf_handler&& other)
+      : streambuf_(other.streambuf_),
+        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)
     {
@@ -339,53 +464,75 @@ namespace detail
     WriteHandler handler_;
   };
 
-  template <typename AsyncWriteStream, typename Allocator,
-      typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_streambuf_handler<AsyncWriteStream,
-        Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncWriteStream, typename Allocator,
-      typename WriteHandler>
+  template <typename Allocator, typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_streambuf_handler<AsyncWriteStream,
-        Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncWriteStream, typename Allocator,
-      typename WriteHandler>
+  template <typename Function, typename Allocator, typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Allocator, typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_streambuf_handler<AsyncWriteStream,
-        Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
+
+  template <typename Allocator, typename WriteHandler>
+  inline write_streambuf_handler<Allocator, WriteHandler>
+  make_write_streambuf_handler(
+      boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
+  {
+    return write_streambuf_handler<Allocator, WriteHandler>(b, handler);
+  }
 } // namespace detail
 
 template <typename AsyncWriteStream, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
 inline void async_write(AsyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, WriteHandler handler)
+    CompletionCondition completion_condition,
+    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;
+
   async_write(s, b.data(), completion_condition,
-      detail::write_streambuf_handler<
-        AsyncWriteStream, Allocator, WriteHandler>(b, handler));
+      detail::make_write_streambuf_handler(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
 }
 
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
 inline void async_write(AsyncWriteStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
+    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
 {
-  async_write(s, b, transfer_all(), 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;
+
+  async_write(s, b.data(), transfer_all(),
+      detail::make_write_streambuf_handler(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)