Add more usages for fmt::ostream

[iwubcode]

I noticed fmt::output_file() returns a special fmt::ostream. It'd be nice if there was something similar for printing to the screen (cout stream replacement) / building into a string (ostringstream replacement).

Then we could do something like this:

void build_text(fmt::ostream& stream)
{
  stream.print("Hello {}\n", "world");
  stream.print('foobar");
}

// Doesn't matter how you call it!

void to_console()
{
  auto stream = fmt::print();  // no argument overload?  or alternative console_stream();
  build_text(stream);
}

void to_file()
{
  auto stream = fmt::output_file("myfile");
  build_text(stream);
}

void to_string()
{
  auto stream = fmt::string_stream();
  build_text(stream);

  // to text!
  const std::string text = fmt::to_string(stream);
}

at the moment I think we have to fall back to stl streams in order to do this? But I thought those were slow in practice.

Please let me know if there's something I'm missing!

[WBurzynski]

I think this is good idea. It would make code more testable, because you can replace console output with string output and make assertions on that string.

I wonder how hard would be to actually implement it?

[joseangeljimenez]

It'll be also great in embedded platforms, for "printing" to a serial port!

[traversebitree]

Is any progress??
I want fmtlib more flexible like std::ostream.
For example,

void print_something_anywhere(std::ostream &output)
{
  output<<"hello world""<<std::endl;
  // ...
}

Then, the output could be a stdcout or stderr or a file handle.

Can fmtlib implement this?

[vitaut]

There is no update on the {fmt}-only solution but you can use std::ostream with {fmt} with the former managing buffering and low-level I/O while the latter doing the formatting.

[vitaut]

Added an experimental fmt::writer API that does this:

#include <fmt/os.h>

void write_text(fmt::writer w) {
  w.print("The answer is {}.", 42);
}

int main() {
  // Write to FILE.
  write_text(stdout);

  // Write to fmt::ostream.
  auto f = fmt::output_file("myfile");
  write_text(f);

  // Write to std::string.
  auto sb = fmt::string_buffer();
  write_text(sb);
  std::string s = sb.str();
}

It is more efficient than std::ostream and fully compatible with C streams.

Thanks for the suggestion!