Namespaces
Variants
Views
Actions

Standard library header <syncstream>

From cppreference.com
< cpp‎ | header
 
 
 

This header is part of the Input/Output library.

Contents

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) [edit]

[edit] 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 );
 
}

[edit] 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
};

[edit] 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
};