passenger 6.0.6 → 6.0.22

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

@@ -2,7 +2,7 @@
 // buffer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -23,9 +23,11 @@
 #include <string>
 #include <vector>
 #include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/string_view.hpp>
 #include <boost/asio/detail/throw_exception.hpp>
 #include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/is_contiguous_iterator.hpp>
 
 #if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1700)
 # if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0)
@@ -47,19 +49,6 @@
 # include <boost/asio/detail/functional.hpp>
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
-#if defined(BOOST_ASIO_HAS_BOOST_WORKAROUND)
-# include <boost/detail/workaround.hpp>
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \
-    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-#  define BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND
-# endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-        // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-#endif // defined(BOOST_ASIO_HAS_BOOST_WORKAROUND)
-
-#if defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
-# include <boost/asio/detail/type_traits.hpp>
-#endif // defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
-
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -91,14 +80,14 @@ class mutable_buffer
 {
 public:
   /// Construct an empty buffer.
-  mutable_buffer() BOOST_ASIO_NOEXCEPT
+  mutable_buffer() noexcept
     : data_(0),
       size_(0)
   {
   }
 
   /// Construct a buffer to represent a given memory range.
-  mutable_buffer(void* data, std::size_t size) BOOST_ASIO_NOEXCEPT
+  mutable_buffer(void* data, std::size_t size) noexcept
     : data_(data),
       size_(size)
   {
@@ -120,7 +109,7 @@ public:
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
   /// Get a pointer to the beginning of the memory range.
-  void* data() const BOOST_ASIO_NOEXCEPT
+  void* data() const noexcept
   {
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     if (size_ && debug_check_)
@@ -130,13 +119,13 @@ public:
   }
 
   /// Get the size of the memory range.
-  std::size_t size() const BOOST_ASIO_NOEXCEPT
+  std::size_t size() const noexcept
   {
     return size_;
   }
 
   /// Move the start of the buffer by the specified number of bytes.
-  mutable_buffer& operator+=(std::size_t n) BOOST_ASIO_NOEXCEPT
+  mutable_buffer& operator+=(std::size_t n) noexcept
   {
     std::size_t offset = n < size_ ? n : size_;
     data_ = static_cast<char*>(data_) + offset;
@@ -168,7 +157,7 @@ public:
   typedef const mutable_buffer* const_iterator;
 
   /// Construct to represent a given memory range.
-  mutable_buffers_1(void* data, std::size_t size) BOOST_ASIO_NOEXCEPT
+  mutable_buffers_1(void* data, std::size_t size) noexcept
     : mutable_buffer(data, size)
   {
   }
@@ -182,19 +171,19 @@ public:
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
   /// Construct to represent a single modifiable buffer.
-  explicit mutable_buffers_1(const mutable_buffer& b) BOOST_ASIO_NOEXCEPT
+  explicit mutable_buffers_1(const mutable_buffer& b) noexcept
     : mutable_buffer(b)
   {
   }
 
   /// Get a random-access iterator to the first element.
-  const_iterator begin() const BOOST_ASIO_NOEXCEPT
+  const_iterator begin() const noexcept
   {
     return this;
   }
 
   /// Get a random-access iterator for one past the last element.
-  const_iterator end() const BOOST_ASIO_NOEXCEPT
+  const_iterator end() const noexcept
   {
     return begin() + 1;
   }
@@ -225,21 +214,21 @@ class const_buffer
 {
 public:
   /// Construct an empty buffer.
-  const_buffer() BOOST_ASIO_NOEXCEPT
+  const_buffer() noexcept
     : data_(0),
       size_(0)
   {
   }
 
   /// Construct a buffer to represent a given memory range.
-  const_buffer(const void* data, std::size_t size) BOOST_ASIO_NOEXCEPT
+  const_buffer(const void* data, std::size_t size) noexcept
     : data_(data),
       size_(size)
   {
   }
 
   /// Construct a non-modifiable buffer from a modifiable one.
-  const_buffer(const mutable_buffer& b) BOOST_ASIO_NOEXCEPT
+  const_buffer(const mutable_buffer& b) noexcept
     : data_(b.data()),
       size_(b.size())
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
@@ -264,7 +253,7 @@ public:
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
   /// Get a pointer to the beginning of the memory range.
-  const void* data() const BOOST_ASIO_NOEXCEPT
+  const void* data() const noexcept
   {
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     if (size_ && debug_check_)
@@ -274,13 +263,13 @@ public:
   }
 
   /// Get the size of the memory range.
-  std::size_t size() const BOOST_ASIO_NOEXCEPT
+  std::size_t size() const noexcept
   {
     return size_;
   }
 
   /// Move the start of the buffer by the specified number of bytes.
-  const_buffer& operator+=(std::size_t n) BOOST_ASIO_NOEXCEPT
+  const_buffer& operator+=(std::size_t n) noexcept
   {
     std::size_t offset = n < size_ ? n : size_;
     data_ = static_cast<const char*>(data_) + offset;
@@ -312,7 +301,7 @@ public:
   typedef const const_buffer* const_iterator;
 
   /// Construct to represent a given memory range.
-  const_buffers_1(const void* data, std::size_t size) BOOST_ASIO_NOEXCEPT
+  const_buffers_1(const void* data, std::size_t size) noexcept
     : const_buffer(data, size)
   {
   }
@@ -326,19 +315,19 @@ public:
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
   /// Construct to represent a single non-modifiable buffer.
-  explicit const_buffers_1(const const_buffer& b) BOOST_ASIO_NOEXCEPT
+  explicit const_buffers_1(const const_buffer& b) noexcept
     : const_buffer(b)
   {
   }
 
   /// Get a random-access iterator to the first element.
-  const_iterator begin() const BOOST_ASIO_NOEXCEPT
+  const_iterator begin() const noexcept
   {
     return this;
   }
 
   /// Get a random-access iterator for one past the last element.
-  const_iterator end() const BOOST_ASIO_NOEXCEPT
+  const_iterator end() const noexcept
   {
     return begin() + 1;
   }
@@ -359,13 +348,13 @@ public:
   typedef const mutable_buffer* const_iterator;
 
   /// Get a random-access iterator to the first element.
-  const_iterator begin() const BOOST_ASIO_NOEXCEPT
+  const_iterator begin() const noexcept
   {
     return &buf_;
   }
 
   /// Get a random-access iterator for one past the last element.
-  const_iterator end() const BOOST_ASIO_NOEXCEPT
+  const_iterator end() const noexcept
   {
     return &buf_;
   }
@@ -382,49 +371,47 @@ private:
 /*@{*/
 
 /// Get an iterator to the first element in a buffer sequence.
-inline const mutable_buffer* buffer_sequence_begin(const mutable_buffer& b)
+template <typename MutableBuffer>
+inline const mutable_buffer* buffer_sequence_begin(const MutableBuffer& b,
+    constraint_t<
+      is_convertible<const MutableBuffer*, const mutable_buffer*>::value
+    > = 0) noexcept
 {
-  return &b;
+  return static_cast<const mutable_buffer*>(detail::addressof(b));
 }
 
 /// Get an iterator to the first element in a buffer sequence.
-inline const const_buffer* buffer_sequence_begin(const const_buffer& b)
+template <typename ConstBuffer>
+inline const const_buffer* buffer_sequence_begin(const ConstBuffer& b,
+    constraint_t<
+      is_convertible<const ConstBuffer*, const const_buffer*>::value
+    > = 0) noexcept
 {
-  return &b;
+  return static_cast<const const_buffer*>(detail::addressof(b));
 }
 
-#if defined(BOOST_ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
-
 /// Get an iterator to the first element in a buffer sequence.
 template <typename C>
-inline auto buffer_sequence_begin(C& c) -> decltype(c.begin())
+inline auto buffer_sequence_begin(C& c,
+    constraint_t<
+      !is_convertible<const C*, const mutable_buffer*>::value
+        && !is_convertible<const C*, const const_buffer*>::value
+    > = 0) noexcept -> decltype(c.begin())
 {
   return c.begin();
 }
 
 /// Get an iterator to the first element in a buffer sequence.
 template <typename C>
-inline auto buffer_sequence_begin(const C& c) -> decltype(c.begin())
-{
-  return c.begin();
-}
-
-#else // defined(BOOST_ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
-
-template <typename C>
-inline typename C::iterator buffer_sequence_begin(C& c)
+inline auto buffer_sequence_begin(const C& c,
+    constraint_t<
+      !is_convertible<const C*, const mutable_buffer*>::value
+        && !is_convertible<const C*, const const_buffer*>::value
+    > = 0) noexcept -> decltype(c.begin())
 {
   return c.begin();
 }
 
-template <typename C>
-inline typename C::const_iterator buffer_sequence_begin(const C& c)
-{
-  return c.begin();
-}
-
-#endif // defined(BOOST_ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
-
 /*@}*/
 
 /** @defgroup buffer_sequence_end boost::asio::buffer_sequence_end
@@ -435,49 +422,47 @@ inline typename C::const_iterator buffer_sequence_begin(const C& c)
 /*@{*/
 
 /// Get an iterator to one past the end element in a buffer sequence.
-inline const mutable_buffer* buffer_sequence_end(const mutable_buffer& b)
+template <typename MutableBuffer>
+inline const mutable_buffer* buffer_sequence_end(const MutableBuffer& b,
+    constraint_t<
+      is_convertible<const MutableBuffer*, const mutable_buffer*>::value
+    > = 0) noexcept
 {
-  return &b + 1;
+  return static_cast<const mutable_buffer*>(detail::addressof(b)) + 1;
 }
 
 /// Get an iterator to one past the end element in a buffer sequence.
-inline const const_buffer* buffer_sequence_end(const const_buffer& b)
+template <typename ConstBuffer>
+inline const const_buffer* buffer_sequence_end(const ConstBuffer& b,
+    constraint_t<
+      is_convertible<const ConstBuffer*, const const_buffer*>::value
+    > = 0) noexcept
 {
-  return &b + 1;
+  return static_cast<const const_buffer*>(detail::addressof(b)) + 1;
 }
 
-#if defined(BOOST_ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
-
 /// Get an iterator to one past the end element in a buffer sequence.
 template <typename C>
-inline auto buffer_sequence_end(C& c) -> decltype(c.end())
+inline auto buffer_sequence_end(C& c,
+    constraint_t<
+      !is_convertible<const C*, const mutable_buffer*>::value
+        && !is_convertible<const C*, const const_buffer*>::value
+    > = 0) noexcept -> decltype(c.end())
 {
   return c.end();
 }
 
 /// Get an iterator to one past the end element in a buffer sequence.
 template <typename C>
-inline auto buffer_sequence_end(const C& c) -> decltype(c.end())
-{
-  return c.end();
-}
-
-#else // defined(BOOST_ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
-
-template <typename C>
-inline typename C::iterator buffer_sequence_end(C& c)
-{
-  return c.end();
-}
-
-template <typename C>
-inline typename C::const_iterator buffer_sequence_end(const C& c)
+inline auto buffer_sequence_end(const C& c,
+    constraint_t<
+      !is_convertible<const C*, const mutable_buffer*>::value
+        && !is_convertible<const C*, const const_buffer*>::value
+    > = 0) noexcept -> decltype(c.end())
 {
   return c.end();
 }
 
-#endif // defined(BOOST_ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)
-
 /*@}*/
 
 namespace detail {
@@ -489,25 +474,25 @@ struct multiple_buffers {};
 // Helper trait to detect single buffers.
 template <typename BufferSequence>
 struct buffer_sequence_cardinality :
-  conditional<
+  conditional_t<
     is_same<BufferSequence, mutable_buffer>::value
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
       || is_same<BufferSequence, mutable_buffers_1>::value
       || is_same<BufferSequence, const_buffers_1>::value
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
       || is_same<BufferSequence, const_buffer>::value,
-    one_buffer, multiple_buffers>::type {};
+    one_buffer, multiple_buffers> {};
 
 template <typename Iterator>
 inline std::size_t buffer_size(one_buffer,
-    Iterator begin, Iterator) BOOST_ASIO_NOEXCEPT
+    Iterator begin, Iterator) noexcept
 {
   return const_buffer(*begin).size();
 }
 
 template <typename Iterator>
 inline std::size_t buffer_size(multiple_buffers,
-    Iterator begin, Iterator end) BOOST_ASIO_NOEXCEPT
+    Iterator begin, Iterator end) noexcept
 {
   std::size_t total_buffer_size = 0;
 
@@ -542,7 +527,7 @@ inline std::size_t buffer_size(multiple_buffers,
  * ConstBufferSequence or @c MutableBufferSequence type requirements.
  */
 template <typename BufferSequence>
-inline std::size_t buffer_size(const BufferSequence& b) BOOST_ASIO_NOEXCEPT
+inline std::size_t buffer_size(const BufferSequence& b) noexcept
 {
   return detail::buffer_size(
       detail::buffer_sequence_cardinality<BufferSequence>(),
@@ -577,14 +562,14 @@ inline std::size_t buffer_size(const BufferSequence& b) BOOST_ASIO_NOEXCEPT
 
 /// Cast a non-modifiable buffer to a specified pointer to POD type.
 template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const mutable_buffer& b) BOOST_ASIO_NOEXCEPT
+inline PointerToPodType buffer_cast(const mutable_buffer& b) noexcept
 {
   return static_cast<PointerToPodType>(b.data());
 }
 
 /// Cast a non-modifiable buffer to a specified pointer to POD type.
 template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const const_buffer& b) BOOST_ASIO_NOEXCEPT
+inline PointerToPodType buffer_cast(const const_buffer& b) noexcept
 {
   return static_cast<PointerToPodType>(b.data());
 }
@@ -598,7 +583,7 @@ inline PointerToPodType buffer_cast(const const_buffer& b) BOOST_ASIO_NOEXCEPT
  * @relates mutable_buffer
  */
 inline mutable_buffer operator+(const mutable_buffer& b,
-    std::size_t n) BOOST_ASIO_NOEXCEPT
+    std::size_t n) noexcept
 {
   std::size_t offset = n < b.size() ? n : b.size();
   char* new_data = static_cast<char*>(b.data()) + offset;
@@ -615,7 +600,7 @@ inline mutable_buffer operator+(const mutable_buffer& b,
  * @relates mutable_buffer
  */
 inline mutable_buffer operator+(std::size_t n,
-    const mutable_buffer& b) BOOST_ASIO_NOEXCEPT
+    const mutable_buffer& b) noexcept
 {
   return b + n;
 }
@@ -625,7 +610,7 @@ inline mutable_buffer operator+(std::size_t n,
  * @relates const_buffer
  */
 inline const_buffer operator+(const const_buffer& b,
-    std::size_t n) BOOST_ASIO_NOEXCEPT
+    std::size_t n) noexcept
 {
   std::size_t offset = n < b.size() ? n : b.size();
   const char* new_data = static_cast<const char*>(b.data()) + offset;
@@ -642,7 +627,7 @@ inline const_buffer operator+(const const_buffer& b,
  * @relates const_buffer
  */
 inline const_buffer operator+(std::size_t n,
-    const const_buffer& b) BOOST_ASIO_NOEXCEPT
+    const const_buffer& b) noexcept
 {
   return b + n;
 }
@@ -841,6 +826,25 @@ private:
  * bufs2.push_back(boost::asio::buffer(d2));
  * bufs2.push_back(boost::asio::buffer(d3));
  * bytes_transferred = sock.send(bufs2); @endcode
+ *
+ * @par Buffer Literals
+ *
+ * The `_buf` literal suffix, defined in namespace
+ * <tt>boost::asio::buffer_literals</tt>, may be used to create @c const_buffer
+ * objects from string, binary integer, and hexadecimal integer literals.
+ * For example:
+ *
+ * @code
+ * using namespace boost::asio::buffer_literals;
+ *
+ * boost::asio::const_buffer b1 = "hello"_buf;
+ * boost::asio::const_buffer b2 = 0xdeadbeef_buf;
+ * boost::asio::const_buffer b3 = 0x0123456789abcdef0123456789abcdef_buf;
+ * boost::asio::const_buffer b4 = 0b1010101011001100_buf; @endcode
+ *
+ * Note that the memory associated with a buffer literal is valid for the
+ * lifetime of the program. This means that the buffer can be safely used with
+ * asynchronous operations.
  */
 /*@{*/
 
@@ -856,8 +860,8 @@ private:
 /**
  * @returns <tt>mutable_buffer(b)</tt>.
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
-    const mutable_buffer& b) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    const mutable_buffer& b) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(b);
 }
@@ -869,8 +873,9 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     b.data(),
  *     min(b.size(), max_size_in_bytes)); @endcode
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    const mutable_buffer& b,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
       mutable_buffer(b.data(),
@@ -886,8 +891,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
 /**
  * @returns <tt>const_buffer(b)</tt>.
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    const const_buffer& b) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const const_buffer& b) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(b);
 }
@@ -899,8 +904,9 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     b.data(),
  *     min(b.size(), max_size_in_bytes)); @endcode
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(const const_buffer& b,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const const_buffer& b,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(b.data(),
       b.size() < max_size_in_bytes
@@ -915,8 +921,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const const_buffer& b,
 /**
  * @returns <tt>mutable_buffer(data, size_in_bytes)</tt>.
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(void* data,
-    std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    void* data, std::size_t size_in_bytes) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data, size_in_bytes);
 }
@@ -925,8 +931,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(void* data,
 /**
  * @returns <tt>const_buffer(data, size_in_bytes)</tt>.
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(const void* data,
-    std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const void* data, std::size_t size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data, size_in_bytes);
 }
@@ -939,11 +945,12 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const void* data,
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    PodType (&data)[N]) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data, N * sizeof(PodType));
 }
- 
+
 /// Create a new modifiable buffer that represents the given POD array.
 /**
  * @returns A mutable_buffer value equivalent to:
@@ -952,14 +959,15 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    PodType (&data)[N],
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data,
       N * sizeof(PodType) < max_size_in_bytes
       ? N * sizeof(PodType) : max_size_in_bytes);
 }
- 
+
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
  * @returns A const_buffer value equivalent to:
@@ -968,8 +976,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    const PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const PodType (&data)[N]) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data, N * sizeof(PodType));
 }
@@ -982,84 +990,15 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const PodType (&data)[N],
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const PodType (&data)[N],
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data,
       N * sizeof(PodType) < max_size_in_bytes
       ? N * sizeof(PodType) : max_size_in_bytes);
 }
 
-#if defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
-
-// Borland C++ and Sun Studio think the overloads:
-//
-//   unspecified buffer(boost::array<PodType, N>& array ...);
-//
-// and
-//
-//   unspecified buffer(boost::array<const PodType, N>& array ...);
-//
-// are ambiguous. This will be worked around by using a buffer_types traits
-// class that contains typedefs for the appropriate buffer and container
-// classes, based on whether PodType is const or non-const.
-
-namespace detail {
-
-template <bool IsConst>
-struct buffer_types_base;
-
-template <>
-struct buffer_types_base<false>
-{
-  typedef mutable_buffer buffer_type;
-  typedef BOOST_ASIO_MUTABLE_BUFFER container_type;
-};
-
-template <>
-struct buffer_types_base<true>
-{
-  typedef const_buffer buffer_type;
-  typedef BOOST_ASIO_CONST_BUFFER container_type;
-};
-
-template <typename PodType>
-struct buffer_types
-  : public buffer_types_base<is_const<PodType>::value>
-{
-};
-
-} // namespace detail
-
-template <typename PodType, std::size_t N>
-inline typename detail::buffer_types<PodType>::container_type
-buffer(boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
-{
-  typedef typename boost::asio::detail::buffer_types<PodType>::buffer_type
-    buffer_type;
-  typedef typename boost::asio::detail::buffer_types<PodType>::container_type
-    container_type;
-  return container_type(
-      buffer_type(data.c_array(), data.size() * sizeof(PodType)));
-}
-
-template <typename PodType, std::size_t N>
-inline typename detail::buffer_types<PodType>::container_type
-buffer(boost::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
-{
-  typedef typename boost::asio::detail::buffer_types<PodType>::buffer_type
-    buffer_type;
-  typedef typename boost::asio::detail::buffer_types<PodType>::container_type
-    container_type;
-  return container_type(
-      buffer_type(data.c_array(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
-}
-
-#else // defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
-
 /// Create a new modifiable buffer that represents the given POD array.
 /**
  * @returns A mutable_buffer value equivalent to:
@@ -1068,8 +1007,8 @@ buffer(boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
-    boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    boost::array<PodType, N>& data) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
       data.c_array(), data.size() * sizeof(PodType));
@@ -1083,8 +1022,9 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    boost::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.c_array(),
       data.size() * sizeof(PodType) < max_size_in_bytes
@@ -1099,8 +1039,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    boost::array<const PodType, N>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    boost::array<const PodType, N>& data) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
 }
@@ -1113,16 +1053,15 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    boost::array<const PodType, N>& data,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
       data.size() * sizeof(PodType) < max_size_in_bytes
       ? data.size() * sizeof(PodType) : max_size_in_bytes);
 }
 
-#endif // defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
-
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
  * @returns A const_buffer value equivalent to:
@@ -1131,8 +1070,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    const boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const boost::array<PodType, N>& data) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
 }
@@ -1145,16 +1084,15 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const boost::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
       data.size() * sizeof(PodType) < max_size_in_bytes
       ? data.size() * sizeof(PodType) : max_size_in_bytes);
 }
 
-#if defined(BOOST_ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)
-
 /// Create a new modifiable buffer that represents the given POD array.
 /**
  * @returns A mutable_buffer value equivalent to:
@@ -1163,8 +1101,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
-    std::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::array<PodType, N>& data) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.data(), data.size() * sizeof(PodType));
 }
@@ -1177,8 +1115,9 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.data(),
       data.size() * sizeof(PodType) < max_size_in_bytes
@@ -1193,8 +1132,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    std::array<const PodType, N>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    std::array<const PodType, N>& data) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
 }
@@ -1207,8 +1146,9 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    std::array<const PodType, N>& data,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
       data.size() * sizeof(PodType) < max_size_in_bytes
@@ -1223,8 +1163,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    const std::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const std::array<PodType, N>& data) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
 }
@@ -1237,16 +1177,15 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const std::array<PodType, N>& data,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
       data.size() * sizeof(PodType) < max_size_in_bytes
       ? data.size() * sizeof(PodType) : max_size_in_bytes);
 }
 
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)
-
 /// Create a new modifiable buffer that represents the given POD vector.
 /**
  * @returns A mutable_buffer value equivalent to:
@@ -1258,8 +1197,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
-    std::vector<PodType, Allocator>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::vector<PodType, Allocator>& data) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
       data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
@@ -1282,8 +1221,9 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::vector<PodType, Allocator>& data,
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
       data.size() * sizeof(PodType) < max_size_in_bytes
@@ -1307,8 +1247,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    const std::vector<PodType, Allocator>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const std::vector<PodType, Allocator>& data) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(
       data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
@@ -1331,9 +1271,9 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::vector<PodType, Allocator>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
       data.size() * sizeof(PodType) < max_size_in_bytes
@@ -1355,8 +1295,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
-    std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::basic_string<Elem, Traits, Allocator>& data) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
       data.size() * sizeof(Elem)
@@ -1379,9 +1319,9 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::basic_string<Elem, Traits, Allocator>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
       data.size() * sizeof(Elem) < max_size_in_bytes
@@ -1402,8 +1342,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    const std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const std::basic_string<Elem, Traits, Allocator>& data) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(Elem)
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
@@ -1425,9 +1365,9 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::basic_string<Elem, Traits, Allocator>& data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
       data.size() * sizeof(Elem) < max_size_in_bytes
@@ -1443,14 +1383,14 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
 #if defined(BOOST_ASIO_HAS_STRING_VIEW) \
   || defined(GENERATING_DOCUMENTATION)
 
-/// Create a new modifiable buffer that represents the given string_view.
+/// Create a new non-modifiable buffer that represents the given string_view.
 /**
  * @returns <tt>mutable_buffer(data.size() ? &data[0] : 0,
  * data.size() * sizeof(Elem))</tt>.
  */
 template <typename Elem, typename Traits>
-inline BOOST_ASIO_CONST_BUFFER buffer(
-    basic_string_view<Elem, Traits> data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    basic_string_view<Elem, Traits> data) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
       data.size() * sizeof(Elem)
@@ -1470,9 +1410,9 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
  */
 template <typename Elem, typename Traits>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     basic_string_view<Elem, Traits> data,
-    std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
+    std::size_t max_size_in_bytes) noexcept
 {
   return BOOST_ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
       data.size() * sizeof(Elem) < max_size_in_bytes
@@ -1488,6 +1428,215 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
 #endif // defined(BOOST_ASIO_HAS_STRING_VIEW)
        //  || defined(GENERATING_DOCUMENTATION)
 
+/// Create a new modifiable buffer from a contiguous container.
+/**
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     data.size() * sizeof(typename T::value_type)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    T& data,
+    constraint_t<
+      is_contiguous_iterator<typename T::iterator>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_const<
+        remove_reference_t<
+          typename std::iterator_traits<typename T::iterator>::reference
+        >
+      >::value,
+      defaulted_constraint
+    > = defaulted_constraint()) noexcept
+{
+  return BOOST_ASIO_MUTABLE_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type));
+}
+
+/// Create a new modifiable buffer from a contiguous container.
+/**
+ * @returns A mutable_buffer value equivalent to:
+ * @code mutable_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     min(
+ *       data.size() * sizeof(typename T::value_type),
+ *       max_size_in_bytes)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    T& data, std::size_t max_size_in_bytes,
+    constraint_t<
+      is_contiguous_iterator<typename T::iterator>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_const<
+        remove_reference_t<
+          typename std::iterator_traits<typename T::iterator>::reference
+        >
+      >::value,
+      defaulted_constraint
+    > = defaulted_constraint()) noexcept
+{
+  return BOOST_ASIO_MUTABLE_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
+      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
+}
+
+/// Create a new non-modifiable buffer from a contiguous container.
+/**
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     data.size() * sizeof(typename T::value_type)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    T& data,
+    constraint_t<
+      is_contiguous_iterator<typename T::iterator>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      is_const<
+        remove_reference_t<
+          typename std::iterator_traits<typename T::iterator>::reference
+        >
+      >::value,
+      defaulted_constraint
+    > = defaulted_constraint()) noexcept
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type));
+}
+
+/// Create a new non-modifiable buffer from a contiguous container.
+/**
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     min(
+ *       data.size() * sizeof(typename T::value_type),
+ *       max_size_in_bytes)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    T& data, std::size_t max_size_in_bytes,
+    constraint_t<
+      is_contiguous_iterator<typename T::iterator>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      is_const<
+        remove_reference_t<
+          typename std::iterator_traits<typename T::iterator>::reference
+        >
+      >::value,
+      defaulted_constraint
+    > = defaulted_constraint()) noexcept
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
+      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
+}
+
+/// Create a new non-modifiable buffer from a contiguous container.
+/**
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     data.size() * sizeof(typename T::value_type)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const T& data,
+    constraint_t<
+      is_contiguous_iterator<typename T::const_iterator>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint()) noexcept
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type));
+}
+
+/// Create a new non-modifiable buffer from a contiguous container.
+/**
+ * @returns A const_buffer value equivalent to:
+ * @code const_buffer(
+ *     data.size() ? &data[0] : 0,
+ *     min(
+ *       data.size() * sizeof(typename T::value_type),
+ *       max_size_in_bytes)); @endcode
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const T& data, std::size_t max_size_in_bytes,
+    constraint_t<
+      is_contiguous_iterator<typename T::const_iterator>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, const_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint(),
+    constraint_t<
+      !is_convertible<T, mutable_buffer>::value,
+      defaulted_constraint
+    > = defaulted_constraint()) noexcept
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      data.size() ? detail::to_address(data.begin()) : 0,
+      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
+      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
+}
+
 /*@}*/
 
 /// Adapt a basic_string to the DynamicBuffer requirements.
@@ -1498,84 +1647,153 @@ template <typename Elem, typename Traits, typename Allocator>
 class dynamic_string_buffer
 {
 public:
-  /// The type used to represent the input sequence as a list of buffers.
+  /// The type used to represent a sequence of constant buffers that refers to
+  /// the underlying memory.
   typedef BOOST_ASIO_CONST_BUFFER const_buffers_type;
 
-  /// The type used to represent the output sequence as a list of buffers.
+  /// The type used to represent a sequence of mutable buffers that refers to
+  /// the underlying memory.
   typedef BOOST_ASIO_MUTABLE_BUFFER mutable_buffers_type;
 
   /// Construct a dynamic buffer from a string.
   /**
    * @param s The string to be used as backing storage for the dynamic buffer.
-   * Any existing data in the string is treated as the dynamic buffer's input
-   * sequence. The object stores a reference to the string and the user is
-   * responsible for ensuring that the string object remains valid until the
-   * dynamic_string_buffer object is destroyed.
+   * The object stores a reference to the string and the user is responsible
+   * for ensuring that the string object remains valid while the
+   * dynamic_string_buffer object, and copies of the object, are in use.
+   *
+   * @b DynamicBuffer_v1: Any existing data in the string is treated as the
+   * dynamic buffer's input sequence.
    *
    * @param maximum_size Specifies a maximum size for the buffer, in bytes.
    */
   explicit dynamic_string_buffer(std::basic_string<Elem, Traits, Allocator>& s,
       std::size_t maximum_size =
-        (std::numeric_limits<std::size_t>::max)()) BOOST_ASIO_NOEXCEPT
+        (std::numeric_limits<std::size_t>::max)()) noexcept
     : string_(s),
-      size_(string_.size()),
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+      size_((std::numeric_limits<std::size_t>::max)()),
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
       max_size_(maximum_size)
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// @b DynamicBuffer_v2: Copy construct a dynamic buffer.
+  dynamic_string_buffer(const dynamic_string_buffer& other) noexcept
+    : string_(other.string_),
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+      size_(other.size_),
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+      max_size_(other.max_size_)
+  {
+  }
+
   /// Move construct a dynamic buffer.
-  dynamic_string_buffer(dynamic_string_buffer&& other) BOOST_ASIO_NOEXCEPT
+  dynamic_string_buffer(dynamic_string_buffer&& other) noexcept
     : string_(other.string_),
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
       size_(other.size_),
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
       max_size_(other.max_size_)
   {
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
-  /// Get the size of the input sequence.
-  std::size_t size() const BOOST_ASIO_NOEXCEPT
+  /// @b DynamicBuffer_v1: Get the size of the input sequence.
+  /// @b DynamicBuffer_v2: Get the current size of the underlying memory.
+  /**
+   * @returns @b DynamicBuffer_v1 The current size of the input sequence.
+   * @b DynamicBuffer_v2: The current size of the underlying string if less than
+   * max_size(). Otherwise returns max_size().
+   */
+  std::size_t size() const noexcept
   {
-    return size_;
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+    if (size_ != (std::numeric_limits<std::size_t>::max)())
+      return size_;
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+    return (std::min)(string_.size(), max_size());
   }
 
   /// Get the maximum size of the dynamic buffer.
   /**
-   * @returns The allowed maximum of the sum of the sizes of the input sequence
-   * and output sequence.
+   * @returns The allowed maximum size of the underlying memory.
    */
-  std::size_t max_size() const BOOST_ASIO_NOEXCEPT
+  std::size_t max_size() const noexcept
   {
     return max_size_;
   }
 
-  /// Get the current capacity of the dynamic buffer.
+  /// Get the maximum size that the buffer may grow to without triggering
+  /// reallocation.
   /**
-   * @returns The current total capacity of the buffer, i.e. for both the input
-   * sequence and output sequence.
+   * @returns The current capacity of the underlying string if less than
+   * max_size(). Otherwise returns max_size().
    */
-  std::size_t capacity() const BOOST_ASIO_NOEXCEPT
+  std::size_t capacity() const noexcept
   {
-    return string_.capacity();
+    return (std::min)(string_.capacity(), max_size());
   }
 
-  /// Get a list of buffers that represents the input sequence.
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+  /// @b DynamicBuffer_v1: Get a list of buffers that represents the input
+  /// sequence.
   /**
    * @returns An object of type @c const_buffers_type that satisfies
    * ConstBufferSequence requirements, representing the basic_string memory in
-   * input sequence.
+   * the input sequence.
    *
    * @note The returned object is invalidated by any @c dynamic_string_buffer
-   * or @c basic_string member function that modifies the input sequence or
-   * output sequence.
+   * or @c basic_string member function that resizes or erases the string.
    */
-  const_buffers_type data() const BOOST_ASIO_NOEXCEPT
+  const_buffers_type data() const noexcept
   {
     return const_buffers_type(boost::asio::buffer(string_, size_));
   }
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+
+  /// @b DynamicBuffer_v2: Get a sequence of buffers that represents the
+  /// underlying memory.
+  /**
+   * @param pos Position of the first byte to represent in the buffer sequence
+   *
+   * @param n The number of bytes to return in the buffer sequence. If the
+   * underlying memory is shorter, the buffer sequence represents as many bytes
+   * as are available.
+   *
+   * @returns An object of type @c mutable_buffers_type that satisfies
+   * MutableBufferSequence requirements, representing the basic_string memory.
+   *
+   * @note The returned object is invalidated by any @c dynamic_string_buffer
+   * or @c basic_string member function that resizes or erases the string.
+   */
+  mutable_buffers_type data(std::size_t pos, std::size_t n) noexcept
+  {
+    return mutable_buffers_type(boost::asio::buffer(
+          boost::asio::buffer(string_, max_size_) + pos, n));
+  }
+
+  /// @b DynamicBuffer_v2: Get a sequence of buffers that represents the
+  /// underlying memory.
+  /**
+   * @param pos Position of the first byte to represent in the buffer sequence
+   *
+   * @param n The number of bytes to return in the buffer sequence. If the
+   * underlying memory is shorter, the buffer sequence represents as many bytes
+   * as are available.
+   *
+   * @note The returned object is invalidated by any @c dynamic_string_buffer
+   * or @c basic_string member function that resizes or erases the string.
+   */
+  const_buffers_type data(std::size_t pos,
+      std::size_t n) const noexcept
+  {
+    return const_buffers_type(boost::asio::buffer(
+          boost::asio::buffer(string_, max_size_) + pos, n));
+  }
 
-  /// Get a list of buffers that represents the output sequence, with the given
-  /// size.
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+  /// @b DynamicBuffer_v1: Get a list of buffers that represents the output
+  /// sequence, with the given size.
   /**
    * Ensures that the output sequence can accommodate @c n bytes, resizing the
    * basic_string object as necessary.
@@ -1592,18 +1810,22 @@ public:
    */
   mutable_buffers_type prepare(std::size_t n)
   {
-    if (size () > max_size() || max_size() - size() < n)
+    if (size() > max_size() || max_size() - size() < n)
     {
       std::length_error ex("dynamic_string_buffer too long");
       boost::asio::detail::throw_exception(ex);
     }
 
+    if (size_ == (std::numeric_limits<std::size_t>::max)())
+      size_ = string_.size(); // Enable v1 behaviour.
+
     string_.resize(size_ + n);
 
     return boost::asio::buffer(boost::asio::buffer(string_) + size_, n);
   }
 
-  /// Move bytes from the output sequence to the input sequence.
+  /// @b DynamicBuffer_v1: Move bytes from the output sequence to the input
+  /// sequence.
   /**
    * @param n The number of bytes to append from the start of the output
    * sequence to the end of the input sequence. The remainder of the output
@@ -1620,24 +1842,69 @@ public:
     size_ += (std::min)(n, string_.size() - size_);
     string_.resize(size_);
   }
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+
+  /// @b DynamicBuffer_v2: Grow the underlying memory by the specified number of
+  /// bytes.
+  /**
+   * Resizes the string to accommodate an additional @c n bytes at the end.
+   *
+   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
+   */
+  void grow(std::size_t n)
+  {
+    if (size() > max_size() || max_size() - size() < n)
+    {
+      std::length_error ex("dynamic_string_buffer too long");
+      boost::asio::detail::throw_exception(ex);
+    }
+
+    string_.resize(size() + n);
+  }
+
+  /// @b DynamicBuffer_v2: Shrink the underlying memory by the specified number
+  /// of bytes.
+  /**
+   * Erases @c n bytes from the end of the string by resizing the basic_string
+   * object. If @c n is greater than the current size of the string, the string
+   * is emptied.
+   */
+  void shrink(std::size_t n)
+  {
+    string_.resize(n > size() ? 0 : size() - n);
+  }
 
-  /// Remove characters from the input sequence.
+  /// @b DynamicBuffer_v1: Remove characters from the input sequence.
+  /// @b DynamicBuffer_v2: Consume the specified number of bytes from the
+  /// beginning of the underlying memory.
   /**
-   * Removes @c n characters from the beginning of the input sequence.
+   * @b DynamicBuffer_v1: Removes @c n characters from the beginning of the
+   * input sequence. @note If @c n is greater than the size of the input
+   * sequence, the entire input sequence is consumed and no error is issued.
    *
-   * @note If @c n is greater than the size of the input sequence, the entire
-   * input sequence is consumed and no error is issued.
+   * @b DynamicBuffer_v2: Erases @c n bytes from the beginning of the string.
+   * If @c n is greater than the current size of the string, the string is
+   * emptied.
    */
   void consume(std::size_t n)
   {
-    std::size_t consume_length = (std::min)(n, size_);
-    string_.erase(0, consume_length);
-    size_ -= consume_length;
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+    if (size_ != (std::numeric_limits<std::size_t>::max)())
+    {
+      std::size_t consume_length = (std::min)(n, size_);
+      string_.erase(0, consume_length);
+      size_ -= consume_length;
+      return;
+    }
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+    string_.erase(0, n);
   }
 
 private:
   std::basic_string<Elem, Traits, Allocator>& string_;
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
   std::size_t size_;
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
   const std::size_t max_size_;
 };
 
@@ -1649,97 +1916,168 @@ template <typename Elem, typename Allocator>
 class dynamic_vector_buffer
 {
 public:
-  /// The type used to represent the input sequence as a list of buffers.
+  /// The type used to represent a sequence of constant buffers that refers to
+  /// the underlying memory.
   typedef BOOST_ASIO_CONST_BUFFER const_buffers_type;
 
-  /// The type used to represent the output sequence as a list of buffers.
+  /// The type used to represent a sequence of mutable buffers that refers to
+  /// the underlying memory.
   typedef BOOST_ASIO_MUTABLE_BUFFER mutable_buffers_type;
 
-  /// Construct a dynamic buffer from a string.
+  /// Construct a dynamic buffer from a vector.
   /**
    * @param v The vector to be used as backing storage for the dynamic buffer.
-   * Any existing data in the vector is treated as the dynamic buffer's input
-   * sequence. The object stores a reference to the vector and the user is
-   * responsible for ensuring that the vector object remains valid until the
-   * dynamic_vector_buffer object is destroyed.
+   * The object stores a reference to the vector and the user is responsible
+   * for ensuring that the vector object remains valid while the
+   * dynamic_vector_buffer object, and copies of the object, are in use.
    *
    * @param maximum_size Specifies a maximum size for the buffer, in bytes.
    */
   explicit dynamic_vector_buffer(std::vector<Elem, Allocator>& v,
       std::size_t maximum_size =
-        (std::numeric_limits<std::size_t>::max)()) BOOST_ASIO_NOEXCEPT
+        (std::numeric_limits<std::size_t>::max)()) noexcept
     : vector_(v),
-      size_(vector_.size()),
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+      size_((std::numeric_limits<std::size_t>::max)()),
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
       max_size_(maximum_size)
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// @b DynamicBuffer_v2: Copy construct a dynamic buffer.
+  dynamic_vector_buffer(const dynamic_vector_buffer& other) noexcept
+    : vector_(other.vector_),
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+      size_(other.size_),
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+      max_size_(other.max_size_)
+  {
+  }
+
   /// Move construct a dynamic buffer.
-  dynamic_vector_buffer(dynamic_vector_buffer&& other) BOOST_ASIO_NOEXCEPT
+  dynamic_vector_buffer(dynamic_vector_buffer&& other) noexcept
     : vector_(other.vector_),
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
       size_(other.size_),
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
       max_size_(other.max_size_)
   {
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
-  /// Get the size of the input sequence.
-  std::size_t size() const BOOST_ASIO_NOEXCEPT
+  /// @b DynamicBuffer_v1: Get the size of the input sequence.
+  /// @b DynamicBuffer_v2: Get the current size of the underlying memory.
+  /**
+   * @returns @b DynamicBuffer_v1 The current size of the input sequence.
+   * @b DynamicBuffer_v2: The current size of the underlying vector if less than
+   * max_size(). Otherwise returns max_size().
+   */
+  std::size_t size() const noexcept
   {
-    return size_;
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+    if (size_ != (std::numeric_limits<std::size_t>::max)())
+      return size_;
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+    return (std::min)(vector_.size(), max_size());
   }
 
   /// Get the maximum size of the dynamic buffer.
   /**
-   * @returns The allowed maximum of the sum of the sizes of the input sequence
-   * and output sequence.
+   * @returns @b DynamicBuffer_v1: The allowed maximum of the sum of the sizes
+   * of the input sequence and output sequence. @b DynamicBuffer_v2: The allowed
+   * maximum size of the underlying memory.
    */
-  std::size_t max_size() const BOOST_ASIO_NOEXCEPT
+  std::size_t max_size() const noexcept
   {
     return max_size_;
   }
 
-  /// Get the current capacity of the dynamic buffer.
+  /// Get the maximum size that the buffer may grow to without triggering
+  /// reallocation.
   /**
-   * @returns The current total capacity of the buffer, i.e. for both the input
-   * sequence and output sequence.
+   * @returns @b DynamicBuffer_v1: The current total capacity of the buffer,
+   * i.e. for both the input sequence and output sequence. @b DynamicBuffer_v2:
+   * The current capacity of the underlying vector if less than max_size().
+   * Otherwise returns max_size().
    */
-  std::size_t capacity() const BOOST_ASIO_NOEXCEPT
+  std::size_t capacity() const noexcept
   {
-    return vector_.capacity();
+    return (std::min)(vector_.capacity(), max_size());
   }
 
-  /// Get a list of buffers that represents the input sequence.
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+  /// @b DynamicBuffer_v1: Get a list of buffers that represents the input
+  /// sequence.
   /**
    * @returns An object of type @c const_buffers_type that satisfies
-   * ConstBufferSequence requirements, representing the basic_string memory in
+   * ConstBufferSequence requirements, representing the vector memory in the
    * input sequence.
    *
    * @note The returned object is invalidated by any @c dynamic_vector_buffer
-   * or @c basic_string member function that modifies the input sequence or
-   * output sequence.
+   * or @c vector member function that modifies the input sequence or output
+   * sequence.
    */
-  const_buffers_type data() const BOOST_ASIO_NOEXCEPT
+  const_buffers_type data() const noexcept
   {
     return const_buffers_type(boost::asio::buffer(vector_, size_));
   }
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 
-  /// Get a list of buffers that represents the output sequence, with the given
-  /// size.
+  /// @b DynamicBuffer_v2: Get a sequence of buffers that represents the
+  /// underlying memory.
+  /**
+   * @param pos Position of the first byte to represent in the buffer sequence
+   *
+   * @param n The number of bytes to return in the buffer sequence. If the
+   * underlying memory is shorter, the buffer sequence represents as many bytes
+   * as are available.
+   *
+   * @returns An object of type @c mutable_buffers_type that satisfies
+   * MutableBufferSequence requirements, representing the vector memory.
+   *
+   * @note The returned object is invalidated by any @c dynamic_vector_buffer
+   * or @c vector member function that resizes or erases the vector.
+   */
+  mutable_buffers_type data(std::size_t pos, std::size_t n) noexcept
+  {
+    return mutable_buffers_type(boost::asio::buffer(
+          boost::asio::buffer(vector_, max_size_) + pos, n));
+  }
+
+  /// @b DynamicBuffer_v2: Get a sequence of buffers that represents the
+  /// underlying memory.
+  /**
+   * @param pos Position of the first byte to represent in the buffer sequence
+   *
+   * @param n The number of bytes to return in the buffer sequence. If the
+   * underlying memory is shorter, the buffer sequence represents as many bytes
+   * as are available.
+   *
+   * @note The returned object is invalidated by any @c dynamic_vector_buffer
+   * or @c vector member function that resizes or erases the vector.
+   */
+  const_buffers_type data(std::size_t pos,
+      std::size_t n) const noexcept
+  {
+    return const_buffers_type(boost::asio::buffer(
+          boost::asio::buffer(vector_, max_size_) + pos, n));
+  }
+
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+  /// @b DynamicBuffer_v1: Get a list of buffers that represents the output
+  /// sequence, with the given size.
   /**
    * Ensures that the output sequence can accommodate @c n bytes, resizing the
-   * basic_string object as necessary.
+   * vector object as necessary.
    *
    * @returns An object of type @c mutable_buffers_type that satisfies
-   * MutableBufferSequence requirements, representing basic_string memory
-   * at the start of the output sequence of size @c n.
+   * MutableBufferSequence requirements, representing vector memory at the
+   * start of the output sequence of size @c n.
    *
    * @throws std::length_error If <tt>size() + n > max_size()</tt>.
    *
    * @note The returned object is invalidated by any @c dynamic_vector_buffer
-   * or @c basic_string member function that modifies the input sequence or
-   * output sequence.
+   * or @c vector member function that modifies the input sequence or output
+   * sequence.
    */
   mutable_buffers_type prepare(std::size_t n)
   {
@@ -1749,12 +2087,16 @@ public:
       boost::asio::detail::throw_exception(ex);
     }
 
+    if (size_ == (std::numeric_limits<std::size_t>::max)())
+      size_ = vector_.size(); // Enable v1 behaviour.
+
     vector_.resize(size_ + n);
 
     return boost::asio::buffer(boost::asio::buffer(vector_) + size_, n);
   }
 
-  /// Move bytes from the output sequence to the input sequence.
+  /// @b DynamicBuffer_v1: Move bytes from the output sequence to the input
+  /// sequence.
   /**
    * @param n The number of bytes to append from the start of the output
    * sequence to the end of the input sequence. The remainder of the output
@@ -1771,24 +2113,69 @@ public:
     size_ += (std::min)(n, vector_.size() - size_);
     vector_.resize(size_);
   }
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 
-  /// Remove characters from the input sequence.
+  /// @b DynamicBuffer_v2: Grow the underlying memory by the specified number of
+  /// bytes.
   /**
-   * Removes @c n characters from the beginning of the input sequence.
+   * Resizes the vector to accommodate an additional @c n bytes at the end.
    *
-   * @note If @c n is greater than the size of the input sequence, the entire
-   * input sequence is consumed and no error is issued.
+   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
+   */
+  void grow(std::size_t n)
+  {
+    if (size() > max_size() || max_size() - size() < n)
+    {
+      std::length_error ex("dynamic_vector_buffer too long");
+      boost::asio::detail::throw_exception(ex);
+    }
+
+    vector_.resize(size() + n);
+  }
+
+  /// @b DynamicBuffer_v2: Shrink the underlying memory by the specified number
+  /// of bytes.
+  /**
+   * Erases @c n bytes from the end of the vector by resizing the vector
+   * object. If @c n is greater than the current size of the vector, the vector
+   * is emptied.
+   */
+  void shrink(std::size_t n)
+  {
+    vector_.resize(n > size() ? 0 : size() - n);
+  }
+
+  /// @b DynamicBuffer_v1: Remove characters from the input sequence.
+  /// @b DynamicBuffer_v2: Consume the specified number of bytes from the
+  /// beginning of the underlying memory.
+  /**
+   * @b DynamicBuffer_v1: Removes @c n characters from the beginning of the
+   * input sequence. @note If @c n is greater than the size of the input
+   * sequence, the entire input sequence is consumed and no error is issued.
+   *
+   * @b DynamicBuffer_v2: Erases @c n bytes from the beginning of the vector.
+   * If @c n is greater than the current size of the vector, the vector is
+   * emptied.
    */
   void consume(std::size_t n)
   {
-    std::size_t consume_length = (std::min)(n, size_);
-    vector_.erase(vector_.begin(), vector_.begin() + consume_length);
-    size_ -= consume_length;
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+    if (size_ != (std::numeric_limits<std::size_t>::max)())
+    {
+      std::size_t consume_length = (std::min)(n, size_);
+      vector_.erase(vector_.begin(), vector_.begin() + consume_length);
+      size_ -= consume_length;
+      return;
+    }
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+    vector_.erase(vector_.begin(), vector_.begin() + (std::min)(size(), n));
   }
 
 private:
   std::vector<Elem, Allocator>& vector_;
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
   std::size_t size_;
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
   const std::size_t max_size_;
 };
 
@@ -1804,8 +2191,9 @@ private:
  * @returns <tt>dynamic_string_buffer<Elem, Traits, Allocator>(data)</tt>.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
-    std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline
+dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
+    std::basic_string<Elem, Traits, Allocator>& data) noexcept
 {
   return dynamic_string_buffer<Elem, Traits, Allocator>(data);
 }
@@ -1816,9 +2204,10 @@ inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
  * max_size)</tt>.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
     std::basic_string<Elem, Traits, Allocator>& data,
-    std::size_t max_size) BOOST_ASIO_NOEXCEPT
+    std::size_t max_size) noexcept
 {
   return dynamic_string_buffer<Elem, Traits, Allocator>(data, max_size);
 }
@@ -1828,8 +2217,9 @@ inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
  * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data)</tt>.
  */
 template <typename Elem, typename Allocator>
-inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
-    std::vector<Elem, Allocator>& data) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline
+dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
+    std::vector<Elem, Allocator>& data) noexcept
 {
   return dynamic_vector_buffer<Elem, Allocator>(data);
 }
@@ -1839,9 +2229,10 @@ inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
  * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data, max_size)</tt>.
  */
 template <typename Elem, typename Allocator>
-inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
     std::vector<Elem, Allocator>& data,
-    std::size_t max_size) BOOST_ASIO_NOEXCEPT
+    std::size_t max_size) noexcept
 {
   return dynamic_vector_buffer<Elem, Allocator>(data, max_size);
 }
@@ -1893,7 +2284,7 @@ inline std::size_t buffer_copy_1(const mutable_buffer& target,
 template <typename TargetIterator, typename SourceIterator>
 inline std::size_t buffer_copy(one_buffer, one_buffer,
     TargetIterator target_begin, TargetIterator,
-    SourceIterator source_begin, SourceIterator) BOOST_ASIO_NOEXCEPT
+    SourceIterator source_begin, SourceIterator) noexcept
 {
   return (buffer_copy_1)(*target_begin, *source_begin);
 }
@@ -1902,7 +2293,7 @@ template <typename TargetIterator, typename SourceIterator>
 inline std::size_t buffer_copy(one_buffer, one_buffer,
     TargetIterator target_begin, TargetIterator,
     SourceIterator source_begin, SourceIterator,
-    std::size_t max_bytes_to_copy) BOOST_ASIO_NOEXCEPT
+    std::size_t max_bytes_to_copy) noexcept
 {
   return (buffer_copy_1)(*target_begin,
       boost::asio::buffer(*source_begin, max_bytes_to_copy));
@@ -1913,7 +2304,7 @@ std::size_t buffer_copy(one_buffer, multiple_buffers,
     TargetIterator target_begin, TargetIterator,
     SourceIterator source_begin, SourceIterator source_end,
     std::size_t max_bytes_to_copy
-      = (std::numeric_limits<std::size_t>::max)()) BOOST_ASIO_NOEXCEPT
+      = (std::numeric_limits<std::size_t>::max)()) noexcept
 {
   std::size_t total_bytes_copied = 0;
   SourceIterator source_iter = source_begin;
@@ -1936,7 +2327,7 @@ std::size_t buffer_copy(multiple_buffers, one_buffer,
     TargetIterator target_begin, TargetIterator target_end,
     SourceIterator source_begin, SourceIterator,
     std::size_t max_bytes_to_copy
-      = (std::numeric_limits<std::size_t>::max)()) BOOST_ASIO_NOEXCEPT
+      = (std::numeric_limits<std::size_t>::max)()) noexcept
 {
   std::size_t total_bytes_copied = 0;
   TargetIterator target_iter = target_begin;
@@ -1957,7 +2348,7 @@ std::size_t buffer_copy(multiple_buffers, one_buffer,
 template <typename TargetIterator, typename SourceIterator>
 std::size_t buffer_copy(multiple_buffers, multiple_buffers,
     TargetIterator target_begin, TargetIterator target_end,
-    SourceIterator source_begin, SourceIterator source_end) BOOST_ASIO_NOEXCEPT
+    SourceIterator source_begin, SourceIterator source_end) noexcept
 {
   std::size_t total_bytes_copied = 0;
 
@@ -2002,7 +2393,7 @@ template <typename TargetIterator, typename SourceIterator>
 std::size_t buffer_copy(multiple_buffers, multiple_buffers,
     TargetIterator target_begin, TargetIterator target_end,
     SourceIterator source_begin, SourceIterator source_end,
-    std::size_t max_bytes_to_copy) BOOST_ASIO_NOEXCEPT
+    std::size_t max_bytes_to_copy) noexcept
 {
   std::size_t total_bytes_copied = 0;
 
@@ -2069,7 +2460,7 @@ std::size_t buffer_copy(multiple_buffers, multiple_buffers,
  */
 template <typename MutableBufferSequence, typename ConstBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const ConstBufferSequence& source) BOOST_ASIO_NOEXCEPT
+    const ConstBufferSequence& source) noexcept
 {
   return detail::buffer_copy(
       detail::buffer_sequence_cardinality<MutableBufferSequence>(),
@@ -2107,7 +2498,7 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
 template <typename MutableBufferSequence, typename ConstBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const ConstBufferSequence& source,
-    std::size_t max_bytes_to_copy) BOOST_ASIO_NOEXCEPT
+    std::size_t max_bytes_to_copy) noexcept
 {
   return detail::buffer_copy(
       detail::buffer_sequence_cardinality<MutableBufferSequence>(),
@@ -2154,17 +2545,208 @@ struct is_const_buffer_sequence
 {
 };
 
-/// Trait to determine whether a type satisfies the DynamicBuffer requirements.
+#if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+/// Trait to determine whether a type satisfies the DynamicBuffer_v1
+/// requirements.
 template <typename T>
-struct is_dynamic_buffer
+struct is_dynamic_buffer_v1
 #if defined(GENERATING_DOCUMENTATION)
   : integral_constant<bool, automatically_determined>
 #else // defined(GENERATING_DOCUMENTATION)
-  : boost::asio::detail::is_dynamic_buffer<T>
+  : boost::asio::detail::is_dynamic_buffer_v1<T>
 #endif // defined(GENERATING_DOCUMENTATION)
 {
 };
+#endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+
+/// Trait to determine whether a type satisfies the DynamicBuffer_v2
+/// requirements.
+template <typename T>
+struct is_dynamic_buffer_v2
+#if defined(GENERATING_DOCUMENTATION)
+  : integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  : boost::asio::detail::is_dynamic_buffer_v2<T>
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+/// Trait to determine whether a type satisfies the DynamicBuffer requirements.
+/**
+ * If @c BOOST_ASIO_NO_DYNAMIC_BUFFER_V1 is not defined, determines whether the
+ * type satisfies the DynamicBuffer_v1 requirements. Otherwise, if @c
+ * BOOST_ASIO_NO_DYNAMIC_BUFFER_V1 is defined, determines whether the type
+ * satisfies the DynamicBuffer_v2 requirements.
+ */
+template <typename T>
+struct is_dynamic_buffer
+#if defined(GENERATING_DOCUMENTATION)
+  : integral_constant<bool, automatically_determined>
+#elif defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+  : boost::asio::is_dynamic_buffer_v2<T>
+#else // defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+  : boost::asio::is_dynamic_buffer_v1<T>
+#endif // defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
+{
+};
+
+namespace buffer_literals {
+namespace detail {
+
+template <char... Chars>
+struct chars {};
+
+template <unsigned char... Bytes>
+struct bytes {};
+
+// Literal processor that converts binary literals to an array of bytes.
+
+template <typename Bytes, char... Chars>
+struct bin_literal;
+
+template <unsigned char... Bytes>
+struct bin_literal<bytes<Bytes...>>
+{
+  static const std::size_t size = sizeof...(Bytes);
+  static const unsigned char data[sizeof...(Bytes)];
+};
+
+template <unsigned char... Bytes>
+const unsigned char bin_literal<bytes<Bytes...>>::data[sizeof...(Bytes)]
+  = { Bytes... };
+
+template <unsigned char... Bytes, char Bit7, char Bit6, char Bit5,
+    char Bit4, char Bit3, char Bit2, char Bit1, char Bit0, char... Chars>
+struct bin_literal<bytes<Bytes...>, Bit7, Bit6,
+    Bit5, Bit4, Bit3, Bit2, Bit1, Bit0, Chars...> :
+  bin_literal<
+    bytes<Bytes...,
+      static_cast<unsigned char>(
+      (Bit7 == '1' ? 0x80 : 0) |
+        (Bit6 == '1' ? 0x40 : 0) |
+        (Bit5 == '1' ? 0x20 : 0) |
+        (Bit4 == '1' ? 0x10 : 0) |
+        (Bit3 == '1' ? 0x08 : 0) |
+        (Bit2 == '1' ? 0x04 : 0) |
+        (Bit1 == '1' ? 0x02 : 0) |
+        (Bit0 == '1' ? 0x01 : 0))
+    >, Chars...> {};
+
+template <unsigned char... Bytes, char... Chars>
+struct bin_literal<bytes<Bytes...>, Chars...>
+{
+  static_assert(sizeof...(Chars) == 0,
+      "number of digits in a binary buffer literal must be a multiple of 8");
+
+  static const std::size_t size = 0;
+  static const unsigned char data[1];
+};
+
+template <unsigned char... Bytes, char... Chars>
+const unsigned char bin_literal<bytes<Bytes...>, Chars...>::data[1] = {};
+
+// Literal processor that converts hexadecimal literals to an array of bytes.
+
+template <typename Bytes, char... Chars>
+struct hex_literal;
+
+template <unsigned char... Bytes>
+struct hex_literal<bytes<Bytes...>>
+{
+  static const std::size_t size = sizeof...(Bytes);
+  static const unsigned char data[sizeof...(Bytes)];
+};
+
+template <unsigned char... Bytes>
+const unsigned char hex_literal<bytes<Bytes...>>::data[sizeof...(Bytes)]
+  = { Bytes... };
+
+template <unsigned char... Bytes, char Hi, char Lo, char... Chars>
+struct hex_literal<bytes<Bytes...>, Hi, Lo, Chars...> :
+  hex_literal<
+    bytes<Bytes...,
+      static_cast<unsigned char>(
+        Lo >= 'A' && Lo <= 'F' ? Lo - 'A' + 10 :
+          (Lo >= 'a' && Lo <= 'f' ? Lo - 'a' + 10 : Lo - '0')) |
+      ((static_cast<unsigned char>(
+        Hi >= 'A' && Hi <= 'F' ? Hi - 'A' + 10 :
+          (Hi >= 'a' && Hi <= 'f' ? Hi - 'a' + 10 : Hi - '0'))) << 4)
+    >, Chars...> {};
+
+template <unsigned char... Bytes, char Char>
+struct hex_literal<bytes<Bytes...>, Char>
+{
+  static_assert(!Char,
+      "a hexadecimal buffer literal must have an even number of digits");
+
+  static const std::size_t size = 0;
+  static const unsigned char data[1];
+};
+
+template <unsigned char... Bytes, char Char>
+const unsigned char hex_literal<bytes<Bytes...>, Char>::data[1] = {};
+
+// Helper template that removes digit separators and then passes the cleaned
+// variadic pack of characters to the literal processor.
+
+template <template <typename, char...> class Literal,
+    typename Clean, char... Raw>
+struct remove_separators;
+
+template <template <typename, char...> class Literal,
+    char... Clean, char... Raw>
+struct remove_separators<Literal, chars<Clean...>, '\'', Raw...> :
+  remove_separators<Literal, chars<Clean...>, Raw...> {};
+
+template <template <typename, char...> class Literal,
+    char... Clean, char C, char... Raw>
+struct remove_separators<Literal, chars<Clean...>, C, Raw...> :
+  remove_separators<Literal, chars<Clean..., C>, Raw...> {};
+
+template <template <typename, char...> class Literal, char... Clean>
+struct remove_separators<Literal, chars<Clean...>> :
+  Literal<bytes<>, Clean...> {};
+
+// Helper template to determine the literal type based on the prefix.
+
+template <char... Chars>
+struct literal;
+
+template <char... Chars>
+struct literal<'0', 'b', Chars...> :
+  remove_separators<bin_literal, chars<>, Chars...>{};
+
+template <char... Chars>
+struct literal<'0', 'B', Chars...> :
+  remove_separators<bin_literal, chars<>, Chars...>{};
+
+template <char... Chars>
+struct literal<'0', 'x', Chars...> :
+  remove_separators<hex_literal, chars<>, Chars...>{};
+
+template <char... Chars>
+struct literal<'0', 'X', Chars...> :
+  remove_separators<hex_literal, chars<>, Chars...>{};
+
+} // namespace detail
+
+/// Literal operator for creating const_buffer objects from string literals.
+inline BOOST_ASIO_CONST_BUFFER operator"" _buf(const char* data, std::size_t n)
+{
+  return BOOST_ASIO_CONST_BUFFER(data, n);
+}
+
+/// Literal operator for creating const_buffer objects from unbounded binary or
+/// hexadecimal integer literals.
+template <char... Chars>
+inline BOOST_ASIO_CONST_BUFFER operator"" _buf()
+{
+  return BOOST_ASIO_CONST_BUFFER(
+      +detail::literal<Chars...>::data,
+      detail::literal<Chars...>::size);
+}
 
+} // namespace buffer_literals
 } // namespace asio
 } // namespace boost