Automatically resizable buffer class based on std::streambuf.
template< typename Allocator = std::allocator<char>> class basic_streambuf : noncopyable
Name |
Description |
---|---|
The type used to represent the input sequence as a list of buffers. |
|
The type used to represent the output sequence as a list of buffers. |
Name |
Description |
---|---|
Construct a basic_streambuf object. |
|
Move characters from the output sequence to the input sequence. |
|
Remove characters from the input sequence. |
|
Get a list of buffers that represents the input sequence. |
|
Get the maximum size of the basic_streambuf. |
|
Get a list of buffers that represents the output sequence, with the given size. |
|
Get the size of the input sequence. |
Name |
Description |
---|---|
Override std::streambuf behaviour. |
|
Override std::streambuf behaviour. |
The basic_streambuf
class
is derived from std::streambuf
to associate the streambuf's
input and output sequences with one or more character arrays. These character
arrays are internal to the basic_streambuf
object, but direct access to the array elements is provided to permit them
to be used efficiently with I/O operations. Characters written to the output
sequence of a basic_streambuf
object are appended to the input sequence of the same object.
The basic_streambuf
class's
public interface is intended to permit the following implementation strategies:
The constructor for basic_streambuf
accepts a size_t
argument specifying the maximum
of the sum of the sizes of the input sequence and output sequence. During
the lifetime of the basic_streambuf
object, the following invariant holds:
size() <= max_size()
Any member function that would, if successful, cause the invariant to be
violated shall throw an exception of class std::length_error
.
The constructor for basic_streambuf
takes an Allocator argument. A copy of this argument is used for any memory
allocation performed, by the constructor and by all member functions, during
the lifetime of each basic_streambuf
object.
Writing directly from an streambuf to a socket:
asio::streambuf b; std::ostream os(&b); os << "Hello, World!\n"; // try sending some data in input sequence size_t n = sock.send(b.data()); b.consume(n); // sent data is removed from input sequence
Reading from a socket directly into a streambuf:
asio::streambuf b; // reserve 512 bytes in output sequence asio::streambuf::mutable_buffers_type bufs = b.prepare(512); size_t n = sock.receive(bufs); // received data is "committed" from output sequence to input sequence b.commit(n); std::istream is(&b); std::string s; is >> s;
Header: asio/basic_streambuf.hpp
Convenience header: asio.hpp