1 files changed, 124 insertions, 25 deletions
diff --git a/3rdParty/Boost/src/boost/asio/buffer.hpp b/3rdParty/Boost/src/boost/asio/buffer.hpp
index 532cfd1..450face 100644
--- a/3rdParty/Boost/src/boost/asio/buffer.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffer.hpp
@@ -1,163 +1,169 @@
 //
 // buffer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2014 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)
 //
 
 #ifndef BOOST_ASIO_BUFFER_HPP
 #define BOOST_ASIO_BUFFER_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <cstring>
 #include <string>
 #include <vector>
-#include <boost/detail/workaround.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
 
-#if defined(BOOST_MSVC)
+#if defined(BOOST_ASIO_MSVC)
 # if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0)
 #  if !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)
 #   define BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 #  endif // !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)
 # endif // defined(_HAS_ITERATOR_DEBUGGING)
-#endif // defined(BOOST_MSVC)
+#endif // defined(BOOST_ASIO_MSVC)
 
 #if defined(__GNUC__)
 # if defined(_GLIBCXX_DEBUG)
 #  if !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)
 #   define BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 #  endif // !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)
 # endif // defined(_GLIBCXX_DEBUG)
 #endif // defined(__GNUC__)
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-# include <boost/function.hpp>
+# include <boost/asio/detail/function.hpp>
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \
-  || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-# include <boost/type_traits/is_const.hpp>
-#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-       // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#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 {
 namespace asio {
 
 class mutable_buffer;
 class const_buffer;
 
 namespace detail {
 void* buffer_cast_helper(const mutable_buffer&);
 const void* buffer_cast_helper(const const_buffer&);
 std::size_t buffer_size_helper(const mutable_buffer&);
 std::size_t buffer_size_helper(const const_buffer&);
 } // namespace detail
 
 /// Holds a buffer that can be modified.
 /**
  * The mutable_buffer class provides a safe representation of a buffer that can
  * be modified. It does not own the underlying data, and so is cheap to copy or
  * assign.
  *
  * @par Accessing Buffer Contents
  *
  * The contents of a buffer may be accessed using the @ref buffer_size
  * and @ref buffer_cast functions:
  *
  * @code boost::asio::mutable_buffer b1 = ...;
  * std::size_t s1 = boost::asio::buffer_size(b1);
  * unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);
  * @endcode
  *
  * The boost::asio::buffer_cast function permits violations of type safety, so
  * uses of it in application code should be carefully considered.
  */
 class mutable_buffer
 {
 public:
   /// Construct an empty buffer.
   mutable_buffer()
     : data_(0),
       size_(0)
   {
   }
 
   /// Construct a buffer to represent a given memory range.
   mutable_buffer(void* data, std::size_t size)
     : data_(data),
       size_(size)
   {
   }
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   mutable_buffer(void* data, std::size_t size,
-      boost::function<void()> debug_check)
+      boost::asio::detail::function<void()> debug_check)
     : data_(data),
       size_(size),
       debug_check_(debug_check)
   {
   }
 
-  const boost::function<void()>& get_debug_check() const
+  const boost::asio::detail::function<void()>& get_debug_check() const
   {
     return debug_check_;
   }
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
 private:
   friend void* boost::asio::detail::buffer_cast_helper(
       const mutable_buffer& b);
   friend std::size_t boost::asio::detail::buffer_size_helper(
       const mutable_buffer& b);
 
   void* data_;
   std::size_t size_;
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-  boost::function<void()> debug_check_;
+  boost::asio::detail::function<void()> debug_check_;
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 };
 
 namespace detail {
 
 inline void* buffer_cast_helper(const mutable_buffer& b)
 {
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   if (b.size_ && b.debug_check_)
     b.debug_check_();
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
   return b.data_;
 }
 
 inline std::size_t buffer_size_helper(const mutable_buffer& b)
 {
   return b.size_;
 }
 
 } // namespace detail
 
 /// Adapts a single modifiable buffer so that it meets the requirements of the
 /// MutableBufferSequence concept.
 class mutable_buffers_1
   : public mutable_buffer
 {
 public:
   /// The type for each element in the list of buffers.
   typedef mutable_buffer value_type;
 
   /// A random-access iterator type that may be used to read elements.
   typedef const mutable_buffer* const_iterator;
 
   /// Construct to represent a given memory range.
   mutable_buffers_1(void* data, std::size_t size)
@@ -200,94 +206,94 @@ public:
  * const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1);
  * @endcode
  *
  * The boost::asio::buffer_cast function permits violations of type safety, so
  * uses of it in application code should be carefully considered.
  */
 class const_buffer
 {
 public:
   /// Construct an empty buffer.
   const_buffer()
     : data_(0),
       size_(0)
   {
   }
 
   /// Construct a buffer to represent a given memory range.
   const_buffer(const void* data, std::size_t size)
     : data_(data),
       size_(size)
   {
   }
 
   /// Construct a non-modifiable buffer from a modifiable one.
   const_buffer(const mutable_buffer& b)
     : data_(boost::asio::detail::buffer_cast_helper(b)),
       size_(boost::asio::detail::buffer_size_helper(b))
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
       , debug_check_(b.get_debug_check())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
   {
   }
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   const_buffer(const void* data, std::size_t size,
-      boost::function<void()> debug_check)
+      boost::asio::detail::function<void()> debug_check)
     : data_(data),
       size_(size),
       debug_check_(debug_check)
   {
   }
 
-  const boost::function<void()>& get_debug_check() const
+  const boost::asio::detail::function<void()>& get_debug_check() const
   {
     return debug_check_;
   }
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
 private:
   friend const void* boost::asio::detail::buffer_cast_helper(
       const const_buffer& b);
   friend std::size_t boost::asio::detail::buffer_size_helper(
       const const_buffer& b);
 
   const void* data_;
   std::size_t size_;
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-  boost::function<void()> debug_check_;
+  boost::asio::detail::function<void()> debug_check_;
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 };
 
 namespace detail {
 
 inline const void* buffer_cast_helper(const const_buffer& b)
 {
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   if (b.size_ && b.debug_check_)
     b.debug_check_();
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
   return b.data_;
 }
 
 inline std::size_t buffer_size_helper(const const_buffer& b)
 {
   return b.size_;
 }
 
 } // namespace detail
 
 /// Adapts a single non-modifiable buffer so that it meets the requirements of
 /// the ConstBufferSequence concept.
 class const_buffers_1
   : public const_buffer
 {
 public:
   /// The type for each element in the list of buffers.
   typedef const_buffer value_type;
 
   /// A random-access iterator type that may be used to read elements.
   typedef const const_buffer* const_iterator;
 
   /// Construct to represent a given memory range.
   const_buffers_1(const void* data, std::size_t size)
@@ -480,76 +486,76 @@ inline const_buffer operator+(const const_buffer& b, std::size_t start)
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
       );
 }
 
 /// Create a new non-modifiable buffer that is offset from the start of another.
 /**
  * @relates const_buffer
  */
 inline const_buffer operator+(std::size_t start, const const_buffer& b)
 {
   if (start > buffer_size(b))
     return const_buffer();
   const char* new_data = buffer_cast<const char*>(b) + start;
   std::size_t new_size = buffer_size(b) - start;
   return const_buffer(new_data, new_size
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
       , b.get_debug_check()
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
       );
 }
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
 namespace detail {
 
 template <typename Iterator>
 class buffer_debug_check
 {
 public:
   buffer_debug_check(Iterator iter)
     : iter_(iter)
   {
   }
 
   ~buffer_debug_check()
   {
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1400)
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC == 1400)
     // MSVC 8's string iterator checking may crash in a std::string::iterator
     // object's destructor when the iterator points to an already-destroyed
     // std::string object, unless the iterator is cleared first.
     iter_ = Iterator();
-#endif // BOOST_WORKAROUND(BOOST_MSVC, == 1400)
+#endif // defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC == 1400)
   }
 
   void operator()()
   {
     *iter_;
   }
 
 private:
   Iterator iter_;
 };
 
 } // namespace detail
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
 /** @defgroup buffer boost::asio::buffer
  *
  * @brief The boost::asio::buffer function is used to create a buffer object to
  * represent raw memory, an array of POD elements, a vector of POD elements,
  * or a std::string.
  *
  * A buffer object represents a contiguous region of memory as a 2-tuple
  * consisting of a pointer and size in bytes. A tuple of the form <tt>{void*,
  * size_t}</tt> specifies a mutable (modifiable) region of memory. Similarly, a
  * tuple of the form <tt>{const void*, size_t}</tt> specifies a const
  * (non-modifiable) region of memory. These two forms correspond to the classes
  * mutable_buffer and const_buffer, respectively. To mirror C++'s conversion
  * rules, a mutable_buffer is implicitly convertible to a const_buffer, and the
  * opposite conversion is not permitted.
  *
  * The simplest use case involves reading or writing a single buffer of a
  * specified size:
  *
  * @code sock.send(boost::asio::buffer(data, size)); @endcode
  *
  * In the above example, the return value of boost::asio::buffer meets the
@@ -580,70 +586,73 @@ private:
  *
  * @par Accessing Buffer Contents
  *
  * The contents of a buffer may be accessed using the @ref buffer_size and
  * @ref buffer_cast functions:
  *
  * @code boost::asio::mutable_buffer b1 = ...;
  * std::size_t s1 = boost::asio::buffer_size(b1);
  * unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);
  *
  * boost::asio::const_buffer b2 = ...;
  * std::size_t s2 = boost::asio::buffer_size(b2);
  * const void* p2 = boost::asio::buffer_cast<const void*>(b2); @endcode
  *
  * The boost::asio::buffer_cast function permits violations of type safety, so
  * uses of it in application code should be carefully considered.
  *
  * For convenience, the @ref buffer_size function also works on buffer
  * sequences (that is, types meeting the ConstBufferSequence or
  * MutableBufferSequence type requirements). In this case, the function returns
  * the total size of all buffers in the sequence.
  *
  * @par Buffer Copying
  *
  * The @ref buffer_copy function may be used to copy raw bytes between
  * individual buffers and buffer sequences.
  *
  * In particular, when used with the @ref buffer_size, the @ref buffer_copy
  * function can be used to linearise a sequence of buffers. For example:
  *
  * @code vector<const_buffer> buffers = ...;
  *
  * vector<unsigned char> data(boost::asio::buffer_size(buffers));
  * boost::asio::buffer_copy(boost::asio::buffer(data), buffers); @endcode
  *
+ * Note that @ref buffer_copy is implemented in terms of @c memcpy, and
+ * consequently it cannot be used to copy between overlapping memory regions.
+ *
  * @par Buffer Invalidation
  *
  * A buffer object does not have any ownership of the memory it refers to. It
  * is the responsibility of the application to ensure the memory region remains
  * valid until it is no longer required for an I/O operation. When the memory
  * is no longer available, the buffer is said to have been invalidated.
  *
  * For the boost::asio::buffer overloads that accept an argument of type
  * std::vector, the buffer objects returned are invalidated by any vector
  * operation that also invalidates all references, pointers and iterators
  * referring to the elements in the sequence (C++ Std, 23.2.4)
  *
  * For the boost::asio::buffer overloads that accept an argument of type
  * std::basic_string, the buffer objects returned are invalidated according to
  * the rules defined for invalidation of references, pointers and iterators
  * referring to elements of the sequence (C++ Std, 21.3).
  *
  * @par Buffer Arithmetic
  *
  * Buffer objects may be manipulated using simple arithmetic in a safe way
  * which helps prevent buffer overruns. Consider an array initialised as
  * follows:
  *
  * @code boost::array<char, 6> a = { 'a', 'b', 'c', 'd', 'e' }; @endcode
  *
  * A buffer object @c b1 created using:
  *
  * @code b1 = boost::asio::buffer(a); @endcode
  *
  * represents the entire array, <tt>{ 'a', 'b', 'c', 'd', 'e' }</tt>. An
  * optional second argument to the boost::asio::buffer function may be used to
  * limit the size, in bytes, of the buffer:
  *
  * @code b2 = boost::asio::buffer(a, 3); @endcode
  *
@@ -796,205 +805,202 @@ inline mutable_buffers_1 buffer(PodType (&data)[N],
       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_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     static_cast<const void*>(data),
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline const_buffers_1 buffer(const PodType (&data)[N])
 {
   return const_buffers_1(const_buffer(data, N * sizeof(PodType)));
 }
 
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     static_cast<const void*>(data),
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline const_buffers_1 buffer(const PodType (&data)[N],
     std::size_t max_size_in_bytes)
 {
   return const_buffers_1(
       const_buffer(data,
         N * sizeof(PodType) < max_size_in_bytes
         ? N * sizeof(PodType) : max_size_in_bytes));
 }
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \
-  || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#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 mutable_buffers_1 container_type;
 };
 
 template <>
 struct buffer_types_base<true>
 {
   typedef const_buffer buffer_type;
   typedef const_buffers_1 container_type;
 };
 
 template <typename PodType>
 struct buffer_types
-  : public buffer_types_base<boost::is_const<PodType>::value>
+  : 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)
 {
   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)
 {
   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 // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-      // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#else // defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
 
 /// Create a new modifiable buffer that represents the given POD array.
 /**
  * @returns A mutable_buffers_1 value equivalent to:
  * @code mutable_buffers_1(
  *     data.data(),
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline mutable_buffers_1 buffer(boost::array<PodType, N>& data)
 {
   return mutable_buffers_1(
       mutable_buffer(data.c_array(), data.size() * sizeof(PodType)));
 }
 
 /// Create a new modifiable buffer that represents the given POD array.
 /**
  * @returns A mutable_buffers_1 value equivalent to:
  * @code mutable_buffers_1(
  *     data.data(),
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline mutable_buffers_1 buffer(boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes)
 {
   return mutable_buffers_1(
       mutable_buffer(data.c_array(),
         data.size() * sizeof(PodType) < max_size_in_bytes
         ? data.size() * sizeof(PodType) : max_size_in_bytes));
 }
 
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     data.data(),
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline const_buffers_1 buffer(boost::array<const PodType, N>& data)
 {
   return const_buffers_1(
       const_buffer(data.data(), data.size() * sizeof(PodType)));
 }
 
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     data.data(),
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline const_buffers_1 buffer(boost::array<const PodType, N>& data,
     std::size_t max_size_in_bytes)
 {
   return const_buffers_1(
       const_buffer(data.data(),
         data.size() * sizeof(PodType) < max_size_in_bytes
         ? data.size() * sizeof(PodType) : max_size_in_bytes));
 }
 
-#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-       // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#endif // defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
 
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     data.data(),
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline const_buffers_1 buffer(const boost::array<PodType, N>& data)
 {
   return const_buffers_1(
       const_buffer(data.data(), data.size() * sizeof(PodType)));
 }
 
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     data.data(),
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline const_buffers_1 buffer(const boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes)
 {
   return const_buffers_1(
       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.
@@ -1230,892 +1236,985 @@ inline const_buffers_1 buffer(
       const_buffer(data.data(),
         data.size() * sizeof(Elem) < max_size_in_bytes
         ? data.size() * sizeof(Elem) : max_size_in_bytes
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
         , detail::buffer_debug_check<
             typename std::basic_string<Elem, Traits, Allocator>::const_iterator
           >(data.begin())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
         ));
 }
 
 /*@}*/
 
 /** @defgroup buffer_copy boost::asio::buffer_copy
  *
  * @brief The boost::asio::buffer_copy function is used to copy bytes from a
  * source buffer (or buffer sequence) to a target buffer (or buffer sequence).
  *
  * The @c buffer_copy function is available in two forms:
  *
  * @li A 2-argument form: @c buffer_copy(target, source)
  *
  * @li A 3-argument form: @c buffer_copy(target, source, max_bytes_to_copy)
 
  * Both forms return the number of bytes actually copied. The number of bytes
  * copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c If specified, @c max_bytes_to_copy.
  *
  * This prevents buffer overflow, regardless of the buffer sizes used in the
  * copy operation.
+ *
+ * Note that @ref buffer_copy is implemented in terms of @c memcpy, and
+ * consequently it cannot be used to copy between overlapping memory regions.
  */
 /*@{*/
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const const_buffer& source)
 {
   using namespace std; // For memcpy.
   std::size_t target_size = buffer_size(target);
   std::size_t source_size = buffer_size(source);
   std::size_t n = target_size < source_size ? target_size : source_size;
   memcpy(buffer_cast<void*>(target), buffer_cast<const void*>(source), n);
   return n;
 }
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const const_buffers_1& source)
 {
   return buffer_copy(target, static_cast<const const_buffer&>(source));
 }
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const mutable_buffer& source)
 {
   return buffer_copy(target, const_buffer(source));
 }
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const mutable_buffers_1& source)
 {
   return buffer_copy(target, const_buffer(source));
 }
 
 /// Copies bytes from a source buffer sequence to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer sequence representing the memory
  * regions from which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename ConstBufferSequence>
 std::size_t buffer_copy(const mutable_buffer& target,
     const ConstBufferSequence& source)
 {
   std::size_t total_bytes_copied = 0;
 
   typename ConstBufferSequence::const_iterator source_iter = source.begin();
   typename ConstBufferSequence::const_iterator source_end = source.end();
 
   for (mutable_buffer target_buffer(target);
       buffer_size(target_buffer) && source_iter != source_end; ++source_iter)
   {
     const_buffer source_buffer(*source_iter);
     std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
     total_bytes_copied += bytes_copied;
     target_buffer = target_buffer + bytes_copied;
   }
 
   return total_bytes_copied;
 }
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const const_buffer& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target), source);
 }
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const const_buffers_1& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target),
       static_cast<const const_buffer&>(source));
 }
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const mutable_buffer& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target),
       const_buffer(source));
 }
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const mutable_buffers_1& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target),
       const_buffer(source));
 }
 
 /// Copies bytes from a source buffer sequence to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer sequence representing the memory
  * regions from which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename ConstBufferSequence>
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const ConstBufferSequence& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target), source);
 }
 
 /// Copies bytes from a source buffer to a target buffer sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 std::size_t buffer_copy(const MutableBufferSequence& target,
     const const_buffer& source)
 {
   std::size_t total_bytes_copied = 0;
 
   typename MutableBufferSequence::const_iterator target_iter = target.begin();
   typename MutableBufferSequence::const_iterator target_end = target.end();
 
   for (const_buffer source_buffer(source);
       buffer_size(source_buffer) && target_iter != target_end; ++target_iter)
   {
     mutable_buffer target_buffer(*target_iter);
     std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
     total_bytes_copied += bytes_copied;
     source_buffer = source_buffer + bytes_copied;
   }
 
   return total_bytes_copied;
 }
 
 /// Copies bytes from a source buffer to a target buffer sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const const_buffers_1& source)
 {
   return buffer_copy(target, static_cast<const const_buffer&>(source));
 }
 
 /// Copies bytes from a source buffer to a target buffer sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const mutable_buffer& source)
 {
   return buffer_copy(target, const_buffer(source));
 }
 
 /// Copies bytes from a source buffer to a target buffer sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const mutable_buffers_1& source)
 {
   return buffer_copy(target, const_buffer(source));
 }
 
 /// Copies bytes from a source buffer sequence to a target buffer sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A non-modifiable buffer sequence representing the memory
  * regions from which the bytes will be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence, typename ConstBufferSequence>
 std::size_t buffer_copy(const MutableBufferSequence& target,
     const ConstBufferSequence& source)
 {
   std::size_t total_bytes_copied = 0;
 
   typename MutableBufferSequence::const_iterator target_iter = target.begin();
   typename MutableBufferSequence::const_iterator target_end = target.end();
   std::size_t target_buffer_offset = 0;
 
   typename ConstBufferSequence::const_iterator source_iter = source.begin();
   typename ConstBufferSequence::const_iterator source_end = source.end();
   std::size_t source_buffer_offset = 0;
 
   while (target_iter != target_end && source_iter != source_end)
   {
     mutable_buffer target_buffer =
       mutable_buffer(*target_iter) + target_buffer_offset;
 
     const_buffer source_buffer =
       const_buffer(*source_iter) + source_buffer_offset;
 
     std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
     total_bytes_copied += bytes_copied;
 
     if (bytes_copied == buffer_size(target_buffer))
     {
       ++target_iter;
       target_buffer_offset = 0;
     }
     else
       target_buffer_offset += bytes_copied;
 
     if (bytes_copied == buffer_size(source_buffer))
     {
       ++source_iter;
       source_buffer_offset = 0;
     }
     else
       source_buffer_offset += bytes_copied;
   }
 
   return total_bytes_copied;
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const const_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const const_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const mutable_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer sequence to a target
 /// buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer sequence representing the memory
  * regions from which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename ConstBufferSequence>
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const const_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const const_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const mutable_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer sequence to a target
 /// buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
  * the bytes will be copied.
  *
  * @param source A non-modifiable buffer sequence representing the memory
  * regions from which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename ConstBufferSequence>
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer
 /// sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const const_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(target, buffer(source, max_bytes_to_copy));
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer
 /// sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A non-modifiable buffer representing the memory region from
  * which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const const_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(target, buffer(source, max_bytes_to_copy));
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer
 /// sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const mutable_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(target, buffer(source, max_bytes_to_copy));
 }
 
 /// Copies a limited number of bytes from a source buffer to a target buffer
 /// sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A modifiable buffer representing the memory region from which
  * the bytes will be copied. The contents of the source buffer will not be
  * modified.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(target, buffer(source, max_bytes_to_copy));
 }
 
 /// Copies a limited number of bytes from a source buffer sequence to a target
 /// buffer sequence.
 /**
  * @param target A modifiable buffer sequence representing the memory regions to
  * which the bytes will be copied.
  *
  * @param source A non-modifiable buffer sequence representing the memory
  * regions from which the bytes will be copied.
  *
  * @param max_bytes_to_copy The maximum number of bytes to be copied.
  *
  * @returns The number of bytes copied.
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence, typename ConstBufferSequence>
 std::size_t buffer_copy(const MutableBufferSequence& target,
     const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
 {
   std::size_t total_bytes_copied = 0;
 
   typename MutableBufferSequence::const_iterator target_iter = target.begin();
   typename MutableBufferSequence::const_iterator target_end = target.end();
   std::size_t target_buffer_offset = 0;
 
   typename ConstBufferSequence::const_iterator source_iter = source.begin();
   typename ConstBufferSequence::const_iterator source_end = source.end();
   std::size_t source_buffer_offset = 0;
 
   while (total_bytes_copied != max_bytes_to_copy
       && target_iter != target_end && source_iter != source_end)
   {
     mutable_buffer target_buffer =
       mutable_buffer(*target_iter) + target_buffer_offset;
 
     const_buffer source_buffer =
       const_buffer(*source_iter) + source_buffer_offset;
 
     std::size_t bytes_copied = buffer_copy(target_buffer,
         source_buffer, max_bytes_to_copy - total_bytes_copied);
     total_bytes_copied += bytes_copied;
 
     if (bytes_copied == buffer_size(target_buffer))
     {
       ++target_iter;
       target_buffer_offset = 0;
     }
     else
       target_buffer_offset += bytes_copied;