Put magic_enum reflection into EnumTools namespace

Author: sebproell

doc/documentation/src/developer_guide/codingguidelines.rst

@@ -82,8 +82,9 @@ Enums
 - By default, use scoped ``enum class`` instead of unscoped ``enum``.
 - Use enums instead of strings for parameters that take one from a fixed set of values.
 - You do not have to write conversion functions between enum constants and strings.
-  Use ``magic_enum::enum_name`` to get the name of an enum constant and ``magic_enum::enum_cast`` to convert a string to
-  an enum constant.
+  Use ``EnumTools::enum_name`` to get the name of an enum constant and ``EnumTools::enum_cast`` to convert a string to
+  an enum constant. ``EnumTools::operator<<`` and ``EnumTools::operator>>`` allow for easy interaction
+  with std streams.
 
 See also `Enum.3 <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum3-prefer-class-enums-over-plain-enums>`_.
 

src/core/io/src/4C_io_input_spec_builders.hpp

@@ -45,7 +45,7 @@ namespace Core::IO
       template <SupportedType T>
       void operator()(std::ostream& out, const T& val) const
       {
-        using magic_enum::iostream_operators::operator<<;
+        using EnumTools::operator<<;
         out << val;
       }
 
@@ -118,7 +118,7 @@ namespace Core::IO
       requires(std::is_enum_v<Enum>)
     struct PrettyTypeName<Enum>
     {
-      std::string operator()() { return std::string{magic_enum::enum_type_name<Enum>()}; }
+      std::string operator()() { return std::string{EnumTools::enum_type_name<Enum>()}; }
     };
 
     template <typename T>
@@ -174,7 +174,7 @@ namespace Core::IO
         FOUR_C_ASSERT(node.is_map(), "Expected a map node.");
         node["type"] = "enum";
         node["choices"] |= ryml::SEQ;
-        for (const auto& choice_string : magic_enum::enum_values<Enum>())
+        for (const auto& choice_string : EnumTools::enum_values<Enum>())
         {
           auto entry = node["choices"].append_child();
           // Write every choice entry as a map to easily extend the information at a later point.
@@ -1445,7 +1445,7 @@ bool Core::IO::Internal::ParameterSpec<T>::match(ConstYamlNodeRef node,
     if constexpr (std::is_enum_v<T>)
     {
       std::string choices_string;
-      for (const auto& e : magic_enum::enum_names<T>())
+      for (const auto& e : EnumTools::enum_names<T>())
       {
         choices_string += std::string(e) + "|";
       }
@@ -1850,7 +1850,7 @@ void Core::IO::Internal::SelectionSpec<T>::print(std::ostream& stream, std::size
   {
     stream << "\n";
     stream << "//" << std::string(indent + 2, ' ') << " if value of " << based_on.selector << " is "
-           << magic_enum::enum_name<T>(selector_value);
+           << EnumTools::enum_name<T>(selector_value);
     spec.impl().print(stream, indent + 4);
   }
   stream << "\n";
@@ -1973,12 +1973,12 @@ Core::IO::InputSpec Core::IO::InputSpecBuilders::selection(
     std::string name, Internal::BasedOn<T> based_on, SelectionData data)
 {
   // Ensure that every enum constant is mapped to a spec.
-  for (const auto& e : magic_enum::enum_values<T>())
+  for (const auto& e : EnumTools::enum_values<T>())
   {
     FOUR_C_ASSERT_ALWAYS(based_on.choices.contains(e),
         "You need to give an InputSpec for every possible value of enum '{}'. Missing "
         "choice for enum constant '{}'.",
-        magic_enum::enum_type_name<T>(), magic_enum::enum_name(e));
+        EnumTools::enum_type_name<T>(), EnumTools::enum_name(e));
   }
 
   std::size_t max_specs_for_choices = std::ranges::max_element(

src/core/io/src/4C_io_value_parser.hpp

@@ -12,10 +12,9 @@
 
 #include "4C_io_input_types.hpp"
 #include "4C_utils_demangle.hpp"
+#include "4C_utils_enum.hpp"
 #include "4C_utils_exceptions.hpp"
 
-#include <magic_enum/magic_enum.hpp>
-
 #include <array>
 #include <filesystem>
 #include <format>
@@ -199,15 +198,15 @@ namespace Core::IO
     {
       std::string string;
       read_internal(string);
-      auto val = magic_enum::enum_cast<Enum>(string);
+      auto val = EnumTools::enum_cast<Enum>(string);
       if (val)
       {
         value = *val;
       }
       else
       {
         FOUR_C_THROW("Could not parse value '{}' as an enum constant of type '{}'.", string,
-            magic_enum::enum_type_name<Enum>());
+            EnumTools::enum_type_name<Enum>());
       }
     }
 

src/core/io/src/4C_io_yaml.hpp

@@ -10,9 +10,9 @@
 
 #include "4C_config.hpp"
 
+#include "4C_utils_enum.hpp"
 #include "4C_utils_exceptions.hpp"
 
-#include <magic_enum/magic_enum.hpp>
 #include <ryml.hpp>      // IWYU pragma: export
 #include <ryml_std.hpp>  // IWYU pragma: export
 
@@ -173,15 +173,15 @@ namespace Core::IO
   {
     FOUR_C_ASSERT_ALWAYS(node.node.has_val(), "Expected a value node.");
     auto substr = node.node.val();
-    auto val = magic_enum::enum_cast<T>(std::string_view(substr.data(), substr.size()));
+    auto val = EnumTools::enum_cast<T>(std::string_view(substr.data(), substr.size()));
     if (val)
     {
       value = *val;
     }
     else
     {
       FOUR_C_THROW("Could not parse value '{}' as an enum constant of type '{}'.",
-          std::string_view(substr.data(), substr.size()), magic_enum::enum_type_name<T>());
+          std::string_view(substr.data(), substr.size()), EnumTools::enum_type_name<T>());
     }
   }
 
@@ -233,7 +233,7 @@ template <typename T>
   requires(std::is_enum_v<T>)
 void Core::IO::emit_value_as_yaml(YamlNodeRef node, const T& value)
 {
-  std::string_view str = magic_enum::enum_name(value);
+  std::string_view str = EnumTools::enum_name(value);
   node.node << ryml::csubstr(str.data(), str.size());
 }
 

src/core/linalg/src/dense/4C_linalg_utils_densematrix_funct.hpp

@@ -23,9 +23,6 @@ exponential and the logarithm, along with specific derivatives in namespace Core
 #include "4C_linalg_fixedsizematrix.hpp"
 #include "4C_linalg_utils_densematrix_eigen.hpp"
 
-#include <magic_enum/magic_enum.hpp>
-
-#include <cstddef>
 #include <optional>
 
 FOUR_C_NAMESPACE_OPEN

src/core/linalg/src/dense/4C_linalg_utils_tensor_interpolation.cpp

@@ -573,7 +573,7 @@ Core::LinAlg::TensorInterpolation::SecondOrderTensorInterpolator<loc_dim>::get_i
     FOUR_C_THROW(
         "We do not have an implementation for RotationInterpolationType {} and EigenvalInterpType "
         "{}!",
-        magic_enum::enum_name(rot_interp_type_), magic_enum::enum_name(eigenval_interp_type_));
+        rot_interp_type_, eigenval_interp_type_);
   }
   return output;
 }

src/core/linalg/src/dense/4C_linalg_utils_tensor_interpolation.hpp

@@ -16,8 +16,6 @@
 #include "4C_utils_enum.hpp"
 #include "4C_utils_exceptions.hpp"
 
-#include <magic_enum/magic_enum.hpp>
-
 FOUR_C_NAMESPACE_OPEN
 
 namespace Core::LinAlg

src/core/utils/src/stl_extension/4C_utils_enum.hpp

@@ -16,12 +16,24 @@
 // 2) Include magic_enum header.
 #include <magic_enum/magic_enum_format.hpp>
 #include <magic_enum/magic_enum_iostream.hpp>
+#include <magic_enum/magic_enum_switch.hpp>
 
 FOUR_C_NAMESPACE_OPEN
 
-// Import the stream insertion and extraction operators for enums.
-using magic_enum::iostream_operators::operator<<;
-using magic_enum::iostream_operators::operator>>;
+/**
+ * This namespace contains helpers for static reflection of enums.
+ *
+ * @note The implementation is currently provided by the magic_enum library.
+ */
+namespace EnumTools
+{
+  // Import the stream insertion and extraction operators for enums.
+  using magic_enum::iostream_operators::operator<<;
+  using magic_enum::iostream_operators::operator>>;
+
+  // Import everything from magic_enum into our namespace.
+  using namespace magic_enum;
+}  // namespace EnumTools
 
 FOUR_C_NAMESPACE_CLOSE
 

src/poroelast/4C_poroelast_monolithic.cpp

@@ -848,8 +848,8 @@ void PoroElast::Monolithic::print_newton_iter_header_stream(std::ostringstream&
 {
   oss << "------------------------------------------------------------" << std::endl;
   oss << "                   Newton-Raphson Scheme                    " << std::endl;
-  oss << "                NormRES " << magic_enum::enum_name(vectornormfres_);
-  oss << "     NormINC " << magic_enum::enum_name(vectornorminc_) << "                    "
+  oss << "                NormRES " << EnumTools::enum_name(vectornormfres_);
+  oss << "     NormINC " << EnumTools::enum_name(vectornorminc_) << "                    "
       << std::endl;
   oss << "------------------------------------------------------------" << std::endl;
 

src/poroelast_scatra/4C_poroelast_scatra_monolithic.cpp

@@ -711,8 +711,8 @@ void PoroElastScaTra::PoroScatraMono::print_newton_iter_header(FILE* ofile)
 
   oss << "------------------------------------------------------------" << std::endl;
   oss << "                   Newton-Raphson Scheme                    " << std::endl;
-  oss << "                NormRES " << magic_enum::enum_name(vectornormfres_);
-  oss << "     NormINC " << magic_enum::enum_name(vectornorminc_) << "                    "
+  oss << "                NormRES " << EnumTools::enum_name(vectornormfres_);
+  oss << "     NormINC " << EnumTools::enum_name(vectornorminc_) << "                    "
       << std::endl;
   oss << "------------------------------------------------------------" << std::endl;