buffer.hpp

//
// buffer.hpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2020 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 ASIO_BUFFER_HPP
#define ASIO_BUFFER_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include "asio/detail/config.hpp"
#include <cstddef>
#include <cstring>
#include <limits>
#include <stdexcept>
#include <string>
#include <vector>
#include "asio/detail/array_fwd.hpp"
#include "asio/detail/memory.hpp"
#include "asio/detail/string_view.hpp"
#include "asio/detail/throw_exception.hpp"
#include "asio/detail/type_traits.hpp"

#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1700)
# if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0)
#  if !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
#   define ASIO_ENABLE_BUFFER_DEBUGGING
#  endif // !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
# endif // defined(_HAS_ITERATOR_DEBUGGING)
#endif // defined(ASIO_MSVC) && (ASIO_MSVC >= 1700)

#if defined(__GNUC__)
# if defined(_GLIBCXX_DEBUG)
#  if !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
#   define ASIO_ENABLE_BUFFER_DEBUGGING
#  endif // !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
# endif // defined(_GLIBCXX_DEBUG)
#endif // defined(__GNUC__)

#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
# include "asio/detail/functional.hpp"
#endif // ASIO_ENABLE_BUFFER_DEBUGGING

#if defined(ASIO_HAS_BOOST_WORKAROUND)
# include <boost/detail/workaround.hpp>
# if !defined(__clang__)
#  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
#   define ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND
#  endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
# elif BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
#  define ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND
# endif // BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
#endif // defined(ASIO_HAS_BOOST_WORKAROUND)

#if defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
# include "asio/detail/type_traits.hpp"
#endif // defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)

#include "asio/detail/push_options.hpp"

namespace asio {

class mutable_buffer;
class const_buffer;


class mutable_buffer
{
public:
  mutable_buffer() ASIO_NOEXCEPT
    : data_(0),
      size_(0)
  {
  }

  mutable_buffer(void* data, std::size_t size) ASIO_NOEXCEPT
    : data_(data),
      size_(size)
  {
  }

#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
  mutable_buffer(void* data, std::size_t size,
      asio::detail::function<void()> debug_check)
    : data_(data),
      size_(size),
      debug_check_(debug_check)
  {
  }

  const asio::detail::function<void()>& get_debug_check() const
  {
    return debug_check_;
  }
#endif // ASIO_ENABLE_BUFFER_DEBUGGING

  void* data() const ASIO_NOEXCEPT
  {
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
    if (size_ && debug_check_)
      debug_check_();
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
    return data_;
  }

  std::size_t size() const ASIO_NOEXCEPT
  {
    return size_;
  }

  mutable_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
  {
    std::size_t offset = n < size_ ? n : size_;
    data_ = static_cast<char*>(data_) + offset;
    size_ -= offset;
    return *this;
  }

private:
  void* data_;
  std::size_t size_;

#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
  asio::detail::function<void()> debug_check_;
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
};

#if !defined(ASIO_NO_DEPRECATED)

class mutable_buffers_1
  : public mutable_buffer
{
public:
  typedef mutable_buffer value_type;

  typedef const mutable_buffer* const_iterator;

  mutable_buffers_1(void* data, std::size_t size) ASIO_NOEXCEPT
    : mutable_buffer(data, size)
  {
  }

#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
  mutable_buffers_1(void* data, std::size_t size,
      asio::detail::function<void()> debug_check)
    : mutable_buffer(data, size, debug_check)
  {
  }
#endif // ASIO_ENABLE_BUFFER_DEBUGGING

  explicit mutable_buffers_1(const mutable_buffer& b) ASIO_NOEXCEPT
    : mutable_buffer(b)
  {
  }

  const_iterator begin() const ASIO_NOEXCEPT
  {
    return this;
  }

  const_iterator end() const ASIO_NOEXCEPT
  {
    return begin() + 1;
  }
};

#endif // !defined(ASIO_NO_DEPRECATED)


class const_buffer
{
public:
  const_buffer() ASIO_NOEXCEPT
    : data_(0),
      size_(0)
  {
  }

  const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
    : data_(data),
      size_(size)
  {
  }

  const_buffer(const mutable_buffer& b) ASIO_NOEXCEPT
    : data_(b.data()),
      size_(b.size())
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , debug_check_(b.get_debug_check())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
  {
  }

#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
  const_buffer(const void* data, std::size_t size,
      asio::detail::function<void()> debug_check)
    : data_(data),
      size_(size),
      debug_check_(debug_check)
  {
  }

  const asio::detail::function<void()>& get_debug_check() const
  {
    return debug_check_;
  }
#endif // ASIO_ENABLE_BUFFER_DEBUGGING

  const void* data() const ASIO_NOEXCEPT
  {
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
    if (size_ && debug_check_)
      debug_check_();
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
    return data_;
  }

  std::size_t size() const ASIO_NOEXCEPT
  {
    return size_;
  }

  const_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
  {
    std::size_t offset = n < size_ ? n : size_;
    data_ = static_cast<const char*>(data_) + offset;
    size_ -= offset;
    return *this;
  }

private:
  const void* data_;
  std::size_t size_;

#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
  asio::detail::function<void()> debug_check_;
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
};

#if !defined(ASIO_NO_DEPRECATED)

class const_buffers_1
  : public const_buffer
{
public:
  typedef const_buffer value_type;

  typedef const const_buffer* const_iterator;

  const_buffers_1(const void* data, std::size_t size) ASIO_NOEXCEPT
    : const_buffer(data, size)
  {
  }

#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
  const_buffers_1(const void* data, std::size_t size,
      asio::detail::function<void()> debug_check)
    : const_buffer(data, size, debug_check)
  {
  }
#endif // ASIO_ENABLE_BUFFER_DEBUGGING

  explicit const_buffers_1(const const_buffer& b) ASIO_NOEXCEPT
    : const_buffer(b)
  {
  }

  const_iterator begin() const ASIO_NOEXCEPT
  {
    return this;
  }

  const_iterator end() const ASIO_NOEXCEPT
  {
    return begin() + 1;
  }
};

#endif // !defined(ASIO_NO_DEPRECATED)

class null_buffers
{
public:
  typedef mutable_buffer value_type;

  typedef const mutable_buffer* const_iterator;

  const_iterator begin() const ASIO_NOEXCEPT
  {
    return &buf_;
  }

  const_iterator end() const ASIO_NOEXCEPT
  {
    return &buf_;
  }

private:
  mutable_buffer buf_;
};


template <typename MutableBuffer>
inline const mutable_buffer* buffer_sequence_begin(const MutableBuffer& b,
    typename enable_if<
      is_convertible<const MutableBuffer*, const mutable_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT
{
  return static_cast<const mutable_buffer*>(detail::addressof(b));
}

template <typename ConstBuffer>
inline const const_buffer* buffer_sequence_begin(const ConstBuffer& b,
    typename enable_if<
      is_convertible<const ConstBuffer*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT
{
  return static_cast<const const_buffer*>(detail::addressof(b));
}

#if defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)

template <typename C>
inline auto buffer_sequence_begin(C& c,
    typename enable_if<
      !is_convertible<const C*, const mutable_buffer*>::value
        && !is_convertible<const C*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT -> decltype(c.begin())
{
  return c.begin();
}

template <typename C>
inline auto buffer_sequence_begin(const C& c,
    typename enable_if<
      !is_convertible<const C*, const mutable_buffer*>::value
        && !is_convertible<const C*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT -> decltype(c.begin())
{
  return c.begin();
}

#else // defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)

template <typename C>
inline typename C::iterator buffer_sequence_begin(C& c,
    typename enable_if<
      !is_convertible<const C*, const mutable_buffer*>::value
        && !is_convertible<const C*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT
{
  return c.begin();
}

template <typename C>
inline typename C::const_iterator buffer_sequence_begin(const C& c,
    typename enable_if<
      !is_convertible<const C*, const mutable_buffer*>::value
        && !is_convertible<const C*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT
{
  return c.begin();
}

#endif // defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)


template <typename MutableBuffer>
inline const mutable_buffer* buffer_sequence_end(const MutableBuffer& b,
    typename enable_if<
      is_convertible<const MutableBuffer*, const mutable_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT
{
  return static_cast<const mutable_buffer*>(detail::addressof(b)) + 1;
}

template <typename ConstBuffer>
inline const const_buffer* buffer_sequence_end(const ConstBuffer& b,
    typename enable_if<
      is_convertible<const ConstBuffer*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT
{
  return static_cast<const const_buffer*>(detail::addressof(b)) + 1;
}

#if defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)

template <typename C>
inline auto buffer_sequence_end(C& c,
    typename enable_if<
      !is_convertible<const C*, const mutable_buffer*>::value
        && !is_convertible<const C*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT -> decltype(c.end())
{
  return c.end();
}

template <typename C>
inline auto buffer_sequence_end(const C& c,
    typename enable_if<
      !is_convertible<const C*, const mutable_buffer*>::value
        && !is_convertible<const C*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT -> decltype(c.end())
{
  return c.end();
}

#else // defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)

template <typename C>
inline typename C::iterator buffer_sequence_end(C& c,
    typename enable_if<
      !is_convertible<const C*, const mutable_buffer*>::value
        && !is_convertible<const C*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT
{
  return c.end();
}

template <typename C>
inline typename C::const_iterator buffer_sequence_end(const C& c,
    typename enable_if<
      !is_convertible<const C*, const mutable_buffer*>::value
        && !is_convertible<const C*, const const_buffer*>::value
    >::type* = 0) ASIO_NOEXCEPT
{
  return c.end();
}

#endif // defined(ASIO_HAS_DECLTYPE) || defined(GENERATING_DOCUMENTATION)

namespace detail {

// Tag types used to select appropriately optimised overloads.
struct one_buffer {};
struct multiple_buffers {};

// Helper trait to detect single buffers.
template <typename BufferSequence>
struct buffer_sequence_cardinality :
  conditional<
    is_same<BufferSequence, mutable_buffer>::value
#if !defined(ASIO_NO_DEPRECATED)
      || is_same<BufferSequence, mutable_buffers_1>::value
      || is_same<BufferSequence, const_buffers_1>::value
#endif // !defined(ASIO_NO_DEPRECATED)
      || is_same<BufferSequence, const_buffer>::value,
    one_buffer, multiple_buffers>::type {};

template <typename Iterator>
inline std::size_t buffer_size(one_buffer,
    Iterator begin, Iterator) ASIO_NOEXCEPT
{
  return const_buffer(*begin).size();
}

template <typename Iterator>
inline std::size_t buffer_size(multiple_buffers,
    Iterator begin, Iterator end) ASIO_NOEXCEPT
{
  std::size_t total_buffer_size = 0;

  Iterator iter = begin;
  for (; iter != end; ++iter)
  {
    const_buffer b(*iter);
    total_buffer_size += b.size();
  }

  return total_buffer_size;
}

} // namespace detail


template <typename BufferSequence>
inline std::size_t buffer_size(const BufferSequence& b) ASIO_NOEXCEPT
{
  return detail::buffer_size(
      detail::buffer_sequence_cardinality<BufferSequence>(),
      asio::buffer_sequence_begin(b),
      asio::buffer_sequence_end(b));
}

#if !defined(ASIO_NO_DEPRECATED)


template <typename PointerToPodType>
inline PointerToPodType buffer_cast(const mutable_buffer& b) ASIO_NOEXCEPT
{
  return static_cast<PointerToPodType>(b.data());
}

template <typename PointerToPodType>
inline PointerToPodType buffer_cast(const const_buffer& b) ASIO_NOEXCEPT
{
  return static_cast<PointerToPodType>(b.data());
}

#endif // !defined(ASIO_NO_DEPRECATED)


inline mutable_buffer operator+(const mutable_buffer& b,
    std::size_t n) ASIO_NOEXCEPT
{
  std::size_t offset = n < b.size() ? n : b.size();
  char* new_data = static_cast<char*>(b.data()) + offset;
  std::size_t new_size = b.size() - offset;
  return mutable_buffer(new_data, new_size
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , b.get_debug_check()
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


inline mutable_buffer operator+(std::size_t n,
    const mutable_buffer& b) ASIO_NOEXCEPT
{
  return b + n;
}


inline const_buffer operator+(const const_buffer& b,
    std::size_t n) ASIO_NOEXCEPT
{
  std::size_t offset = n < b.size() ? n : b.size();
  const char* new_data = static_cast<const char*>(b.data()) + offset;
  std::size_t new_size = b.size() - offset;
  return const_buffer(new_data, new_size
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , b.get_debug_check()
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


inline const_buffer operator+(std::size_t n,
    const const_buffer& b) ASIO_NOEXCEPT
{
  return b + n;
}

#if defined(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 defined(ASIO_MSVC) && (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 // defined(ASIO_MSVC) && (ASIO_MSVC == 1400)
  }

  void operator()()
  {
    (void)*iter_;
  }

private:
  Iterator iter_;
};

} // namespace detail
#endif // ASIO_ENABLE_BUFFER_DEBUGGING


#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
# define ASIO_MUTABLE_BUFFER mutable_buffer
# define ASIO_CONST_BUFFER const_buffer
#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
# define ASIO_MUTABLE_BUFFER mutable_buffers_1
# define ASIO_CONST_BUFFER const_buffers_1
#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)


inline ASIO_MUTABLE_BUFFER buffer(
    const mutable_buffer& b) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(b);
}


inline ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(
      mutable_buffer(b.data(),
        b.size() < max_size_in_bytes
        ? b.size() : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
        , b.get_debug_check()
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
        ));
}


inline ASIO_CONST_BUFFER buffer(
    const const_buffer& b) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(b);
}


inline ASIO_CONST_BUFFER buffer(const const_buffer& b,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(b.data(),
      b.size() < max_size_in_bytes
      ? b.size() : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , b.get_debug_check()
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


inline ASIO_MUTABLE_BUFFER buffer(void* data,
    std::size_t size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data, size_in_bytes);
}


inline ASIO_CONST_BUFFER buffer(const void* data,
    std::size_t size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data, size_in_bytes);
}


template <typename PodType, std::size_t N>
inline ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data, N * sizeof(PodType));
}
 

template <typename PodType, std::size_t N>
inline ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data,
      N * sizeof(PodType) < max_size_in_bytes
      ? N * sizeof(PodType) : max_size_in_bytes);
}
 

template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(
    const PodType (&data)[N]) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data, N * sizeof(PodType));
}


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(const PodType (&data)[N],
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data,
      N * sizeof(PodType) < max_size_in_bytes
      ? N * sizeof(PodType) : max_size_in_bytes);
}

#if defined(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 ASIO_MUTABLE_BUFFER container_type;
};

template <>
struct buffer_types_base<true>
{
  typedef const_buffer buffer_type;
  typedef 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) ASIO_NOEXCEPT
{
  typedef typename asio::detail::buffer_types<PodType>::buffer_type
    buffer_type;
  typedef typename 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) ASIO_NOEXCEPT
{
  typedef typename asio::detail::buffer_types<PodType>::buffer_type
    buffer_type;
  typedef typename 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(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)


template <typename PodType, std::size_t N>
inline ASIO_MUTABLE_BUFFER buffer(
    boost::array<PodType, N>& data) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(
      data.c_array(), data.size() * sizeof(PodType));
}


template <typename PodType, std::size_t N>
inline ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data.c_array(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(
    boost::array<const PodType, N>& data) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
}


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}

#endif // defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(
    const boost::array<PodType, N>& data) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
}


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}

#if defined(ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)


template <typename PodType, std::size_t N>
inline ASIO_MUTABLE_BUFFER buffer(
    std::array<PodType, N>& data) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data.data(), data.size() * sizeof(PodType));
}


template <typename PodType, std::size_t N>
inline ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(
    std::array<const PodType, N>& data) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
}


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(
    const std::array<PodType, N>& data) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
}


template <typename PodType, std::size_t N>
inline ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}

#endif // defined(ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)


template <typename PodType, typename Allocator>
inline ASIO_MUTABLE_BUFFER buffer(
    std::vector<PodType, Allocator>& data) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(
      data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::vector<PodType, Allocator>::iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


template <typename PodType, typename Allocator>
inline ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::vector<PodType, Allocator>::iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


template <typename PodType, typename Allocator>
inline ASIO_CONST_BUFFER buffer(
    const std::vector<PodType, Allocator>& data) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(
      data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::vector<PodType, Allocator>::const_iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


template <typename PodType, typename Allocator>
inline ASIO_CONST_BUFFER buffer(
    const std::vector<PodType, Allocator>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::vector<PodType, Allocator>::const_iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


template <typename Elem, typename Traits, typename Allocator>
inline ASIO_MUTABLE_BUFFER buffer(
    std::basic_string<Elem, Traits, Allocator>& data) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
      data.size() * sizeof(Elem)
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::basic_string<Elem, Traits, Allocator>::iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


template <typename Elem, typename Traits, typename Allocator>
inline ASIO_MUTABLE_BUFFER buffer(
    std::basic_string<Elem, Traits, Allocator>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
      data.size() * sizeof(Elem) < max_size_in_bytes
      ? data.size() * sizeof(Elem) : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::basic_string<Elem, Traits, Allocator>::iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


template <typename Elem, typename Traits, typename Allocator>
inline ASIO_CONST_BUFFER buffer(
    const std::basic_string<Elem, Traits, Allocator>& data) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(Elem)
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::basic_string<Elem, Traits, Allocator>::const_iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


template <typename Elem, typename Traits, typename Allocator>
inline ASIO_CONST_BUFFER buffer(
    const std::basic_string<Elem, Traits, Allocator>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.data(),
      data.size() * sizeof(Elem) < max_size_in_bytes
      ? data.size() * sizeof(Elem) : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::basic_string<Elem, Traits, Allocator>::const_iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}

#if defined(ASIO_HAS_STRING_VIEW) \
  || defined(GENERATING_DOCUMENTATION)


template <typename Elem, typename Traits>
inline ASIO_CONST_BUFFER buffer(
    basic_string_view<Elem, Traits> data) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
      data.size() * sizeof(Elem)
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename basic_string_view<Elem, Traits>::iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}


template <typename Elem, typename Traits>
inline ASIO_CONST_BUFFER buffer(
    basic_string_view<Elem, Traits> data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
      data.size() * sizeof(Elem) < max_size_in_bytes
      ? data.size() * sizeof(Elem) : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename basic_string_view<Elem, Traits>::iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}

#endif // defined(ASIO_HAS_STRING_VIEW)
       //  || defined(GENERATING_DOCUMENTATION)


template <typename Elem, typename Traits, typename Allocator>
class dynamic_string_buffer
{
public:
  typedef ASIO_CONST_BUFFER const_buffers_type;

  typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;


  explicit dynamic_string_buffer(std::basic_string<Elem, Traits, Allocator>& s,
      std::size_t maximum_size =
        (std::numeric_limits<std::size_t>::max)()) ASIO_NOEXCEPT
    : string_(s),
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      size_((std::numeric_limits<std::size_t>::max)()),
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      max_size_(maximum_size)
  {
  }

  dynamic_string_buffer(const dynamic_string_buffer& other) ASIO_NOEXCEPT
    : string_(other.string_),
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      size_(other.size_),
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      max_size_(other.max_size_)
  {
  }

#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
  dynamic_string_buffer(dynamic_string_buffer&& other) ASIO_NOEXCEPT
    : string_(other.string_),
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      size_(other.size_),
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      max_size_(other.max_size_)
  {
  }
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)


  std::size_t size() const ASIO_NOEXCEPT
  {
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
    if (size_ != (std::numeric_limits<std::size_t>::max)())
      return size_;
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
    return (std::min)(string_.size(), max_size());
  }


  std::size_t max_size() const ASIO_NOEXCEPT
  {
    return max_size_;
  }


  std::size_t capacity() const ASIO_NOEXCEPT
  {
    return (std::min)(string_.capacity(), max_size());
  }

#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  const_buffers_type data() const ASIO_NOEXCEPT
  {
    return const_buffers_type(asio::buffer(string_, size_));
  }
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)


  mutable_buffers_type data(std::size_t pos, std::size_t n) ASIO_NOEXCEPT
  {
    return mutable_buffers_type(asio::buffer(
          asio::buffer(string_, max_size_) + pos, n));
  }


  const_buffers_type data(std::size_t pos,
      std::size_t n) const ASIO_NOEXCEPT
  {
    return const_buffers_type(asio::buffer(
          asio::buffer(string_, max_size_) + pos, n));
  }

#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  mutable_buffers_type prepare(std::size_t n)
  {
    if (size() > max_size() || max_size() - size() < n)
    {
      std::length_error ex("dynamic_string_buffer too long");
      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 asio::buffer(asio::buffer(string_) + size_, n);
  }


  void commit(std::size_t n)
  {
    size_ += (std::min)(n, string_.size() - size_);
    string_.resize(size_);
  }
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)


  void grow(std::size_t n)
  {
    if (size() > max_size() || max_size() - size() < n)
    {
      std::length_error ex("dynamic_string_buffer too long");
      asio::detail::throw_exception(ex);
    }

    string_.resize(size() + n);
  }


  void shrink(std::size_t n)
  {
    string_.resize(n > size() ? 0 : size() - n);
  }


  void consume(std::size_t n)
  {
#if !defined(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(ASIO_NO_DYNAMIC_BUFFER_V1)
    string_.erase(0, n);
  }

private:
  std::basic_string<Elem, Traits, Allocator>& string_;
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
  std::size_t size_;
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
  const std::size_t max_size_;
};


template <typename Elem, typename Allocator>
class dynamic_vector_buffer
{
public:
  typedef ASIO_CONST_BUFFER const_buffers_type;

  typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;


  explicit dynamic_vector_buffer(std::vector<Elem, Allocator>& v,
      std::size_t maximum_size =
        (std::numeric_limits<std::size_t>::max)()) ASIO_NOEXCEPT
    : vector_(v),
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      size_((std::numeric_limits<std::size_t>::max)()),
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      max_size_(maximum_size)
  {
  }

  dynamic_vector_buffer(const dynamic_vector_buffer& other) ASIO_NOEXCEPT
    : vector_(other.vector_),
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      size_(other.size_),
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      max_size_(other.max_size_)
  {
  }

#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
  dynamic_vector_buffer(dynamic_vector_buffer&& other) ASIO_NOEXCEPT
    : vector_(other.vector_),
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      size_(other.size_),
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
      max_size_(other.max_size_)
  {
  }
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)


  std::size_t size() const ASIO_NOEXCEPT
  {
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
    if (size_ != (std::numeric_limits<std::size_t>::max)())
      return size_;
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
    return (std::min)(vector_.size(), max_size());
  }


  std::size_t max_size() const ASIO_NOEXCEPT
  {
    return max_size_;
  }


  std::size_t capacity() const ASIO_NOEXCEPT
  {
    return (std::min)(vector_.capacity(), max_size());
  }

#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  const_buffers_type data() const ASIO_NOEXCEPT
  {
    return const_buffers_type(asio::buffer(vector_, size_));
  }
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)


  mutable_buffers_type data(std::size_t pos, std::size_t n) ASIO_NOEXCEPT
  {
    return mutable_buffers_type(asio::buffer(
          asio::buffer(vector_, max_size_) + pos, n));
  }


  const_buffers_type data(std::size_t pos,
      std::size_t n) const ASIO_NOEXCEPT
  {
    return const_buffers_type(asio::buffer(
          asio::buffer(vector_, max_size_) + pos, n));
  }

#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

  mutable_buffers_type prepare(std::size_t n)
  {
    if (size () > max_size() || max_size() - size() < n)
    {
      std::length_error ex("dynamic_vector_buffer too long");
      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 asio::buffer(asio::buffer(vector_) + size_, n);
  }


  void commit(std::size_t n)
  {
    size_ += (std::min)(n, vector_.size() - size_);
    vector_.resize(size_);
  }
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)


  void grow(std::size_t n)
  {
    if (size() > max_size() || max_size() - size() < n)
    {
      std::length_error ex("dynamic_vector_buffer too long");
      asio::detail::throw_exception(ex);
    }

    vector_.resize(size() + n);
  }


  void shrink(std::size_t n)
  {
    vector_.resize(n > size() ? 0 : size() - n);
  }


  void consume(std::size_t n)
  {
#if !defined(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(ASIO_NO_DYNAMIC_BUFFER_V1)
    vector_.erase(vector_.begin(), vector_.begin() + (std::min)(size(), n));
  }

private:
  std::vector<Elem, Allocator>& vector_;
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
  std::size_t size_;
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
  const std::size_t max_size_;
};



template <typename Elem, typename Traits, typename Allocator>
inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
    std::basic_string<Elem, Traits, Allocator>& data) ASIO_NOEXCEPT
{
  return dynamic_string_buffer<Elem, Traits, Allocator>(data);
}


template <typename Elem, typename Traits, typename Allocator>
inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
    std::basic_string<Elem, Traits, Allocator>& data,
    std::size_t max_size) ASIO_NOEXCEPT
{
  return dynamic_string_buffer<Elem, Traits, Allocator>(data, max_size);
}


template <typename Elem, typename Allocator>
inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
    std::vector<Elem, Allocator>& data) ASIO_NOEXCEPT
{
  return dynamic_vector_buffer<Elem, Allocator>(data);
}


template <typename Elem, typename Allocator>
inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
    std::vector<Elem, Allocator>& data,
    std::size_t max_size) ASIO_NOEXCEPT
{
  return dynamic_vector_buffer<Elem, Allocator>(data, max_size);
}


namespace detail {

inline std::size_t buffer_copy_1(const mutable_buffer& target,
    const const_buffer& source)
{
  using namespace std; // For memcpy.
  std::size_t target_size = target.size();
  std::size_t source_size = source.size();
  std::size_t n = target_size < source_size ? target_size : source_size;
  if (n > 0)
    memcpy(target.data(), source.data(), n);
  return n;
}

template <typename TargetIterator, typename SourceIterator>
inline std::size_t buffer_copy(one_buffer, one_buffer,
    TargetIterator target_begin, TargetIterator,
    SourceIterator source_begin, SourceIterator) ASIO_NOEXCEPT
{
  return (buffer_copy_1)(*target_begin, *source_begin);
}

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) ASIO_NOEXCEPT
{
  return (buffer_copy_1)(*target_begin,
      asio::buffer(*source_begin, max_bytes_to_copy));
}

template <typename TargetIterator, typename SourceIterator>
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)()) ASIO_NOEXCEPT
{
  std::size_t total_bytes_copied = 0;
  SourceIterator source_iter = source_begin;

  for (mutable_buffer target_buffer(
        asio::buffer(*target_begin, max_bytes_to_copy));
      target_buffer.size() && source_iter != source_end; ++source_iter)
  {
    const_buffer source_buffer(*source_iter);
    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
    total_bytes_copied += bytes_copied;
    target_buffer += bytes_copied;
  }

  return total_bytes_copied;
}

template <typename TargetIterator, typename SourceIterator>
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)()) ASIO_NOEXCEPT
{
  std::size_t total_bytes_copied = 0;
  TargetIterator target_iter = target_begin;

  for (const_buffer source_buffer(
        asio::buffer(*source_begin, max_bytes_to_copy));
      source_buffer.size() && target_iter != target_end; ++target_iter)
  {
    mutable_buffer target_buffer(*target_iter);
    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
    total_bytes_copied += bytes_copied;
    source_buffer += bytes_copied;
  }

  return total_bytes_copied;
}

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) ASIO_NOEXCEPT
{
  std::size_t total_bytes_copied = 0;

  TargetIterator target_iter = target_begin;
  std::size_t target_buffer_offset = 0;

  SourceIterator source_iter = source_begin;
  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_1)(target_buffer, source_buffer);
    total_bytes_copied += bytes_copied;

    if (bytes_copied == target_buffer.size())
    {
      ++target_iter;
      target_buffer_offset = 0;
    }
    else
      target_buffer_offset += bytes_copied;

    if (bytes_copied == source_buffer.size())
    {
      ++source_iter;
      source_buffer_offset = 0;
    }
    else
      source_buffer_offset += bytes_copied;
  }

  return total_bytes_copied;
}

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) ASIO_NOEXCEPT
{
  std::size_t total_bytes_copied = 0;

  TargetIterator target_iter = target_begin;
  std::size_t target_buffer_offset = 0;

  SourceIterator source_iter = source_begin;
  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_1)(
        target_buffer, asio::buffer(source_buffer,
          max_bytes_to_copy - total_bytes_copied));
    total_bytes_copied += bytes_copied;

    if (bytes_copied == target_buffer.size())
    {
      ++target_iter;
      target_buffer_offset = 0;
    }
    else
      target_buffer_offset += bytes_copied;

    if (bytes_copied == source_buffer.size())
    {
      ++source_iter;
      source_buffer_offset = 0;
    }
    else
      source_buffer_offset += bytes_copied;
  }

  return total_bytes_copied;
}

} // namespace detail


template <typename MutableBufferSequence, typename ConstBufferSequence>
inline std::size_t buffer_copy(const MutableBufferSequence& target,
    const ConstBufferSequence& source) ASIO_NOEXCEPT
{
  return detail::buffer_copy(
      detail::buffer_sequence_cardinality<MutableBufferSequence>(),
      detail::buffer_sequence_cardinality<ConstBufferSequence>(),
      asio::buffer_sequence_begin(target),
      asio::buffer_sequence_end(target),
      asio::buffer_sequence_begin(source),
      asio::buffer_sequence_end(source));
}


template <typename MutableBufferSequence, typename ConstBufferSequence>
inline std::size_t buffer_copy(const MutableBufferSequence& target,
    const ConstBufferSequence& source,
    std::size_t max_bytes_to_copy) ASIO_NOEXCEPT
{
  return detail::buffer_copy(
      detail::buffer_sequence_cardinality<MutableBufferSequence>(),
      detail::buffer_sequence_cardinality<ConstBufferSequence>(),
      asio::buffer_sequence_begin(target),
      asio::buffer_sequence_end(target),
      asio::buffer_sequence_begin(source),
      asio::buffer_sequence_end(source), max_bytes_to_copy);
}

} // namespace asio

#include "asio/detail/pop_options.hpp"
#include "asio/detail/is_buffer_sequence.hpp"
#include "asio/detail/push_options.hpp"

namespace asio {

template <typename T>
struct is_mutable_buffer_sequence
#if defined(GENERATING_DOCUMENTATION)
  : integral_constant<bool, automatically_determined>
#else // defined(GENERATING_DOCUMENTATION)
  : asio::detail::is_buffer_sequence<T, mutable_buffer>
#endif // defined(GENERATING_DOCUMENTATION)
{
};

template <typename T>
struct is_const_buffer_sequence
#if defined(GENERATING_DOCUMENTATION)
  : integral_constant<bool, automatically_determined>
#else // defined(GENERATING_DOCUMENTATION)
  : asio::detail::is_buffer_sequence<T, const_buffer>
#endif // defined(GENERATING_DOCUMENTATION)
{
};

#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
template <typename T>
struct is_dynamic_buffer_v1
#if defined(GENERATING_DOCUMENTATION)
  : integral_constant<bool, automatically_determined>
#else // defined(GENERATING_DOCUMENTATION)
  : asio::detail::is_dynamic_buffer_v1<T>
#endif // defined(GENERATING_DOCUMENTATION)
{
};
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)

template <typename T>
struct is_dynamic_buffer_v2
#if defined(GENERATING_DOCUMENTATION)
  : integral_constant<bool, automatically_determined>
#else // defined(GENERATING_DOCUMENTATION)
  : asio::detail::is_dynamic_buffer_v2<T>
#endif // defined(GENERATING_DOCUMENTATION)
{
};


template <typename T>
struct is_dynamic_buffer
#if defined(GENERATING_DOCUMENTATION)
  : integral_constant<bool, automatically_determined>
#elif defined(ASIO_NO_DYNAMIC_BUFFER_V1)
  : asio::is_dynamic_buffer_v2<T>
#else // defined(ASIO_NO_DYNAMIC_BUFFER_V1)
  : asio::is_dynamic_buffer_v1<T>
#endif // defined(ASIO_NO_DYNAMIC_BUFFER_V1)
{
};

} // namespace asio

#include "asio/detail/pop_options.hpp"

#endif // ASIO_BUFFER_HPP