Feature Request: Add write_n() function to fmt::BasicWriter that restricts output to a specified number of characters.

[KevinDHall]

The idea is to make write_n() be a replacement for the snprintf() family of functions.

The reason this would be useful is to prevent fmt::BasicArrayWriter from throwing an exception when output cannot fit in the buffer. Currently one may wrap write() in a try block, but the element that caused the exception to be thrown will not be printed at all -- not even partially. Often it is desired to get partial output. One example is copying long strings (log or error messages). It is better to get some of the text instead of none of it.

[vitaut]

Thanks for the suggestion, I think this is a useful functionality worth implementing. The only thing is that it should be a separate buffer and writer, possibly a modification of FixedBuffer and ArrayWriter, rather than a new method, because this should work both with formatting and writing API.

[vitaut]

But as a heads up, it might take a while till I get to it. Maybe someone else would like to contribute though.

[KevinDHall]

I'd be happy to try contributing.

The challenge I saw looking at the code is that the code to do the writing uses resize() and grow_buffer() and doesn't allow for a max_count to be passed around easily.

If you are willing to give a bit more high-level direction on where you'd like a seam to be made, I'd be happy to try implementing something.

[vitaut]

I think the easiest solution is to make Buffer::grow return bool - true if the buffer has grown to the required size, false if it hasn't (unchanged capacity & size):

template <typename Char>
bool fmt::internal::FixedBuffer<Char>::grow(std::size_t) {
  return false;
}

Then comes a more complicated part of making all callers of grow check the return value and adjust the behavior accordingly, for example:

// Buffer::push_back
void push_back(const T &value) {
  if (size_ < capacity_ || grow(size_ + 1))
    ptr_[size_++] = value;
}

void Buffer<T>::append(const U *begin, const U *end) {
  std::size_t new_size = size_ + internal::to_unsigned(end - begin);
  if (new_size > capacity_ && !grow(new_size)) {
    new_size = capacity_;
    end = begin + new_size;
  }
  std::uninitialized_copy(begin, end,
                          internal::make_ptr(ptr_, capacity_) + size_);
  size_ = new_size;
}

etc.

Numeric formatters might be a bit of a pain.

[randrewy]

Any progress on this? Or may be there is other alternative to snprintf-like behaviour?

[vitaut]

A simple workaround is to format into a memory writer and then truncate the result. It is suboptimal so it's on my TODO list to add direct support for truncated output.

[vitaut]

The std branch now has an experimental range support. Currently only (unbounded) output ranges are supported, but it should be relatively straightforward to extend the implementation to support fixed-size ones.

[randrewy]

This is great news!

[vitaut]

The write API is being replaced with the format API with compile-time parsing of format strings which will have a way to limit output size (format_to_n in #518). Therefore closing in favor of #518.

[vitaut]

format_to_n is now implemented: http://fmtlib.net/dev/api.html#_CPPv2N3fmt11format_to_nE8OutputItNSt6size_tE11string_viewDpRK4Args