Swift
summaryrefslogtreecommitdiffstats
path: root/3rdParty/Boost/src/boost/asio/buffer.hpp
diff options
context:
space:
mode:
authorTobias Markmann <tm@ayena.de>2014-10-19 20:22:58 (GMT)
committerTobias Markmann <tm@ayena.de>2014-10-20 13:49:33 (GMT)
commit6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch)
tree2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/asio/buffer.hpp
parent38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff)
downloadswift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip
swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2
Update Boost in 3rdParty to version 1.56.0.
This updates Boost in our 3rdParty directory to version 1.56.0. Updated our update.sh script to stop on error. Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to missing include of <iostream> with newer Boost. Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
Diffstat (limited to '3rdParty/Boost/src/boost/asio/buffer.hpp')
-rw-r--r--3rdParty/Boost/src/boost/asio/buffer.hpp149
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;