Implement std::formatter for enums

Author: felsenhower

argument_parser.cpp

@@ -128,9 +128,9 @@ namespace partdiff {
     this->add_argument_description(
         "method", method,
         std::format("calculation method (1 .. 2)\n"
-                    "{0}{1:d}: Gauß-Seidel\n"
-                    "{0}{2:d}: Jacobi",
-                    indent, to_underlying(calculation_method::gauss_seidel), to_underlying(calculation_method::jacobi)),
+                    "{0}{1:d}: {1:s}\n"
+                    "{0}{2:d}: {2:s}",
+                    indent, calculation_method::gauss_seidel, calculation_method::jacobi),
         [method] { return (*method == calculation_method::gauss_seidel || *method == calculation_method::jacobi); });
 
     auto interlines = &(this->options.interlines);
@@ -141,27 +141,26 @@ namespace partdiff {
                                    [interlines] { return (interlines_bounds.contains(*interlines)); });
 
     auto pert_func = &(this->options.pert_func);
-    this->add_argument_description(
-        "func", pert_func,
-        std::format("perturbation function (1 .. 2)\n"
-                    "{0}{1:d}: f(x,y) = 0\n"
-                    "{0}{2:d}: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y)",
-                    indent, to_underlying(perturbation_function::f0), to_underlying(perturbation_function::fpisin)),
-        [pert_func] {
-          return (*pert_func == perturbation_function::f0 || *pert_func == perturbation_function::fpisin);
-        });
+    this->add_argument_description("func", pert_func,
+                                   std::format("perturbation function (1 .. 2)\n"
+                                               "{0}{1:d}: {1:s}\n"
+                                               "{0}{2:d}: {2:s}",
+                                               indent, perturbation_function::f0, perturbation_function::fpisin),
+                                   [pert_func] {
+                                     return (*pert_func == perturbation_function::f0 ||
+                                             *pert_func == perturbation_function::fpisin);
+                                   });
 
     auto termination = &(this->options.termination);
-    this->add_argument_description("term", termination,
-                                   std::format("termination condition ( 1.. 2)\n"
-                                               "{0}{1:d}: sufficient accuracy\n"
-                                               "{0}{2:d}: number of iterations",
-                                               indent, to_underlying(termination_condition::accuracy),
-                                               to_underlying(termination_condition::iterations)),
-                                   [termination] {
-                                     return (*termination == termination_condition::accuracy ||
-                                             *termination == termination_condition::iterations);
-                                   });
+    this->add_argument_description(
+        "term", termination,
+        std::format("termination condition ( 1.. 2)\n"
+                    "{0}{1:d}: {1:s}\n"
+                    "{0}{2:d}: {2:s}",
+                    indent, termination_condition::accuracy, termination_condition::iterations),
+        [termination] {
+          return (*termination == termination_condition::accuracy || *termination == termination_condition::iterations);
+        });
 
     this->add_argument_description("acc/iter", std::format("depending on term:\n"
                                                            "{0}accuracy:  {1:.0e}\n"

enums.hpp

@@ -1,10 +1,84 @@
 #pragma once
 
+#include <array>
+#include <concepts>
 #include <cstdint>
+#include <format>
+#include <iostream>
+#include <stdexcept>
+#include <string_view>
+#include <type_traits>
+#include <utility>
 
 namespace partdiff {
   enum class calculation_method : uint64_t { gauss_seidel = 1, jacobi = 2 };
   enum class perturbation_function : uint64_t { f0 = 1, fpisin = 2 };
   enum class termination_condition : uint64_t { accuracy = 1, iterations = 2 };
 
 } // namespace partdiff
+
+template <typename Enum>
+struct enum_member_names;
+
+template <>
+struct enum_member_names<partdiff::calculation_method> {
+  static constexpr std::array names = {
+      std::pair{partdiff::calculation_method::gauss_seidel, "Gauß-Seidel"},
+      std::pair{partdiff::calculation_method::jacobi, "Jacobi"},
+  };
+};
+
+template <>
+struct enum_member_names<partdiff::perturbation_function> {
+  static constexpr std::array names = {
+      std::pair{partdiff::perturbation_function::f0, "f(x,y) = 0"},
+      std::pair{partdiff::perturbation_function::fpisin, "f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y)"},
+  };
+};
+
+template <>
+struct enum_member_names<partdiff::termination_condition> {
+  static constexpr std::array names = {
+      std::pair{partdiff::termination_condition::accuracy, "Required accuracy"},
+      std::pair{partdiff::termination_condition::iterations, "Number of iterations"},
+  };
+};
+
+// Some template magic to print the above enum classes with "{:d}" and "{:s}"
+
+template <typename Enum>
+  requires std::is_enum_v<Enum> && requires { enum_member_names<Enum>::names; }
+struct std::formatter<Enum> : std::formatter<std::string_view> {
+  enum class mode { string, number } fmt_mode = mode::string;
+  constexpr auto parse(std::format_parse_context &ctx) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+
+    if (it != end) {
+      if (*it == 's') {
+        fmt_mode = mode::string;
+        ++it;
+      } else if (*it == 'd') {
+        fmt_mode = mode::number;
+        ++it;
+      } else if (*it != '}')
+        throw std::format_error("invalid format specifier for enum");
+    }
+    return it;
+  }
+
+  template <class FormatContext>
+  auto format(Enum value, FormatContext &ctx) const {
+    if (fmt_mode == mode::number) {
+      return std::format_to(ctx.out(), "{}", static_cast<std::underlying_type_t<Enum>>(value));
+    }
+    std::string_view name = "unknown";
+    for (auto &&[v, n] : enum_member_names<Enum>::names) {
+      if (v == value) {
+        name = n;
+        break;
+      }
+    }
+    return std::format_to(ctx.out(), "{}", name);
+  }
+};

partdiff.cpp

@@ -95,19 +95,13 @@ namespace partdiff {
     const int N = arguments.N;
     const double time = std::chrono::duration<double>(results.end_time - results.start_time).count();
     const double memory_consumption = (N + 1) * (N + 1) * sizeof(double) * arguments.num_matrices / 1024.0 / 1024.0;
-    const std::string_view calculation_method_display =
-        options.method == calculation_method::gauss_seidel ? "Gauß-Seidel" : "Jacobi";
-    const std::string_view perturbation_function_display =
-        options.pert_func == perturbation_function::f0 ? "f(x,y) = 0" : "f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y)";
-    const std::string_view termination_display =
-        options.termination == termination_condition::accuracy ? "Required accuracy" : "Number of iterations";
 
     std::println("Calculation time:       {:0.6f} s", time);
     std::println("Memory usage:           {:0.6f} MiB", memory_consumption);
-    std::println("Calculation method:     {:s}", calculation_method_display);
+    std::println("Calculation method:     {:s}", options.method);
     std::println("Interlines:             {:d}", options.interlines);
-    std::println("Perturbation function:  {:s}", perturbation_function_display);
-    std::println("Termination:            {:s}", termination_display);
+    std::println("Perturbation function:  {:s}", options.pert_func);
+    std::println("Termination:            {:s}", options.termination);
     std::println("Number of iterations:   {:d}", results.stat_iteration);
     std::println("Residuum:               {:e}", results.stat_accuracy);
   }