passenger 5.3.3 → 5.3.4

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

@@ -2,7 +2,7 @@
 // impl/read_until.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,8 @@
 #include <string>
 #include <vector>
 #include <utility>
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associated_executor.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/buffers_iterator.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
@@ -34,32 +36,35 @@
 namespace boost {
 namespace asio {
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 inline std::size_t read_until(SyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, char delim)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers, char delim)
 {
   boost::system::error_code ec;
-  std::size_t bytes_transferred = read_until(s, b, delim, ec);
+  std::size_t bytes_transferred = read_until(s,
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers), delim, ec);
   boost::asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, char delim,
-    boost::system::error_code& ec)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    char delim, boost::system::error_code& ec)
 {
+  typename decay<DynamicBuffer>::type b(
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
-    typedef typename boost::asio::basic_streambuf<
-      Allocator>::const_buffers_type const_buffers_type;
-    typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
-    const_buffers_type buffers = b.data();
-    iterator begin = iterator::begin(buffers);
+    typedef typename DynamicBuffer::const_buffers_type buffers_type;
+    typedef buffers_iterator<buffers_type> iterator;
+    buffers_type data_buffers = b.data();
+    iterator begin = iterator::begin(data_buffers);
     iterator start_pos = begin + search_position;
-    iterator end = iterator::end(buffers);
+    iterator end = iterator::end(data_buffers);
 
     // Look for a match.
     iterator iter = std::find(start_pos, end, delim);
@@ -83,19 +88,23 @@ std::size_t read_until(SyncReadStream& s,
     }
 
     // Need more data.
-    std::size_t bytes_to_read = read_size_helper(b, 65536);
+    std::size_t bytes_to_read = std::min<std::size_t>(
+          std::max<std::size_t>(512, b.capacity() - b.size()),
+          std::min<std::size_t>(65536, b.max_size() - b.size()));
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 inline std::size_t read_until(SyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, const std::string& delim)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    BOOST_ASIO_STRING_VIEW_PARAM delim)
 {
   boost::system::error_code ec;
-  std::size_t bytes_transferred = read_until(s, b, delim, ec);
+  std::size_t bytes_transferred = read_until(s,
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers), delim, ec);
   boost::asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
@@ -135,22 +144,24 @@ namespace detail
   }
 } // namespace detail
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
-    boost::system::error_code& ec)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    BOOST_ASIO_STRING_VIEW_PARAM delim, boost::system::error_code& ec)
 {
+  typename decay<DynamicBuffer>::type b(
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
-    typedef typename boost::asio::basic_streambuf<
-      Allocator>::const_buffers_type const_buffers_type;
-    typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
-    const_buffers_type buffers = b.data();
-    iterator begin = iterator::begin(buffers);
+    typedef typename DynamicBuffer::const_buffers_type buffers_type;
+    typedef buffers_iterator<buffers_type> iterator;
+    buffers_type data_buffers = b.data();
+    iterator begin = iterator::begin(data_buffers);
     iterator start_pos = begin + search_position;
-    iterator end = iterator::end(buffers);
+    iterator end = iterator::end(data_buffers);
 
     // Look for a match.
     std::pair<iterator, bool> result = detail::partial_search(
@@ -183,41 +194,48 @@ std::size_t read_until(SyncReadStream& s,
     }
 
     // Need more data.
-    std::size_t bytes_to_read = read_size_helper(b, 65536);
+    std::size_t bytes_to_read = std::min<std::size_t>(
+          std::max<std::size_t>(512, b.capacity() - b.size()),
+          std::min<std::size_t>(65536, b.max_size() - b.size()));
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
+#if !defined(BOOST_ASIO_NO_EXTENSIONS)
 #if defined(BOOST_ASIO_HAS_BOOST_REGEX)
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 inline std::size_t read_until(SyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr)
 {
   boost::system::error_code ec;
-  std::size_t bytes_transferred = read_until(s, b, expr, ec);
+  std::size_t bytes_transferred = read_until(s,
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers), expr, ec);
   boost::asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
 
-template <typename SyncReadStream, typename Allocator>
+template <typename SyncReadStream, typename DynamicBuffer>
 std::size_t read_until(SyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    boost::system::error_code& ec)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr, boost::system::error_code& ec)
 {
+  typename decay<DynamicBuffer>::type b(
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
-    typedef typename boost::asio::basic_streambuf<
-      Allocator>::const_buffers_type const_buffers_type;
-    typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
-    const_buffers_type buffers = b.data();
-    iterator begin = iterator::begin(buffers);
+    typedef typename DynamicBuffer::const_buffers_type buffers_type;
+    typedef buffers_iterator<buffers_type> iterator;
+    buffers_type data_buffers = b.data();
+    iterator begin = iterator::begin(data_buffers);
     iterator start_pos = begin + search_position;
-    iterator end = iterator::end(buffers);
+    iterator end = iterator::end(data_buffers);
 
     // Look for a match.
     boost::match_results<iterator,
@@ -261,23 +279,41 @@ std::size_t read_until(SyncReadStream& s,
 
 #endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
 
-template <typename SyncReadStream, typename Allocator, typename MatchCondition>
+template <typename SyncReadStream,
+    typename DynamicBuffer, typename MatchCondition>
+inline std::size_t read_until(SyncReadStream& s,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    MatchCondition match_condition,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read_until(s,
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+      match_condition, ec);
+  boost::asio::detail::throw_error(ec, "read_until");
+  return bytes_transferred;
+}
+
+template <typename SyncReadStream,
+    typename DynamicBuffer, typename MatchCondition>
 std::size_t read_until(SyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
     MatchCondition match_condition, boost::system::error_code& ec,
     typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
+  typename decay<DynamicBuffer>::type b(
+      BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers));
+
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
-    typedef typename boost::asio::basic_streambuf<
-      Allocator>::const_buffers_type const_buffers_type;
-    typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
-    const_buffers_type buffers = b.data();
-    iterator begin = iterator::begin(buffers);
+    typedef typename DynamicBuffer::const_buffers_type buffers_type;
+    typedef buffers_iterator<buffers_type> iterator;
+    buffers_type data_buffers = b.data();
+    iterator begin = iterator::begin(data_buffers);
     iterator start_pos = begin + search_position;
-    iterator end = iterator::end(buffers);
+    iterator end = iterator::end(data_buffers);
 
     // Look for a match.
     std::pair<iterator, bool> result = match_condition(start_pos, end);
@@ -306,35 +342,100 @@ std::size_t read_until(SyncReadStream& s,
     }
 
     // Need more data.
-    std::size_t bytes_to_read = read_size_helper(b, 65536);
+    std::size_t bytes_to_read = std::min<std::size_t>(
+          std::max<std::size_t>(512, b.capacity() - b.size()),
+          std::min<std::size_t>(65536, b.max_size() - b.size()));
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b, char delim)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b, char delim,
+    boost::system::error_code& ec)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_STRING_VIEW_PARAM delim)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_STRING_VIEW_PARAM delim, boost::system::error_code& ec)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
+}
+
+#if defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), expr);
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read_until(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    boost::system::error_code& ec)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), expr, ec);
+}
+
+#endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
 template <typename SyncReadStream, typename Allocator, typename MatchCondition>
 inline std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
     typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
-  boost::system::error_code ec;
-  std::size_t bytes_transferred = read_until(s, b, match_condition, ec);
-  boost::asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
+  return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition);
+}
+
+template <typename SyncReadStream, typename Allocator, typename MatchCondition>
+inline std::size_t read_until(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    MatchCondition match_condition, boost::system::error_code& ec,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
+{
+  return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition, ec);
 }
 
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
+
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   class read_until_delim_op
   {
   public:
+    template <typename BufferSequence>
     read_until_delim_op(AsyncReadStream& stream,
-        boost::asio::basic_streambuf<Allocator>& streambuf,
+        BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         char delim, ReadHandler& handler)
       : stream_(stream),
-        streambuf_(streambuf),
+        buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         delim_(delim),
         start_(0),
         search_position_(0),
@@ -345,7 +446,7 @@ namespace detail
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_delim_op(const read_until_delim_op& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         delim_(other.delim_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -355,7 +456,7 @@ namespace detail
 
     read_until_delim_op(read_until_delim_op&& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         delim_(other.delim_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -376,13 +477,13 @@ namespace detail
         {
           {
             // Determine the range of the data to be searched.
-            typedef typename boost::asio::basic_streambuf<
-              Allocator>::const_buffers_type const_buffers_type;
-            typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
-            const_buffers_type buffers = streambuf_.data();
-            iterator begin = iterator::begin(buffers);
+            typedef typename DynamicBuffer::const_buffers_type
+              buffers_type;
+            typedef buffers_iterator<buffers_type> iterator;
+            buffers_type data_buffers = buffers_.data();
+            iterator begin = iterator::begin(data_buffers);
             iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(buffers);
+            iterator end = iterator::end(data_buffers);
 
             // Look for a match.
             iterator iter = std::find(start_pos, end, delim_);
@@ -394,7 +495,7 @@ namespace detail
             }
 
             // No match yet. Check if buffer is full.
-            else if (streambuf_.size() == streambuf_.max_size())
+            else if (buffers_.size() == buffers_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
@@ -405,7 +506,11 @@ namespace detail
             {
               // Next search can start with the new data.
               search_position_ = end - begin;
-              bytes_to_read = read_size_helper(streambuf_, 65536);
+              bytes_to_read = std::min<std::size_t>(
+                    std::max<std::size_t>(512,
+                      buffers_.capacity() - buffers_.size()),
+                    std::min<std::size_t>(65536,
+                      buffers_.max_size() - buffers_.size()));
             }
           }
 
@@ -414,10 +519,10 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+          stream_.async_read_some(buffers_.prepare(bytes_to_read),
               BOOST_ASIO_MOVE_CAST(read_until_delim_op)(*this));
           return; default:
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
@@ -436,97 +541,143 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     char delim_;
     int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline bool asio_handler_is_continuation(
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : boost_asio_handler_cont_helpers::is_continuation(
           this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_delim_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_until_delim_op<AsyncReadStream,
+      DynamicBuffer, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_until_delim_op<AsyncReadStream,
+        DynamicBuffer, ReadHandler>& h,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_until_delim_op<AsyncReadStream,
+      DynamicBuffer, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_until_delim_op<AsyncReadStream,
+        DynamicBuffer, ReadHandler>& h,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
 BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, char delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    char delim, BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
   detail::read_until_delim_op<AsyncReadStream,
-    Allocator, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
-      void (boost::system::error_code, std::size_t))>(
-        s, b, delim, init.handler)(
-          boost::system::error_code(), 0, 1);
+    typename decay<DynamicBuffer>::type,
+      BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+        void (boost::system::error_code, std::size_t))>(
+          s, BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            delim, init.completion_handler)(boost::system::error_code(), 0, 1);
 
   return init.result.get();
 }
 
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   class read_until_delim_string_op
   {
   public:
+    template <typename BufferSequence>
     read_until_delim_string_op(AsyncReadStream& stream,
-        boost::asio::basic_streambuf<Allocator>& streambuf,
+        BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         const std::string& delim, ReadHandler& handler)
       : stream_(stream),
-        streambuf_(streambuf),
+        buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         delim_(delim),
         start_(0),
         search_position_(0),
@@ -537,7 +688,7 @@ namespace detail
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_delim_string_op(const read_until_delim_string_op& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         delim_(other.delim_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -547,7 +698,7 @@ namespace detail
 
     read_until_delim_string_op(read_until_delim_string_op&& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         delim_(BOOST_ASIO_MOVE_CAST(std::string)(other.delim_)),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -568,13 +719,13 @@ namespace detail
         {
           {
             // Determine the range of the data to be searched.
-            typedef typename boost::asio::basic_streambuf<
-              Allocator>::const_buffers_type const_buffers_type;
-            typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
-            const_buffers_type buffers = streambuf_.data();
-            iterator begin = iterator::begin(buffers);
+            typedef typename DynamicBuffer::const_buffers_type
+              buffers_type;
+            typedef buffers_iterator<buffers_type> iterator;
+            buffers_type data_buffers = buffers_.data();
+            iterator begin = iterator::begin(data_buffers);
             iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(buffers);
+            iterator end = iterator::end(data_buffers);
 
             // Look for a match.
             std::pair<iterator, bool> result = detail::partial_search(
@@ -587,7 +738,7 @@ namespace detail
             }
 
             // No match yet. Check if buffer is full.
-            else if (streambuf_.size() == streambuf_.max_size())
+            else if (buffers_.size() == buffers_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
@@ -608,7 +759,11 @@ namespace detail
                 search_position_ = end - begin;
               }
 
-              bytes_to_read = read_size_helper(streambuf_, 65536);
+              bytes_to_read = std::min<std::size_t>(
+                    std::max<std::size_t>(512,
+                      buffers_.capacity() - buffers_.size()),
+                    std::min<std::size_t>(65536,
+                      buffers_.max_size() - buffers_.size()));
             }
           }
 
@@ -617,10 +772,10 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+          stream_.async_read_some(buffers_.prepare(bytes_to_read),
               BOOST_ASIO_MOVE_CAST(read_until_delim_string_op)(*this));
           return; default:
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
@@ -639,35 +794,38 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     std::string delim_;
     int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+  template <typename AsyncReadStream,
+      typename DynamicBuffer, typename ReadHandler>
   inline bool asio_handler_is_continuation(
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : boost_asio_handler_cont_helpers::is_continuation(
@@ -675,64 +833,109 @@ namespace detail
   }
 
   template <typename Function, typename AsyncReadStream,
-      typename Allocator, typename ReadHandler>
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
   template <typename Function, typename AsyncReadStream,
-      typename Allocator, typename ReadHandler>
+      typename DynamicBuffer, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_delim_string_op<AsyncReadStream,
-        Allocator, ReadHandler>* this_handler)
+        DynamicBuffer, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_until_delim_string_op<AsyncReadStream,
+      DynamicBuffer, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_until_delim_string_op<AsyncReadStream,
+        DynamicBuffer, ReadHandler>& h,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_until_delim_string_op<AsyncReadStream,
+      DynamicBuffer, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_until_delim_string_op<AsyncReadStream,
+        DynamicBuffer, ReadHandler>& h,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
 BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    BOOST_ASIO_STRING_VIEW_PARAM delim,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
   detail::read_until_delim_string_op<AsyncReadStream,
-    Allocator, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
-      void (boost::system::error_code, std::size_t))>(
-        s, b, delim, init.handler)(
-          boost::system::error_code(), 0, 1);
+    typename decay<DynamicBuffer>::type,
+      BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+        void (boost::system::error_code, std::size_t))>(
+          s, BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            static_cast<std::string>(delim),
+              init.completion_handler)(boost::system::error_code(), 0, 1);
 
   return init.result.get();
 }
 
+#if !defined(BOOST_ASIO_NO_EXTENSIONS)
 #if defined(BOOST_ASIO_HAS_BOOST_REGEX)
 
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename RegEx, typename ReadHandler>
   class read_until_expr_op
   {
   public:
+    template <typename BufferSequence>
     read_until_expr_op(AsyncReadStream& stream,
-        boost::asio::basic_streambuf<Allocator>& streambuf,
+        BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         const boost::regex& expr, ReadHandler& handler)
       : stream_(stream),
-        streambuf_(streambuf),
+        buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         expr_(expr),
         start_(0),
         search_position_(0),
@@ -743,7 +946,7 @@ namespace detail
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_expr_op(const read_until_expr_op& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         expr_(other.expr_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -753,7 +956,7 @@ namespace detail
 
     read_until_expr_op(read_until_expr_op&& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         expr_(other.expr_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -774,13 +977,13 @@ namespace detail
         {
           {
             // Determine the range of the data to be searched.
-            typedef typename boost::asio::basic_streambuf<
-              Allocator>::const_buffers_type const_buffers_type;
-            typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
-            const_buffers_type buffers = streambuf_.data();
-            iterator begin = iterator::begin(buffers);
+            typedef typename DynamicBuffer::const_buffers_type
+              buffers_type;
+            typedef buffers_iterator<buffers_type> iterator;
+            buffers_type data_buffers = buffers_.data();
+            iterator begin = iterator::begin(data_buffers);
             iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(buffers);
+            iterator end = iterator::end(data_buffers);
 
             // Look for a match.
             boost::match_results<iterator,
@@ -796,7 +999,7 @@ namespace detail
             }
 
             // No match yet. Check if buffer is full.
-            else if (streambuf_.size() == streambuf_.max_size())
+            else if (buffers_.size() == buffers_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
@@ -817,7 +1020,11 @@ namespace detail
                 search_position_ = end - begin;
               }
 
-              bytes_to_read = read_size_helper(streambuf_, 65536);
+              bytes_to_read = std::min<std::size_t>(
+                    std::max<std::size_t>(512,
+                      buffers_.capacity() - buffers_.size()),
+                    std::min<std::size_t>(65536,
+                      buffers_.max_size() - buffers_.size()));
             }
           }
 
@@ -826,10 +1033,10 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+          stream_.async_read_some(buffers_.prepare(bytes_to_read),
               BOOST_ASIO_MOVE_CAST(read_until_expr_op)(*this));
           return; default:
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
@@ -848,85 +1055,127 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     RegEx expr_;
     int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename RegEx, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename RegEx, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename RegEx, typename ReadHandler>
   inline bool asio_handler_is_continuation(
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : boost_asio_handler_cont_helpers::is_continuation(
           this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename RegEx, typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename RegEx, typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename RegEx, typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename RegEx, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_until_expr_op<AsyncReadStream,
-        Allocator, RegEx, ReadHandler>* this_handler)
+        DynamicBuffer, RegEx, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename RegEx, typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_until_expr_op<AsyncReadStream,
+      DynamicBuffer, RegEx, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_until_expr_op<AsyncReadStream,
+        DynamicBuffer, RegEx, ReadHandler>& h,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename RegEx, typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_until_expr_op<AsyncReadStream,
+      DynamicBuffer, RegEx, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_until_expr_op<AsyncReadStream,
+        DynamicBuffer, RegEx, ReadHandler>& h,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream,
+    typename DynamicBuffer, typename ReadHandler>
 BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
+    const boost::regex& expr,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
-  detail::read_until_expr_op<AsyncReadStream, Allocator,
-    boost::regex, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
-      void (boost::system::error_code, std::size_t))>(
-        s, b, expr, init.handler)(
-          boost::system::error_code(), 0, 1);
+  detail::read_until_expr_op<AsyncReadStream,
+    typename decay<DynamicBuffer>::type,
+      boost::regex, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+        void (boost::system::error_code, std::size_t))>(
+          s, BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            expr, init.completion_handler)(boost::system::error_code(), 0, 1);
 
   return init.result.get();
 }
@@ -935,16 +1184,17 @@ async_read_until(AsyncReadStream& s,
 
 namespace detail
 {
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename MatchCondition, typename ReadHandler>
   class read_until_match_op
   {
   public:
+    template <typename BufferSequence>
     read_until_match_op(AsyncReadStream& stream,
-        boost::asio::basic_streambuf<Allocator>& streambuf,
+        BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         MatchCondition match_condition, ReadHandler& handler)
       : stream_(stream),
-        streambuf_(streambuf),
+        buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         match_condition_(match_condition),
         start_(0),
         search_position_(0),
@@ -955,7 +1205,7 @@ namespace detail
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_match_op(const read_until_match_op& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(other.buffers_),
         match_condition_(other.match_condition_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -965,7 +1215,7 @@ namespace detail
 
     read_until_match_op(read_until_match_op&& other)
       : stream_(other.stream_),
-        streambuf_(other.streambuf_),
+        buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)),
         match_condition_(other.match_condition_),
         start_(other.start_),
         search_position_(other.search_position_),
@@ -986,13 +1236,13 @@ namespace detail
         {
           {
             // Determine the range of the data to be searched.
-            typedef typename boost::asio::basic_streambuf<
-              Allocator>::const_buffers_type const_buffers_type;
-            typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
-            const_buffers_type buffers = streambuf_.data();
-            iterator begin = iterator::begin(buffers);
+            typedef typename DynamicBuffer::const_buffers_type
+              buffers_type;
+            typedef buffers_iterator<buffers_type> iterator;
+            buffers_type data_buffers = buffers_.data();
+            iterator begin = iterator::begin(data_buffers);
             iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(buffers);
+            iterator end = iterator::end(data_buffers);
 
             // Look for a match.
             std::pair<iterator, bool> result = match_condition_(start_pos, end);
@@ -1004,7 +1254,7 @@ namespace detail
             }
 
             // No match yet. Check if buffer is full.
-            else if (streambuf_.size() == streambuf_.max_size())
+            else if (buffers_.size() == buffers_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
@@ -1025,7 +1275,11 @@ namespace detail
                 search_position_ = end - begin;
               }
 
-              bytes_to_read = read_size_helper(streambuf_, 65536);
+              bytes_to_read = std::min<std::size_t>(
+                    std::max<std::size_t>(512,
+                      buffers_.capacity() - buffers_.size()),
+                    std::min<std::size_t>(65536,
+                      buffers_.max_size() - buffers_.size()));
             }
           }
 
@@ -1034,10 +1288,10 @@ namespace detail
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
+          stream_.async_read_some(buffers_.prepare(bytes_to_read),
               BOOST_ASIO_MOVE_CAST(read_until_match_op)(*this));
           return; default:
-          streambuf_.commit(bytes_transferred);
+          buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
@@ -1056,71 +1310,113 @@ namespace detail
 
   //private:
     AsyncReadStream& stream_;
-    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    DynamicBuffer buffers_;
     MatchCondition match_condition_;
     int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename MatchCondition, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+        MatchCondition, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename MatchCondition, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+        MatchCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
   }
 
-  template <typename AsyncReadStream, typename Allocator,
+  template <typename AsyncReadStream, typename DynamicBuffer,
       typename MatchCondition, typename ReadHandler>
   inline bool asio_handler_is_continuation(
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+        MatchCondition, ReadHandler>* this_handler)
   {
     return this_handler->start_ == 0 ? true
       : boost_asio_handler_cont_helpers::is_continuation(
           this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename MatchCondition, typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename MatchCondition,
+      typename ReadHandler>
   inline void asio_handler_invoke(Function& function,
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+        MatchCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename MatchCondition, typename ReadHandler>
+  template <typename Function, typename AsyncReadStream,
+      typename DynamicBuffer, typename MatchCondition,
+      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
-      read_until_match_op<AsyncReadStream,
-        Allocator, MatchCondition, ReadHandler>* this_handler)
+      read_until_match_op<AsyncReadStream, DynamicBuffer,
+      MatchCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
 } // namespace detail
 
-template <typename AsyncReadStream, typename Allocator,
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename MatchCondition, typename ReadHandler, typename Allocator>
+struct associated_allocator<
+    detail::read_until_match_op<AsyncReadStream,
+      DynamicBuffer, MatchCondition, ReadHandler>,
+    Allocator>
+{
+  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
+
+  static type get(
+      const detail::read_until_match_op<AsyncReadStream,
+        DynamicBuffer, MatchCondition, ReadHandler>& h,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
+  }
+};
+
+template <typename AsyncReadStream, typename DynamicBuffer,
+    typename MatchCondition, typename ReadHandler, typename Executor>
+struct associated_executor<
+    detail::read_until_match_op<AsyncReadStream,
+      DynamicBuffer, MatchCondition, ReadHandler>,
+    Executor>
+{
+  typedef typename associated_executor<ReadHandler, Executor>::type type;
+
+  static type get(
+      const detail::read_until_match_op<AsyncReadStream,
+        DynamicBuffer, MatchCondition, ReadHandler>& h,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+template <typename AsyncReadStream, typename DynamicBuffer,
     typename MatchCondition, typename ReadHandler>
 BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers,
     MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
     typename enable_if<is_match_condition<MatchCondition>::value>::type*)
 {
@@ -1128,19 +1424,76 @@ async_read_until(AsyncReadStream& s,
   // not meet the documented type requirements for a ReadHandler.
   BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
 
-  detail::async_result_init<
-    ReadHandler, void (boost::system::error_code, std::size_t)> init(
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+  async_completion<ReadHandler,
+    void (boost::system::error_code, std::size_t)> init(handler);
 
-  detail::read_until_match_op<AsyncReadStream, Allocator,
-    MatchCondition, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
-      void (boost::system::error_code, std::size_t))>(
-        s, b, match_condition, init.handler)(
-          boost::system::error_code(), 0, 1);
+  detail::read_until_match_op<AsyncReadStream,
+    typename decay<DynamicBuffer>::type,
+      MatchCondition, BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+        void (boost::system::error_code, std::size_t))>(
+          s, BOOST_ASIO_MOVE_CAST(DynamicBuffer)(buffers),
+            match_condition, init.completion_handler)(
+              boost::system::error_code(), 0, 1);
 
   return init.result.get();
 }
 
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
+
+template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    char delim, BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
+      delim, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_STRING_VIEW_PARAM delim,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
+      delim, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+#if defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
+template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
+      expr, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+#endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
+template <typename AsyncReadStream, typename Allocator,
+    typename MatchCondition, typename ReadHandler>
+inline BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_until(AsyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
+{
+  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
+      match_condition, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+}
+
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
+
 } // namespace asio
 } // namespace boost