format.hpp

Go to the documentation of this file.

#pragma once
 
#include <boost/describe.hpp>
#include <filesystem>
#include <format>
#include <vector>
 
#include "wren/utils/concepts.hpp"
 
template <wren::DescribedStruct T>
struct std::formatter<T, char> {
  constexpr auto parse(std::format_parse_context& ctx) {
    auto it = ctx.begin(), end = ctx.end();
 
    if (it != end && *it != '}') {
      throw std::runtime_error("invalid format");
    }
 
    return it;
  }
 
  auto format(const T& t, format_context& ctx) const {
    using namespace boost::describe;
 
    using Bd = describe_bases<T, mod_any_access>;
    using Md = describe_members<T, mod_any_access>;
 
    auto out = ctx.out();
 
    *out++ = '{';
 
    bool first = true;
 
    boost::mp11::mp_for_each<Bd>([&](auto d) {
      if (!first) {
        *out++ = ',';
      }
 
      first = false;
 
      out = std::format_to(out, " {}", t);
    });
 
    boost::mp11::mp_for_each<Md>([&](auto d) {
      if (!first) {
        *out++ = ',';
      }
 
      first = false;
 
      out = std::format_to(out, " .{}={}", d.name, t.*d.pointer);
    });
 
    if (!first) {
      *out++ = ' ';
    }
 
    *out++ = '}';
 
    return out;
  }
};
 
template <wren::DescribedEnum T>
struct std::formatter<T, char> {
 private:
  using U = std::underlying_type_t<T>;
 
  std::formatter<std::string_view, char> sf_;
  std::formatter<U, char> nf_;
 
 public:
  constexpr auto parse(format_parse_context& ctx) {
    auto i1 = sf_.parse(ctx);
    auto i2 = nf_.parse(ctx);
 
    if (i1 != i2) {
      throw std::runtime_error("invalid format");
    }
 
    return i1;
  }
 
  auto format(const T& t, format_context& ctx) const {
    const char* s = boost::describe::enum_to_string(t, 0);
 
    if (s) {
      return sf_.format(s, ctx);
    } else {
      return nf_.format(static_cast<U>(t), ctx);
    }
  }
};
 
template <typename T>
struct std::formatter<std::vector<T>, char> {
  constexpr auto parse(format_parse_context& ctx) {
    auto it = ctx.begin(), end = ctx.end();
 
    if (it != end && *it != '}') {
      throw std::runtime_error("invalid format");
    }
 
    return it;
  }
 
  auto format(const std::vector<T>& list, format_context& ctx) const {
    auto out = ctx.out();
 
    bool first = true;
 
    for (const auto& elem : list) {
      if (!first) *out++ = ',';
 
      out = std::format_to(out, "{}", elem);
 
      first = false;
    }
 
    return out;
  }
};
 
template <>
struct std::formatter<std::filesystem::path, char> {
  constexpr auto parse(format_parse_context& ctx) {
    auto it = ctx.begin(), end = ctx.end();
 
    if (it != end && *it != '}') {
      throw std::runtime_error("invalid format");
    }
 
    return it;
  }
 
  auto format(const std::filesystem::path& path, format_context& ctx) const {
    return std::format_to(ctx.out(), "{}", path.string());
  }
};