How can I make this custom fmt formatter code cleaner? - c++

Question

I want to write a custom formatter for simple structures inheriting from the existing formatters to access all their options. For example, I've written this for a rectangle:
#include <fmt/format.h>
template<typename T>
struct rect {
T x;
T y;
T width;
T height;
};
template <typename T>
struct fmt::formatter<rect<T>>: formatter<T> {
template <typename FormatContext>
auto format(rect<T> c, FormatContext& ctx) const {
auto out = ctx.out();
fmt::format_to(out, "[(");
out = formatter<T>::format(c.x, ctx);
fmt::format_to(out, ", ");
ctx.advance_to(out);
out= formatter<T>::format(c.y, ctx);
fmt::format_to(out, "), ");
ctx.advance_to(out);
out = formatter<T>::format(c.width, ctx);
fmt::format_to(out, " x ");
ctx.advance_to(out);
out = formatter<T>::format(c.height, ctx);
fmt::format_to(out, "]");
return out;
}
};
int main()
{
rect<double> f = {1.0, 2.3445, 3.14, 4};
fmt::print("{:.2f}\n", f);
rect<int> b = {1, 2, 3, 4};
fmt::print("{}\n", b);
return 0;
}
It works as expected, but the code inside the format() call seems a bit too convoluted. Q:
Is there a way of making it better, or at least cleaner?
Is format_to(...) the best option for adding those characters to the output?

Answer 1

Maybe you want like this. Note you have to implement parse and format methods both as per https://fmt.dev/latest/api.html#formatting-user-defined-types:
template < typename T >
struct fmt::formatter < rect < T >>: formatter < T > {
int floating_point_precision = 0;
constexpr auto parse(format_parse_context & ctx) -> decltype(ctx.begin()) {
auto it = ctx.begin(), end = ctx.end();
if (it != end && ( * it == '.')) it++;
if (it != end && ( * it >= '0' && * it <= '9')) {
floating_point_precision = * it - '0';
it++;
}
if (it != end && ( * it == 'f')) it++;
// Check if reached the end of the range:
if (it != end && * it != '}') throw format_error("invalid format");
// Return an iterator past the end of the parsed range:
return it;
}
template < typename FormatContext >
auto format(rect < T > c, FormatContext & ctx) const {
auto out = ctx.out();
if (floating_point_precision == 0)
fmt::format_to(out, "[({}, {}), {} x {}]", c.x, c.y, c.width, c.height);
else {
std::stringstream ss;
ss << "[({:." << floating_point_precision << "f}, {:." << floating_point_precision << "f}), "
"{:." << floating_point_precision << "f} x {:." << floating_point_precision << "f}]";
fmt::format_to(out, ss.str(), c.x, c.y, c.width, c.height);
}
return out;
}
};

Answer 2

You can make the code a bit cleaner as follows:
Move the element formatting logic into a separate function/lambda and reuse it in 4 places.
Remove redundant namespace qualification since the formatter is defined in the fmt namespace.
template <typename T>
struct fmt::formatter<rect<T>>: formatter<T> {
template <typename FormatContext>
auto format(rect<T> c, FormatContext& ctx) const {
auto out = ctx.out();
auto format_element = [&](const T& value) {
ctx.advance_to(out);
out = formatter<T>::format(value, ctx);
};
out = format_to(out, "[(");
format_element(c.x);
out = format_to(out, ", ");
format_element(c.y);
out = format_to(out, "), ");
format_element(c.width);
out = format_to(out, " x ");
format_element(c.height);
return format_to(out, "]");
}
};
Full example: https://godbolt.org/z/b8E88d3dG.
format_to is a reasonable way to output literal text but you could use std:copy instead.