passenger 6.0.23 → 6.0.25

data/src/cxx_supportlib/vendor-modified/boost/asio/write.hpp

@@ -185,6 +185,9 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
     constraint_t<
       is_const_buffer_sequence<ConstBufferSequence>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 /// Write a certain amount of data to a stream before returning.
@@ -232,6 +235,9 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition, boost::system::error_code& ec,
     constraint_t<
       is_const_buffer_sequence<ConstBufferSequence>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
@@ -357,6 +363,9 @@ std::size_t write(SyncWriteStream& s,
     > = 0,
     constraint_t<
       !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 /// Write a certain amount of data to a stream before returning.
@@ -406,6 +415,9 @@ std::size_t write(SyncWriteStream& s,
     > = 0,
     constraint_t<
       !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 #if !defined(BOOST_ASIO_NO_EXTENSIONS)
@@ -508,7 +520,10 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
 template <typename SyncWriteStream, typename Allocator,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition);
+    CompletionCondition completion_condition,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 /// Write a certain amount of data to a stream before returning.
 /**
@@ -549,7 +564,10 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
 template <typename SyncWriteStream, typename Allocator,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, boost::system::error_code& ec);
+    CompletionCondition completion_condition, boost::system::error_code& ec,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 #endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
@@ -664,6 +682,9 @@ std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
     constraint_t<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 /// Write a certain amount of data to a stream before returning.
@@ -709,6 +730,9 @@ std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition, boost::system::error_code& ec,
     constraint_t<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 /*@}*/
@@ -763,7 +787,7 @@ std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -792,17 +816,26 @@ template <typename AsyncWriteStream, typename ConstBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteToken
         = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+inline auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     WriteToken&& token
       = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
     constraint_t<
       is_const_buffer_sequence<ConstBufferSequence>::value
+    > = 0,
+    constraint_t<
+      !is_completion_condition<decay_t<WriteToken>>::value
     > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write<AsyncWriteStream>>(),
-        token, buffers, transfer_all()));
+        token, buffers, transfer_all()))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write<AsyncWriteStream>(s),
+      token, buffers, transfer_all());
+}
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
@@ -861,7 +894,7 @@ auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -890,19 +923,31 @@ auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
 template <typename AsyncWriteStream,
     typename ConstBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteToken>
-auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+      std::size_t)) WriteToken
+        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
+inline auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
-    WriteToken&& token,
+    WriteToken&& token
+      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
     constraint_t<
       is_const_buffer_sequence<ConstBufferSequence>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write<AsyncWriteStream>>(),
         token, buffers,
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write<AsyncWriteStream>(s),
+      token, buffers,
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 
@@ -949,7 +994,7 @@ auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -969,7 +1014,7 @@ template <typename AsyncWriteStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteToken
         = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
+inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
     WriteToken&& token
       = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
     constraint_t<
@@ -977,13 +1022,23 @@ auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
     > = 0,
     constraint_t<
       !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
+    > = 0,
+    constraint_t<
+      !is_completion_condition<decay_t<WriteToken>>::value
     > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(),
         token, static_cast<DynamicBuffer_v1&&>(buffers),
-        transfer_all()));
+        transfer_all()))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
+      token, static_cast<DynamicBuffer_v1&&>(buffers),
+      transfer_all());
+}
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
@@ -1042,7 +1097,7 @@ auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -1061,21 +1116,34 @@ auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
 template <typename AsyncWriteStream,
     typename DynamicBuffer_v1, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteToken>
-auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition, WriteToken&& token,
+      std::size_t)) WriteToken
+        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
+inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
+    CompletionCondition completion_condition,
+    WriteToken&& token
+      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
     constraint_t<
       is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
     > = 0,
     constraint_t<
       !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(),
         token, static_cast<DynamicBuffer_v1&&>(buffers),
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
+      token, static_cast<DynamicBuffer_v1&&>(buffers),
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #if !defined(BOOST_ASIO_NO_EXTENSIONS)
 #if !defined(BOOST_ASIO_NO_IOSTREAM)
@@ -1121,7 +1189,7 @@ auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -1141,14 +1209,23 @@ template <typename AsyncWriteStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteToken
         = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
+inline auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
     WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>())
+      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
+    constraint_t<
+      !is_completion_condition<decay_t<WriteToken>>::value
+    > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(),
-        token, basic_streambuf_ref<Allocator>(b), transfer_all()));
+        token, basic_streambuf_ref<Allocator>(b), transfer_all()))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
+      token, basic_streambuf_ref<Allocator>(b), transfer_all());
+}
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
@@ -1205,7 +1282,7 @@ auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -1224,15 +1301,28 @@ auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
 template <typename AsyncWriteStream,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteToken>
-auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, WriteToken&& token)
+      std::size_t)) WriteToken
+        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
+inline auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition,
+    WriteToken&& token
+      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(),
         token, basic_streambuf_ref<Allocator>(b),
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
+      token, basic_streambuf_ref<Allocator>(b),
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 #endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
@@ -1281,7 +1371,7 @@ auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -1301,18 +1391,28 @@ template <typename AsyncWriteStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteToken
         = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
+inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
     WriteToken&& token
       = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
     constraint_t<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
+    > = 0,
+    constraint_t<
+      !is_completion_condition<decay_t<WriteToken>>::value
     > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>>(),
         token, static_cast<DynamicBuffer_v2&&>(buffers),
-        transfer_all()));
+        transfer_all()))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>(s),
+      token, static_cast<DynamicBuffer_v2&&>(buffers),
+      transfer_all());
+}
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
@@ -1371,7 +1471,7 @@ auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -1390,19 +1490,31 @@ auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
 template <typename AsyncWriteStream,
     typename DynamicBuffer_v2, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteToken>
-auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
+      std::size_t)) WriteToken
+        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
+inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
-    WriteToken&& token,
+    WriteToken&& token
+      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
     constraint_t<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>>(),
         token, static_cast<DynamicBuffer_v2&&>(buffers),
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>(s),
+      token, static_cast<DynamicBuffer_v2&&>(buffers),
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 /*@}*/
 

data/src/cxx_supportlib/vendor-modified/boost/asio/write_at.hpp

@@ -188,7 +188,10 @@ template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition);
+    CompletionCondition completion_condition,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 /// Write a certain amount of data at a specified offset before returning.
 /**
@@ -236,7 +239,10 @@ template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, boost::system::error_code& ec);
+    CompletionCondition completion_condition, boost::system::error_code& ec,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 #if !defined(BOOST_ASIO_NO_EXTENSIONS)
 #if !defined(BOOST_ASIO_NO_IOSTREAM)
@@ -349,7 +355,10 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
 template <typename SyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition>
 std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
-    basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
+    basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 /// Write a certain amount of data at a specified offset before returning.
 /**
@@ -392,9 +401,12 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
  */
 template <typename SyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
-    basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
-    boost::system::error_code& ec);
+std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    uint64_t offset, basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition, boost::system::error_code& ec,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 #endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
@@ -457,7 +469,7 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -486,16 +498,25 @@ template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteToken = default_completion_token_t<
         typename AsyncRandomAccessWriteDevice::executor_type>>
-auto async_write_at(AsyncRandomAccessWriteDevice& d,
+inline auto async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
     WriteToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessWriteDevice::executor_type>())
+      typename AsyncRandomAccessWriteDevice::executor_type>(),
+    constraint_t<
+      !is_completion_condition<WriteToken>::value
+    > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_at<
           AsyncRandomAccessWriteDevice>>(),
-        token, offset, buffers, transfer_all()));
+        token, offset, buffers, transfer_all()))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_at<AsyncRandomAccessWriteDevice>(d),
+      token, offset, buffers, transfer_all());
+}
 
 /// Start an asynchronous operation to write a certain amount of data at the
 /// specified offset.
@@ -559,7 +580,7 @@ auto async_write_at(AsyncRandomAccessWriteDevice& d,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -590,18 +611,28 @@ template <typename AsyncRandomAccessWriteDevice,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteToken = default_completion_token_t<
         typename AsyncRandomAccessWriteDevice::executor_type>>
-auto async_write_at(AsyncRandomAccessWriteDevice& d,
+inline auto async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
     WriteToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessWriteDevice::executor_type>())
+      typename AsyncRandomAccessWriteDevice::executor_type>(),
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_at<
           AsyncRandomAccessWriteDevice>>(),
         token, offset, buffers,
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_at<AsyncRandomAccessWriteDevice>(d),
+      token, offset, buffers,
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #if !defined(BOOST_ASIO_NO_EXTENSIONS)
 #if !defined(BOOST_ASIO_NO_IOSTREAM)
@@ -652,7 +683,7 @@ auto async_write_at(AsyncRandomAccessWriteDevice& d,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -672,16 +703,26 @@ template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteToken = default_completion_token_t<
         typename AsyncRandomAccessWriteDevice::executor_type>>
-auto async_write_at(AsyncRandomAccessWriteDevice& d,
+inline auto async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, basic_streambuf<Allocator>& b,
     WriteToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessWriteDevice::executor_type>())
+      typename AsyncRandomAccessWriteDevice::executor_type>(),
+    constraint_t<
+      !is_completion_condition<WriteToken>::value
+    > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_at_streambuf<
           AsyncRandomAccessWriteDevice>>(),
-        token, offset, &b, transfer_all()));
+        token, offset, &b, transfer_all()))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_at_streambuf<
+        AsyncRandomAccessWriteDevice>(d),
+      token, offset, &b, transfer_all());
+}
 
 /// Start an asynchronous operation to write a certain amount of data at the
 /// specified offset.
@@ -743,7 +784,7 @@ auto async_write_at(AsyncRandomAccessWriteDevice& d,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, std::size_t) @endcode
@@ -764,17 +805,28 @@ template <typename AsyncRandomAccessWriteDevice,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteToken = default_completion_token_t<
         typename AsyncRandomAccessWriteDevice::executor_type>>
-auto async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
+inline auto async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
     WriteToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessWriteDevice::executor_type>())
+      typename AsyncRandomAccessWriteDevice::executor_type>(),
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0)
   -> decltype(
     async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
         declval<detail::initiate_async_write_at_streambuf<
           AsyncRandomAccessWriteDevice>>(),
         token, offset, &b,
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<WriteToken,
+    void (boost::system::error_code, std::size_t)>(
+      detail::initiate_async_write_at_streambuf<
+        AsyncRandomAccessWriteDevice>(d),
+      token, offset, &b,
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 #endif // !defined(BOOST_ASIO_NO_EXTENSIONS)

data/src/cxx_supportlib/vendor-modified/boost/asio.hpp

@@ -61,12 +61,16 @@
 #include <boost/asio/buffered_write_stream_fwd.hpp>
 #include <boost/asio/buffered_write_stream.hpp>
 #include <boost/asio/buffers_iterator.hpp>
+#include <boost/asio/cancel_after.hpp>
+#include <boost/asio/cancel_at.hpp>
 #include <boost/asio/cancellation_signal.hpp>
 #include <boost/asio/cancellation_state.hpp>
 #include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/co_composed.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/compose.hpp>
+#include <boost/asio/composed.hpp>
 #include <boost/asio/connect.hpp>
 #include <boost/asio/connect_pipe.hpp>
 #include <boost/asio/consign.hpp>
@@ -74,6 +78,7 @@
 #include <boost/asio/deadline_timer.hpp>
 #include <boost/asio/defer.hpp>
 #include <boost/asio/deferred.hpp>
+#include <boost/asio/default_completion_token.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/dispatch.hpp>
 #include <boost/asio/error.hpp>
@@ -101,6 +106,7 @@
 #include <boost/asio/generic/stream_protocol.hpp>
 #include <boost/asio/handler_continuation_hook.hpp>
 #include <boost/asio/high_resolution_timer.hpp>
+#include <boost/asio/immediate.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/io_context_strand.hpp>
 #include <boost/asio/io_service.hpp>

data/src/cxx_supportlib/vendor-modified/boost/assert/source_location.hpp

@@ -174,9 +174,12 @@ template<class E, class T> std::basic_ostream<E, T> & operator<<( std::basic_ost
 
 # define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN())
 
-#elif defined(BOOST_GCC) && BOOST_GCC >= 70000
+#elif defined(BOOST_GCC) && BOOST_GCC >= 80000
 
 // The built-ins are available in 4.8+, but are not constant expressions until 7
+// In addition, reproducible builds require -ffile-prefix-map, which is GCC 8
+// https://github.com/boostorg/assert/issues/38
+
 # define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION())
 
 #elif defined(BOOST_GCC) && BOOST_GCC >= 50000