format.hpp

Go to the documentation of this file.

#pragma once
 
#include <fmt/format.h>
#include <fmt/std.h>
 
#include <boost/describe.hpp>
#include <boost/system/error_code.hpp>
 
#include "utils/reflect.hpp"
 
template <typename T>
concept IsFormattable = requires(T& v, fmt::format_context ctx) {
  fmt::formatter<std::remove_cvref_t<T>>().format(v, ctx);
};
 
template <>
struct fmt::formatter<boost::system::error_code> : fmt::formatter<std::string> {
  template <typename Ctx>
  auto format(const boost::system::error_code& ec, Ctx& ctx) const {
    return formatter<std::string>::format(
        fmt::format("{}: {}", ec.category().name(), ec.message()), ctx);
  }
};
 
template <>
struct fmt::formatter<std::error_code> : fmt::formatter<std::string> {
  template <typename Ctx>
  auto format(const std::error_code& ec, Ctx& ctx) const {
    return formatter<std::string>::format(
        fmt::format("{}: {}", ec.category().name(), ec.message()), ctx);
  }
};
 
// ========== Struct formatter ============== //
 
template <typename T>
concept formattable_struct =
    boost::describe::has_describe_bases<T>::value &&
    boost::describe::has_describe_members<T>::value && !std::is_union_v<T>;
 
template <formattable_struct T>
struct fmt::formatter<T, char> {
  // NOLINTNEXTLINE
  constexpr auto parse(format_parse_context& ctx) {
    const auto* it = ctx.begin();
    const auto* end = ctx.end();
 
    if (it != end && *it != '}') {
      fmt::throw_format_error("invalid format");
    }
 
    return it;
  }
 
  // NOLINTNEXTLINE
  auto format(T const& t, format_context& ctx) const {
    using Bd =
        boost::describe::describe_bases<T, boost::describe::mod_any_access>;
    using Md =
        boost::describe::describe_members<T, boost::describe::mod_any_access>;
 
    auto out = ctx.out();
 
    out = fmt::format_to(out, "{} ", stax::reflect::GetTypeName<T>());
    *out++ = '{';
 
    bool first = true;
 
    boost::mp11::mp_for_each<Bd>([&](auto d) {
      if (!first) {
        *out++ = ',';
      }
 
      first = false;
 
      out = fmt::format_to(out, " {}",
                           static_cast<typename decltype(d)::type const&>(t));
    });
 
    boost::mp11::mp_for_each<Md>([&](auto d) {
      if (!first) {
        *out++ = ',';
      }
 
      first = false;
 
      out = fmt::format_to(out, " .{}: {}", d.name, t.*d.pointer);
    });
 
    if (!first) {
      *out++ = ' ';
    }
 
    *out++ = '}';
 
    return out;
  }
};
 
// ========== Struct formatter ============== //
 
template <typename T>
concept formattable_enum = boost::describe::has_describe_enumerators<T>::value;
 
template <formattable_enum T>
struct fmt::formatter<T, char> {
 private:
  using U = std::underlying_type_t<T>;
 
  fmt::formatter<std::string_view, char> sf_;
  fmt::formatter<U, char> nf_;
 
 public:
  constexpr auto parse(fmt::format_parse_context& ctx) {
    auto i1 = sf_.parse(ctx);
    auto i2 = nf_.parse(ctx);
 
    if (i1 != i2) {
      fmt::throw_format_error("invalid format");
    }
 
    return i1;
  }
 
  auto format(T const& t, fmt::format_context& ctx) const {
    char const* s = boost::describe::enum_to_string(t, 0);
 
    if (s) {
      return sf_.format(s, ctx);
    } else {
      return nf_.format(static_cast<U>(t), ctx);
    }
  }
};