Standard library header <syncstream>

From cppreference.com
< cpplrm; | header

This header is part of the Input/Output library.

Includes

<ostream>

Classes

synchronized output device wrapper
(class template)
synchronized output stream wrapper
(class template)

Typedefs

syncbuf basic_syncbuf<char>
wsyncbuf basic_syncbuf<wchar_t>
osyncstream basic_osyncstream<char>
wosyncstream basic_osyncstream<wchar_t>

Functions

specializes the std::swap algorithm
(function template)

Synopsis

namespace std {
template <class CharT,
          class Traits = char_traits<CharT>,
          class Allocator = allocator<CharT>>
  class basic_syncbuf;

using syncbuf  = basic_syncbuf<char>;
using wsyncbuf = basic_syncbuf<wchar_t>;

template <class CharT,
          class Traits = char_traits<CharT>,
          class Allocator = allocator<CharT>>
  class basic_osyncstream;

using osyncstream  = basic_osyncstream<char>;
using wosyncstream = basic_osyncstream<wchar_t>;

template <class CharT, class Traits, class Allocator>
  void swap( std::basic_syncbuf<CharT, Traits, Allocator>& lhs,
             std::basic_syncbuf<CharT, Traits, Allocator>& rhs );

}

Class std::basic_syncbuf

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>;

  // Constructors/destructor:
  explicit
  basic_syncbuf(streambuf_type* obuf = nullptr)
    : basic_syncbuf(obuf, Allocator()) {}
  basic_syncbuf(streambuf_type* ,
                const Allocator&);
  basic_syncbuf(basic_syncbuf&&);
  ~basic_syncbuf();

  // Assign/swap:
  basic_syncbuf& operator=(basic_syncbuf&&);
  void swap(basic_syncbuf &);

  // Members:
  bool emit();
  streambuf_type* get_wrapped()   const noexcept;
  allocator_type  get_allocator() const noexcept;
  void            set_emit_on_sync(bool) noexcept;

protected:
  // Overridden virtual functions:
  int sync() override;

private:
  streambuf_type *wrapped;       // exposition only
  bool            emit_on_sync{};// exposition only
};

Class std::basic_osyncstream

template <class CharT,
          class Traits = char_traits<CharT>,
          class Allocator = allocator<CharT>>
class basic_osyncstream
  : public basic_ostream<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>;
  using syncbuf_type   = basic_syncbuf<CharT, Traits, Allocator>;

  // Constructors/destructor:
  basic_osyncstream(streambuf_type *, const Allocator &);
  explicit basic_osyncstream(streambuf_type *obuf)
    : basic_osyncstream(obuf, Allocator()) {}
  basic_osyncstream(basic_ostream<CharT,Traits> &os, const Allocator &allocator)
    : basic_osyncstream(os.rdbuf(), allocator){}
  explicit basic_osyncstream(basic_ostream<CharT,Traits> &os)
    : basic_osyncstream(os, Allocator()) {}
  basic_osyncstream(basic_osyncstream&&) noexcept;
  ~basic_osyncstream();

  // Assign:
  basic_osyncstream& operator=(basic_osyncstream&&) noexcept;

  // Members:
  void emit();
  streambuf_type* get_wrapped() const noexcept;
  syncbuf_type* rdbuf() const noexcept { return &sb ; }

private:
  syncbuf_type sb; // exposition only
};