Support for fmt::format with support_wformat

[jeanga]

Hi!

What would it take to support fmtlib's format instead or in addition to std:format in proxy::support_wformat ?

Thank you

[mingxwa]

Hi @jeanga, thanks for the excellent question! I believe adding fmtlib support would be a fantastic enhancement by allowing users the flexibility to opt-in to fmtlib when using the Proxy library.

As the Proxy library currently only supports the standard format library via support_format and support_wformat, we can extend it to fmtlib by defining specialized fmt::formatter.

Below is a prototype implementation (run it here):

namespace pro_fmt {

template <class CharT> struct format_overload_traits;
template <>
struct format_overload_traits<char>
    : std::type_identity<fmt::format_context::iterator(
          std::string_view spec, fmt::format_context& fc) const> {};
template <>
struct format_overload_traits<wchar_t>
    : std::type_identity<fmt::wformat_context::iterator(
          std::wstring_view spec, fmt::wformat_context& fc) const> {};
template <class CharT>
using format_overload_t = typename format_overload_traits<CharT>::type;

struct format_dispatch {
  template <class T, class CharT, class OutIt>
  OutIt operator()(const T& self, std::basic_string_view<CharT> spec,
      fmt::basic_format_context<OutIt, CharT>& fc) const
      requires(std::is_default_constructible_v<fmt::formatter<T, CharT>>) {
    fmt::formatter<T, CharT> impl;
    {
      fmt::basic_format_parse_context<CharT> pc{spec};
      impl.parse(pc);
    }
    return impl.format(self, fc);
  }
};

}  // namespace pro_fmt

namespace fmt {

template <pro::facade F, class CharT>
struct formatter<pro::proxy_indirect_accessor<F>, CharT> {
  constexpr auto parse(basic_format_parse_context<CharT>& pc) {
    for (auto it = pc.begin(); it != pc.end(); ++it) {
      if (*it == '}') {
        spec_ = std::basic_string_view<CharT>{pc.begin(), it + 1};
        return it;
      }
    }
    return pc.end();
  }

  template <class OutIt>
  OutIt format(const pro::proxy_indirect_accessor<F>& ia,
      basic_format_context<OutIt, CharT>& fc) const {
    auto& p = pro::access_proxy<F>(ia);
    if (!p.has_value()) { throw format_error{"null proxy"}; }
    return pro::proxy_invoke<false, pro_fmt::format_dispatch,
        pro_fmt::format_overload_t<CharT>>(p, spec_, fc);
  }

 private:
  std::basic_string_view<CharT> spec_;
};

}  // namespace fmt

We will explore how to integrate this option into the Proxy library by default — perhaps controlled by a macro like PRO_FORMAT_SUPPORT. @vitaut, do you have any thoughts on a good approach for toggling this support? I'd love to hear any further ideas or questions on this!

[jeanga]

Waow. Thank you very much for your answer.

[vitaut]

If you mean detecting if {fmt} is available then you could probably use __has_include(<fmt/format.h>).

[mingxwa]

@jeanga @vitaut I have filed a pull request for {fmt} support with a new header file proxy_fmt.h (run it here). Could you help review?

I tried to use __has_include(<fmt/format.h>) in my initial draft, but found it not trivial to make the header file self-contained. My proposed changes require users to include {fmt} header files prior to including proxy_fmt.h, because

• Although including fmt/format.h is sufficient before {fmt} 8.0, it becomes insufficient in newer versions (requires a separate header fmt/xchar.h for wchar_t).
• Users may configure the {fmt} library in different ways (default, header-only, module).
• Users may have installed the library to a different location.

Please let me know if there is anything missing. If everything goes well, this feature will be included in the next 4.0.0 release of Proxy. BTW, when testing my changes, I found that NVHPC reports warnings when compiling {fmt} and filed a bug: fmtlib/fmt#4415

[jeanga]

Thank you very much for this addition 👍