namespace std {
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
class basic_syncbuf : public basic_streambuf<charT, traits> {
public:
using char_type = charT;
using int_type = typename traits::int_type;
using pos_type = typename traits::pos_type;
using off_type = typename traits::off_type;
using traits_type = traits;
using allocator_type = Allocator;
using streambuf_type = basic_streambuf<charT, traits>;
basic_syncbuf()
: basic_syncbuf(nullptr) {}
explicit basic_syncbuf(streambuf_type* obuf)
: basic_syncbuf(obuf, Allocator()) {}
basic_syncbuf(streambuf_type*, const Allocator&);
basic_syncbuf(basic_syncbuf&&);
~basic_syncbuf();
basic_syncbuf& operator=(basic_syncbuf&&);
void swap(basic_syncbuf&);
bool emit();
streambuf_type* get_wrapped() const noexcept;
allocator_type get_allocator() const noexcept;
void set_emit_on_sync(bool) noexcept;
protected:
int sync() override;
private:
streambuf_type* wrapped;
bool emit_on_sync{};
};
template<class charT, class traits, class Allocator>
void swap(basic_syncbuf<charT, traits, Allocator>&,
basic_syncbuf<charT, traits, Allocator>&);
}
Class template
basic_syncbuf stores character data
written to it, known as the associated output, into internal
buffers allocated using the object's allocator
. The associated output is transferred to the
wrapped stream buffer object
*wrapped
when
emit() is called
or when the
basic_syncbuf object is destroyed
. Such transfers are atomic with respect to transfers
by other
basic_syncbuf objects
with the same wrapped stream buffer object
.