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!

Support for fmt::format with support_wformat #279

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions