Class template basic_formatting_ostream

boost::log::basic_formatting_ostream — Stream for log records formatting.

Synopsis

// In header: <boost/log/utility/formatting_ostream_fwd.hpp>

template<typename CharT, typename TraitsT = std::char_traits< CharT >, 
         typename AllocatorT = std::allocator< CharT > > 
class basic_formatting_ostream {
public:
  // construct/copy/destruct
  basic_formatting_ostream();
  explicit basic_formatting_ostream(string_type &);
  basic_formatting_ostream(basic_formatting_ostream const &) = delete;
  basic_formatting_ostream & 
  operator=(basic_formatting_ostream const &) = delete;
  ~basic_formatting_ostream();

  // public member functions
  void attach(string_type &);
  void detach();
  string_type const & str() const;
  ostream_type & stream();
  ostream_type const & stream() const;
  fmtflags flags() const;
  fmtflags flags(fmtflags);
  fmtflags setf(fmtflags);
  fmtflags setf(fmtflags, fmtflags);
  void unsetf(fmtflags);
  std::streamsize precision() const;
  std::streamsize precision(std::streamsize);
  std::streamsize width() const;
  std::streamsize width(std::streamsize);
  std::locale getloc() const;
  std::locale imbue(std::locale const &);
  long & iword(int);
  void *& pword(int);
  void register_callback(event_callback, int);
  explicit operator bool() const;
  bool operator!() const;
  iostate rdstate() const;
  void clear(iostate = goodbit);
  void setstate(iostate);
  bool good() const;
  bool eof() const;
  bool fail() const;
  bool bad() const;
  iostate exceptions() const;
  void exceptions(iostate);
  ostream_type * tie() const;
  ostream_type * tie(ostream_type *);
  streambuf_type * rdbuf() const;
  basic_formatting_ostream & 
  copyfmt(std::basic_ios< char_type, traits_type > &);
  basic_formatting_ostream & copyfmt(basic_formatting_ostream &);
  char_type fill() const;
  char_type fill(char_type);
  char narrow(char_type, char) const;
  char_type widen(char) const;
  basic_formatting_ostream & flush();
  pos_type tellp();
  basic_formatting_ostream & seekp(pos_type);
  basic_formatting_ostream & seekp(off_type, std::ios_base::seekdir);
  basic_formatting_ostream & put(char_type);
  template<typename OtherCharT> unspecified put(OtherCharT);
  basic_formatting_ostream & write(const char_type *, std::streamsize);
  template<typename OtherCharT> 
    unspecified write(const OtherCharT *, std::streamsize);
  basic_formatting_ostream & operator<<(ios_base_manip);
  basic_formatting_ostream & operator<<(basic_ios_manip);
  basic_formatting_ostream & operator<<(stream_manip);
  basic_formatting_ostream & operator<<(char);
  basic_formatting_ostream & operator<<(const char *);
  basic_formatting_ostream & operator<<(wchar_t);
  basic_formatting_ostream & operator<<(const wchar_t *);
  basic_formatting_ostream & operator<<(char16_t);
  basic_formatting_ostream & operator<<(const char16_t *);
  basic_formatting_ostream & operator<<(char32_t);
  basic_formatting_ostream & operator<<(const char32_t *);
  basic_formatting_ostream & operator<<(bool);
  basic_formatting_ostream & operator<<(signed char);
  basic_formatting_ostream & operator<<(unsigned char);
  basic_formatting_ostream & operator<<(short);
  basic_formatting_ostream & operator<<(unsigned short);
  basic_formatting_ostream & operator<<(int);
  basic_formatting_ostream & operator<<(unsigned int);
  basic_formatting_ostream & operator<<(long);
  basic_formatting_ostream & operator<<(unsigned long);
  basic_formatting_ostream & operator<<(long long);
  basic_formatting_ostream & operator<<(unsigned long long);
  basic_formatting_ostream & operator<<(float);
  basic_formatting_ostream & operator<<(double);
  basic_formatting_ostream & operator<<(long double);
  basic_formatting_ostream & operator<<(const void *);
  basic_formatting_ostream & 
  operator<<(std::basic_streambuf< char_type, traits_type > *);

  // public static functions
  static int xalloc();
  static bool sync_with_stdio(bool = true);

  // private member functions
  void init_stream();
  basic_formatting_ostream & 
  formatted_write(const char_type *, std::streamsize);
  template<typename OtherCharT> 
    basic_formatting_ostream & 
    formatted_write(const OtherCharT *, std::streamsize);
  void aligned_write(const char_type *, std::streamsize);
  template<typename OtherCharT> 
    void aligned_write(const OtherCharT *, std::streamsize);
};

Description

Stream wrapper for log records formatting.

This stream wrapper is used by the library for log record formatting. It implements the standard string stream interface with a few differences:

It does not derive from standard types std::basic_ostream, std::basic_ios and std::ios_base, although it tries to implement their interfaces closely. There are a few small differences, mostly regarding rdbuf and str signatures, as well as the supported insertion operator overloads. The actual wrapped stream can be accessed through the stream methods.
By default, bool values are formatted using alphabetical representation rather than numeric.
The stream supports writing strings of character types different from the stream character type. The stream will perform character code conversion as needed using the imbued locale.
The stream operates on an external string object rather than on the embedded one. The string can be attached or detached from the stream dynamically.

Although basic_formatting_ostream does not derive from std::basic_ostream, users are not required to add special overloads of operator<< for it since the stream will by default reuse the operators for std::basic_ostream. However, one can define special overloads of operator<< for basic_formatting_ostream if a certain type needs special formatting when output to log.

`basic_formatting_ostream` public construct/copy/destruct

```
basic_formatting_ostream();
```
Default constructor. Creates an empty record that is equivalent to the invalid record handle. The stream capability is not available after construction.

Postconditions:

!*this == true
```
explicit basic_formatting_ostream(string_type & str);
```
Initializing constructor. Attaches the string to the constructed stream. The string will be used to store the formatted characters.

Parameters:

str

The string buffer to attach.

Postconditions:

!*this == false

basic_formatting_ostream(basic_formatting_ostream const & that) = delete;

Copy constructor (closed)

basic_formatting_ostream & 
operator=(basic_formatting_ostream const & that) = delete;

Assignment (closed)

```
~basic_formatting_ostream();
```
Destructor. Destroys the record, releases any sinks and attribute values that were involved in processing this record.

`basic_formatting_ostream` public member functions

```
void attach(string_type & str);
```
Attaches the stream to the string. The string will be used to store the formatted characters.

Parameters:

str

The string buffer to attach.
```
void detach();
```
Detaches the stream from the string. Any buffered data is flushed to the string.
```
string_type const & str() const;
```
Returns:

Reference to the attached string. The string must be attached before calling this method.
```
ostream_type & stream();
```
Returns:

Reference to the wrapped stream
```
ostream_type const & stream() const;
```
Returns:

Reference to the wrapped stream
```
fmtflags flags() const;
```
```
fmtflags flags(fmtflags f);
```
```
fmtflags setf(fmtflags f);
```

fmtflags setf(fmtflags f, fmtflags mask);

```
void unsetf(fmtflags f);
```
```
std::streamsize precision() const;
```

std::streamsize precision(std::streamsize p);

```
std::streamsize width() const;
```

std::streamsize width(std::streamsize w);

```
std::locale getloc() const;
```

std::locale imbue(std::locale const & loc);

```
long & iword(int index);
```
```
void *& pword(int index);
```

void register_callback(event_callback fn, int index);

```
explicit operator bool() const;
```
```
bool operator!() const;
```
```
iostate rdstate() const;
```
```
void clear(iostate state = goodbit);
```
```
void setstate(iostate state);
```
```
bool good() const;
```
```
bool eof() const;
```
```
bool fail() const;
```
```
bool bad() const;
```
```
iostate exceptions() const;
```
```
void exceptions(iostate s);
```
```
ostream_type * tie() const;
```

ostream_type * tie(ostream_type * strm);

```
streambuf_type * rdbuf() const;
```

basic_formatting_ostream & 
copyfmt(std::basic_ios< char_type, traits_type > & rhs);

basic_formatting_ostream & copyfmt(basic_formatting_ostream & rhs);

```
char_type fill() const;
```
```
char_type fill(char_type ch);
```

char narrow(char_type ch, char def) const;

```
char_type widen(char ch) const;
```
```
basic_formatting_ostream & flush();
```
```
pos_type tellp();
```

basic_formatting_ostream & seekp(pos_type pos);

basic_formatting_ostream & seekp(off_type off, std::ios_base::seekdir dir);

basic_formatting_ostream & put(char_type c);

template<typename OtherCharT> unspecified put(OtherCharT c);

basic_formatting_ostream & write(const char_type * p, std::streamsize size);

template<typename OtherCharT> 
  unspecified write(const OtherCharT * p, std::streamsize size);

basic_formatting_ostream & operator<<(ios_base_manip manip);

basic_formatting_ostream & operator<<(basic_ios_manip manip);

basic_formatting_ostream & operator<<(stream_manip manip);

basic_formatting_ostream & operator<<(char c);

basic_formatting_ostream & operator<<(const char * p);

basic_formatting_ostream & operator<<(wchar_t c);

basic_formatting_ostream & operator<<(const wchar_t * p);

basic_formatting_ostream & operator<<(char16_t c);

basic_formatting_ostream & operator<<(const char16_t * p);

basic_formatting_ostream & operator<<(char32_t c);

basic_formatting_ostream & operator<<(const char32_t * p);

basic_formatting_ostream & operator<<(bool value);

basic_formatting_ostream & operator<<(signed char value);

basic_formatting_ostream & operator<<(unsigned char value);

basic_formatting_ostream & operator<<(short value);

basic_formatting_ostream & operator<<(unsigned short value);

basic_formatting_ostream & operator<<(int value);

basic_formatting_ostream & operator<<(unsigned int value);

basic_formatting_ostream & operator<<(long value);

basic_formatting_ostream & operator<<(unsigned long value);

basic_formatting_ostream & operator<<(long long value);

basic_formatting_ostream & operator<<(unsigned long long value);

basic_formatting_ostream & operator<<(float value);

basic_formatting_ostream & operator<<(double value);

basic_formatting_ostream & operator<<(long double value);

basic_formatting_ostream & operator<<(const void * value);

basic_formatting_ostream & 
operator<<(std::basic_streambuf< char_type, traits_type > * buf);

`basic_formatting_ostream` public static functions

```
static int xalloc();
```

static bool sync_with_stdio(bool sync = true);

`basic_formatting_ostream` private member functions

```
void init_stream();
```

basic_formatting_ostream & 
formatted_write(const char_type * p, std::streamsize size);

template<typename OtherCharT> 
  basic_formatting_ostream & 
  formatted_write(const OtherCharT * p, std::streamsize size);

void aligned_write(const char_type * p, std::streamsize size);

template<typename OtherCharT> 
  void aligned_write(const OtherCharT * p, std::streamsize size);

Boost C++ Libraries