Reusing formatters in formatters::parse for user defined type

[pwm1234]

I have said before, but it is worth saying again -- thanks for working on fmt; it is great and a pleasure to use!

I have a question about formatting user defined types. The point example in the documentation leaves me with a question that I do not know how to answer. To extend the point example to be even more practical:

How can I make a custom point formatter that reuses the parse context and specifiers (these may not be the right terms) for the underlying double type?

For example, I would like to format a point where formatter parse and format use any of the underlying double specifiers. And example usage might be

point p = {1.001, 2.0015};
std::string s = fmt::format("{:.3f}", p);
// s == "(1.001, 2.002)"

where the parse function sees the .3f specifier and uses that in the format function.

Additional extensions might be: how to specify independent specifiers for the x and y components? How to have the specifier for y be optional and if not specified is the same as the x specifier.

If someone can point me in the right direction, I will attempt to provide an update to the example documentation.
Thanks!

[alex-700]

Hi! I don't know supposed answer for your first question, but personally I usually solve it like in the example below.

struct point_t { double x, y; };

template<>
struct fmt::formatter<point_t> : fmt::formatter<double>
{
   using base_t = fmt::formatter<double>;

   template <class FormatContext>
   auto format(point_t const & point, FormatContext & ctx)
   {
      base_t::format(point.x, ctx);
      fmt::format_to(ctx.out(), " ");
      return base_t::format(point.y, ctx);
   }
};

The second question is very good. I think there is no single answer to it. It seems that you should invent some format in each case.
And I'm very interested in some readings about "best practices" to do this.

[vitaut]

I have said before, but it is worth saying again -- thanks for working on fmt; it is great and a pleasure to use!

Thank you!

How can I make a custom point formatter that reuses the parse context and specifiers (these may not be the right terms) for the underlying double type?

You can do this by reusing formatter<double> specialization via inheritance (as @alex-700 showed in his example) or composition. The parsed format specifiers are stored in the formatter object and applied when formatter<double>::format is called, possibly multiple times.

how to specify independent specifiers for the x and y components?

You can have two formatter<double> objects in fmt::formatter<point_t> and delegate formatting to them:

template<> struct fmt::formatter<point> {
  formatter<double> x_formatter, y_formatter;

  auto parse(format_parse_context& ctx) {
    // Parse format specifications for point delegating
    // to x_formatter.parse/y_formatter.parse parsing of
    // format specifiers for components.
  }

  auto format(point p, format_context& ctx) {
    x_formatter.format(p.x, ctx);
    fmt::format_to(ctx.out(), " ");
    return y_formatter.format(p.y, ctx);
 }
};

[pwm1234]

Thank you for your response!

Once I understand it, would you like a pull request with some of this added to the documentation? Do you have a preference or suggestion on where to put it? I think a test or example would also be helpful (to me at least).

[vitaut]

Once I understand it, would you like a pull request with some of this added to the documentation?

Sure, documentation improvements are always welcome.

Do you have a preference or suggestion on where to put it?

Perhaps in https://github.com/fmtlib/fmt/blob/master/doc/api.rst#formatting-user-defined-types. For now I've added a small clarification there: b8fbcec.

[chiphogg]

You can have two formatter<double> objects in fmt::formatter<point_t> and delegate formatting to them:

template<> struct fmt::formatter {
formatter x_formatter, y_formatter;

auto parse(format_parse_context& ctx) {
// Parse format specifications for point delegating
// to x_formatter.parse/y_formatter.parse parsing of
// format specifiers for components.
}

auto format(point p, format_context& ctx) {
x_formatter.format(p.x, ctx);
fmt::format_to(ctx.out(), " ");
return y_formatter.format(p.y, ctx);
}
};

For anyone else stumbling on this issue, note that the approach in the comments in auto parse() won't actually work in the general case. There's no good way to pass "substrings" of the format string to the parse function for another formatter type. See #4508 for more details.

[vitaut]

To be more precise you can pass a suffix of the format string to the nested formatter (which is what ranges do) but not an arbitrary substring.