Moved the project in to it's own directory libsecondlife
git-svn-id: http://libopenmetaverse.googlecode.com/svn/trunk@18 52acb1d6-8a22-11de-b505-999d5b087335
This commit is contained in:
John Hurliman
625
libsecondlife/include/boost/asio/buffer.hpp
Normal file
625
libsecondlife/include/boost/asio/buffer.hpp
Normal file
@@ -0,0 +1,625 @@
|
||||
//
|
||||
// buffer.hpp
|
||||
// ~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2005 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/push_options.hpp>
|
||||
|
||||
#include <boost/asio/detail/push_options.hpp>
|
||||
#include <cstddef>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/array.hpp>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <boost/asio/detail/pop_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 const_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.
|
||||
*/
|
||||
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)
|
||||
{
|
||||
}
|
||||
|
||||
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_;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
inline void* buffer_cast_helper(const mutable_buffer& b)
|
||||
{
|
||||
return b.data_;
|
||||
}
|
||||
|
||||
inline std::size_t buffer_size_helper(const mutable_buffer& b)
|
||||
{
|
||||
return b.size_;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/// Cast a non-modifiable buffer to a specified pointer to POD type.
|
||||
/**
|
||||
* @relates mutable_buffer
|
||||
*/
|
||||
template <typename Pointer_To_Pod_Type>
|
||||
inline Pointer_To_Pod_Type buffer_cast(const mutable_buffer& b)
|
||||
{
|
||||
return static_cast<Pointer_To_Pod_Type>(detail::buffer_cast_helper(b));
|
||||
}
|
||||
|
||||
/// Get the number of bytes in a non-modifiable buffer.
|
||||
/**
|
||||
* @relates mutable_buffer
|
||||
*/
|
||||
inline std::size_t buffer_size(const mutable_buffer& b)
|
||||
{
|
||||
return detail::buffer_size_helper(b);
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that is offset from the start of another.
|
||||
/**
|
||||
* @relates mutable_buffer
|
||||
*/
|
||||
inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
|
||||
{
|
||||
if (start > buffer_size(b))
|
||||
return mutable_buffer();
|
||||
char* new_data = buffer_cast<char*>(b) + start;
|
||||
std::size_t new_size = buffer_size(b) - start;
|
||||
return mutable_buffer(new_data, new_size);
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that is offset from the start of another.
|
||||
/**
|
||||
* @relates mutable_buffer
|
||||
*/
|
||||
inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
|
||||
{
|
||||
if (start > buffer_size(b))
|
||||
return mutable_buffer();
|
||||
char* new_data = buffer_cast<char*>(b) + start;
|
||||
std::size_t new_size = buffer_size(b) - start;
|
||||
return mutable_buffer(new_data, new_size);
|
||||
}
|
||||
|
||||
/// Adapts a single modifiable buffer so that it meets the requirements of the
|
||||
/// Mutable_Buffers concept.
|
||||
class mutable_buffer_container_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 or modify elements.
|
||||
typedef mutable_buffer* iterator;
|
||||
|
||||
/// A random-access iterator type that may be used to read elements.
|
||||
typedef const mutable_buffer* const_iterator;
|
||||
|
||||
/// Construct to represent a single modifiable buffer.
|
||||
explicit mutable_buffer_container_1(const mutable_buffer& b)
|
||||
: mutable_buffer(b)
|
||||
{
|
||||
}
|
||||
|
||||
/// Get a random-access iterator to the first element.
|
||||
iterator begin()
|
||||
{
|
||||
return this;
|
||||
}
|
||||
|
||||
/// Get a random-access iterator to the first element.
|
||||
const_iterator begin() const
|
||||
{
|
||||
return this;
|
||||
}
|
||||
|
||||
/// Get a random-access iterator for one past the last element.
|
||||
iterator end()
|
||||
{
|
||||
return begin() + 1;
|
||||
}
|
||||
|
||||
/// Get a random-access iterator for one past the last element.
|
||||
const_iterator end() const
|
||||
{
|
||||
return begin() + 1;
|
||||
}
|
||||
};
|
||||
|
||||
/// Holds a buffer that cannot be modified.
|
||||
/**
|
||||
* The const_buffer class provides a safe representation of a buffer that cannot
|
||||
* be modified. It does not own the underlying data, and so is cheap to copy or
|
||||
* assign.
|
||||
*/
|
||||
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))
|
||||
{
|
||||
}
|
||||
|
||||
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_;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
inline const void* buffer_cast_helper(const const_buffer& b)
|
||||
{
|
||||
return b.data_;
|
||||
}
|
||||
|
||||
inline std::size_t buffer_size_helper(const const_buffer& b)
|
||||
{
|
||||
return b.size_;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/// Cast a non-modifiable buffer to a specified pointer to POD type.
|
||||
/**
|
||||
* @relates const_buffer
|
||||
*/
|
||||
template <typename Pointer_To_Pod_Type>
|
||||
inline Pointer_To_Pod_Type buffer_cast(const const_buffer& b)
|
||||
{
|
||||
return static_cast<Pointer_To_Pod_Type>(detail::buffer_cast_helper(b));
|
||||
}
|
||||
|
||||
/// Get the number of bytes in a non-modifiable buffer.
|
||||
/**
|
||||
* @relates const_buffer
|
||||
*/
|
||||
inline std::size_t buffer_size(const const_buffer& b)
|
||||
{
|
||||
return detail::buffer_size_helper(b);
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that is offset from the start of another.
|
||||
/**
|
||||
* @relates const_buffer
|
||||
*/
|
||||
inline const_buffer operator+(const const_buffer& b, std::size_t start)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
/// 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);
|
||||
}
|
||||
|
||||
/// Adapts a single non-modifiable buffer so that it meets the requirements of
|
||||
/// the Const_Buffers concept.
|
||||
class const_buffer_container_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 or modify elements.
|
||||
typedef const_buffer* iterator;
|
||||
|
||||
/// A random-access iterator type that may be used to read elements.
|
||||
typedef const const_buffer* const_iterator;
|
||||
|
||||
/// Construct to represent a single non-modifiable buffer.
|
||||
explicit const_buffer_container_1(const const_buffer& b)
|
||||
: const_buffer(b)
|
||||
{
|
||||
}
|
||||
|
||||
/// Get a random-access iterator to the first element.
|
||||
iterator begin()
|
||||
{
|
||||
return this;
|
||||
}
|
||||
|
||||
/// Get a random-access iterator to the first element.
|
||||
const_iterator begin() const
|
||||
{
|
||||
return this;
|
||||
}
|
||||
|
||||
/// Get a random-access iterator for one past the last element.
|
||||
iterator end()
|
||||
{
|
||||
return begin() + 1;
|
||||
}
|
||||
|
||||
/// Get a random-access iterator for one past the last element.
|
||||
const_iterator end() const
|
||||
{
|
||||
return begin() + 1;
|
||||
}
|
||||
};
|
||||
|
||||
/** @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, or a vector of POD elements.
|
||||
*
|
||||
* The simplest use case involves reading or writing a single buffer of a
|
||||
* specified size:
|
||||
*
|
||||
* @code sock.write(boost::asio::buffer(data, size)); @endcode
|
||||
*
|
||||
* In the above example, the return value of boost::asio::buffer meets the
|
||||
* requirements of the Const_Buffers concept so that it may be directly passed
|
||||
* to the socket's write function. A buffer created for modifiable memory also
|
||||
* meets the requirements of the Mutable_Buffers concept.
|
||||
*
|
||||
* An individual buffer may be created from a builtin array, std::vector or
|
||||
* boost::array of POD elements. This helps prevent buffer overruns by
|
||||
* automatically determining the size of the buffer:
|
||||
*
|
||||
* @code char d1[128];
|
||||
* size_t bytes_transferred = sock.read(boost::asio::buffer(d1));
|
||||
*
|
||||
* std::vector<char> d2(128);
|
||||
* bytes_transferred = sock.read(boost::asio::buffer(d2));
|
||||
*
|
||||
* boost::array<char, 128> d3;
|
||||
* bytes_transferred = sock.read(boost::asio::buffer(d3)); @endcode
|
||||
*
|
||||
* To read or write using multiple buffers (i.e. scatter-gather I/O), multiple
|
||||
* buffer objects may be assigned into a container that supports the
|
||||
* Mutable_Buffers (for read) or Const_Buffers (for write) concepts:
|
||||
*
|
||||
* @code
|
||||
* char d1[128];
|
||||
* std::vector<char> d2(128);
|
||||
* boost::array<char, 128> d3;
|
||||
*
|
||||
* boost::array<mutable_buffer, 3> bufs1 = {
|
||||
* boost::asio::buffer(d1),
|
||||
* boost::asio::buffer(d2),
|
||||
* boost::asio::buffer(d3) };
|
||||
* bytes_transferred = sock.read(bufs1);
|
||||
*
|
||||
* std::vector<const_buffer> bufs2;
|
||||
* bufs2.push_back(boost::asio::buffer(d1));
|
||||
* bufs2.push_back(boost::asio::buffer(d2));
|
||||
* bufs2.push_back(boost::asio::buffer(d3));
|
||||
* bytes_transferred = sock.write(bufs2); @endcode
|
||||
*/
|
||||
/*@{*/
|
||||
|
||||
/// Create a new modifiable buffer from an existing buffer.
|
||||
inline mutable_buffer_container_1 buffer(const mutable_buffer& b)
|
||||
{
|
||||
return mutable_buffer_container_1(b);
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer from an existing buffer.
|
||||
inline mutable_buffer_container_1 buffer(const mutable_buffer& b,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return mutable_buffer_container_1(
|
||||
mutable_buffer(buffer_cast<void*>(b),
|
||||
buffer_size(b) < max_size_in_bytes
|
||||
? buffer_size(b) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer from an existing buffer.
|
||||
inline const_buffer_container_1 buffer(const const_buffer& b)
|
||||
{
|
||||
return const_buffer_container_1(b);
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer from an existing buffer.
|
||||
inline const_buffer_container_1 buffer(const const_buffer& b,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(buffer_cast<const void*>(b),
|
||||
buffer_size(b) < max_size_in_bytes
|
||||
? buffer_size(b) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that represents the given memory range.
|
||||
inline mutable_buffer_container_1 buffer(void* data, std::size_t size_in_bytes)
|
||||
{
|
||||
return mutable_buffer_container_1(mutable_buffer(data, size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given memory range.
|
||||
inline const_buffer_container_1 buffer(const void* data,
|
||||
std::size_t size_in_bytes)
|
||||
{
|
||||
return const_buffer_container_1(const_buffer(data, size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline mutable_buffer_container_1 buffer(Pod_Type (&data)[N])
|
||||
{
|
||||
return mutable_buffer_container_1(mutable_buffer(data, N * sizeof(Pod_Type)));
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline mutable_buffer_container_1 buffer(Pod_Type (&data)[N],
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return mutable_buffer_container_1(
|
||||
mutable_buffer(data,
|
||||
N * sizeof(Pod_Type) < max_size_in_bytes
|
||||
? N * sizeof(Pod_Type) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline const_buffer_container_1 buffer(const Pod_Type (&data)[N])
|
||||
{
|
||||
return const_buffer_container_1(const_buffer(data, N * sizeof(Pod_Type)));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline const_buffer_container_1 buffer(const Pod_Type (&data)[N],
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(data,
|
||||
N * sizeof(Pod_Type) < max_size_in_bytes
|
||||
? N * sizeof(Pod_Type) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline mutable_buffer_container_1 buffer(boost::array<Pod_Type, N>& data)
|
||||
{
|
||||
return mutable_buffer_container_1(
|
||||
mutable_buffer(data.c_array(), data.size() * sizeof(Pod_Type)));
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline mutable_buffer_container_1 buffer(boost::array<Pod_Type, N>& data,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return mutable_buffer_container_1(
|
||||
mutable_buffer(data.c_array(),
|
||||
data.size() * sizeof(Pod_Type) < max_size_in_bytes
|
||||
? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline const_buffer_container_1 buffer(const boost::array<Pod_Type, N>& data)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(data.data(), data.size() * sizeof(Pod_Type)));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline const_buffer_container_1 buffer(const boost::array<Pod_Type, N>& data,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(data.data(),
|
||||
data.size() * sizeof(Pod_Type) < max_size_in_bytes
|
||||
? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline const_buffer_container_1 buffer(boost::array<const Pod_Type, N>& data)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(data.data(), data.size() * sizeof(Pod_Type)));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD array.
|
||||
template <typename Pod_Type, std::size_t N>
|
||||
inline const_buffer_container_1 buffer(boost::array<const Pod_Type, N>& data,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(data.data(),
|
||||
data.size() * sizeof(Pod_Type) < max_size_in_bytes
|
||||
? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that represents the given POD vector.
|
||||
/**
|
||||
* @note The buffer is invalidated by any vector operation that would also
|
||||
* invalidate iterators.
|
||||
*/
|
||||
template <typename Pod_Type>
|
||||
inline mutable_buffer_container_1 buffer(std::vector<Pod_Type>& data)
|
||||
{
|
||||
return mutable_buffer_container_1(
|
||||
mutable_buffer(&data[0], data.size() * sizeof(Pod_Type)));
|
||||
}
|
||||
|
||||
/// Create a new modifiable buffer that represents the given POD vector.
|
||||
/**
|
||||
* @note The buffer is invalidated by any vector operation that would also
|
||||
* invalidate iterators.
|
||||
*/
|
||||
template <typename Pod_Type>
|
||||
inline mutable_buffer_container_1 buffer(std::vector<Pod_Type>& data,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return mutable_buffer_container_1(
|
||||
mutable_buffer(&data[0],
|
||||
data.size() * sizeof(Pod_Type) < max_size_in_bytes
|
||||
? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD vector.
|
||||
/**
|
||||
* @note The buffer is invalidated by any vector operation that would also
|
||||
* invalidate iterators.
|
||||
*/
|
||||
template <typename Pod_Type>
|
||||
inline const_buffer_container_1 buffer(const std::vector<Pod_Type>& data)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(&data[0], data.size() * sizeof(Pod_Type)));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD vector.
|
||||
/**
|
||||
* @note The buffer is invalidated by any vector operation that would also
|
||||
* invalidate iterators.
|
||||
*/
|
||||
template <typename Pod_Type>
|
||||
inline const_buffer_container_1 buffer(const std::vector<Pod_Type>& data,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(&data[0],
|
||||
data.size() * sizeof(Pod_Type) < max_size_in_bytes
|
||||
? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD vector.
|
||||
/**
|
||||
* @note The buffer is invalidated by any vector operation that would also
|
||||
* invalidate iterators.
|
||||
*/
|
||||
template <typename Pod_Type>
|
||||
inline const_buffer_container_1 buffer(std::vector<const Pod_Type>& data)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(&data[0], data.size() * sizeof(Pod_Type)));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given POD vector.
|
||||
/**
|
||||
* @note The buffer is invalidated by any vector operation that would also
|
||||
* invalidate iterators.
|
||||
*/
|
||||
template <typename Pod_Type>
|
||||
inline const_buffer_container_1 buffer(std::vector<const Pod_Type>& data,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(&data[0],
|
||||
data.size() * sizeof(Pod_Type) < max_size_in_bytes
|
||||
? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given string.
|
||||
/**
|
||||
* @note The buffer is invalidated by any non-const operation called on the
|
||||
* given string object.
|
||||
*/
|
||||
inline const_buffer_container_1 buffer(const std::string& data)
|
||||
{
|
||||
return const_buffer_container_1(const_buffer(data.data(), data.size()));
|
||||
}
|
||||
|
||||
/// Create a new non-modifiable buffer that represents the given string.
|
||||
/**
|
||||
* @note The buffer is invalidated by any non-const operation called on the
|
||||
* given string object.
|
||||
*/
|
||||
inline const_buffer_container_1 buffer(const std::string& data,
|
||||
std::size_t max_size_in_bytes)
|
||||
{
|
||||
return const_buffer_container_1(
|
||||
const_buffer(data.data(),
|
||||
data.size() < max_size_in_bytes
|
||||
? data.size() : max_size_in_bytes));
|
||||
}
|
||||
|
||||
/*@}*/
|
||||
|
||||
} // namespace asio
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/asio/detail/pop_options.hpp>
|
||||
|
||||
#endif // BOOST_ASIO_BUFFER_HPP
|
||||
Reference in New Issue
Block a user