individual_format.h

Go to the documentation of this file.

 
#if !defined(ULTRA_INDIVIDUAL_FORMAT_H)
#define      ULTRA_INDIVIDUAL_FORMAT_H
 
#include "kernel/individual.h"
 
#include <algorithm>
#include <concepts>
#include <format>
#include <iosfwd>
 
namespace ultra
{
 
std::ostream &operator<<(std::ostream &, const individual &);
 
namespace out
{
 
print_format_t print_format_flag(std::ostream &);
 
class print_format
{
public:
  explicit print_format(print_format_t t) : t_(t) {}
 
  friend std::ostream &operator<<(std::ostream &, print_format);
 
private:
  print_format_t t_;
};
 
std::ostream &c_language(std::ostream &);
std::ostream &cpp_language(std::ostream &);
std::ostream &dump(std::ostream &);
std::ostream &graphviz(std::ostream &);
std::ostream &in_line(std::ostream &);
std::ostream &list(std::ostream &);
std::ostream &python_language(std::ostream &);
std::ostream &tree(std::ostream &);
 
}  // namespace out
}  // namespace ultra
 
namespace std
{
 
template<> struct formatter<ultra::individual, char>
{
  ultra::out::print_format_t fmt_ = ultra::out::list_f;
 
  [[nodiscard]] constexpr auto parse(std::format_parse_context &ctx)
  {
    auto it(ctx.begin());
    const auto end(ctx.end());
 
    if (it == end || *it == '}')
      return it;
 
    const auto consume([&]<std::size_t N>(const char (&s)[N],
                                          ultra::out::print_format_t f)
    {
      auto probe(it);
 
      for (std::size_t i(0); i < N - 1; ++i)
      {
        if (probe == end || *probe != s[i])
          return false;
        ++probe;
      }
 
      fmt_ = f;
      it = probe;
      return true;
    });
 
    // Test longer prefixes first (remember "cpp" starts with "c", so `{:cpp}`
    // will match "c" first, then fail on trailing characters "pp").
    if (consume("graphviz", ultra::out::graphviz_f)
        || consume("python", ultra::out::python_language_f)
        || consume("inline", ultra::out::in_line_f)
        || consume("dump", ultra::out::dump_f)
        || consume("list", ultra::out::list_f)
        || consume("tree", ultra::out::tree_f)
        || consume("cpp", ultra::out::cpp_language_f)
        || consume("c", ultra::out::c_language_f))
    {
      if (it != end && *it != '}')
        throw std::format_error("invalid trailing format specifier for "
                                "ultra::individual");
 
      return it;
    }
 
    throw std::format_error("invalid format specifier for ultra::individual");
  }
 
  template<class FormatContext>
  [[nodiscard]] auto format(const ultra::individual &ind,
                            FormatContext &ctx) const
  {
    const auto s(ind.format(fmt_));
    return std::ranges::copy(s, ctx.out()).out;
  }
};
 
template<std::derived_from<ultra::individual> T>
struct formatter<T, char> : formatter<ultra::individual, char>
{
};
 
}  // namespace std
 
#endif  // include guard