Merge pull request #718 from sebproell/enum-tools

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_parameter_container.hpp

@@ -56,7 +56,8 @@ namespace Core::IO
     /**
      * \brief Add @data to the container at the given key @name.
      *
-     * If an entry with given @p name already exists, it will be overwritten.
+     * If an entry with given @p name already exists, it will be overwritten. The type must be
+     * one of the SupportedType of the input framework.
      */
     template <typename T>
     void add(const std::string& name, const T& data);
@@ -77,7 +78,7 @@ namespace Core::IO
     [[nodiscard]] auto groups() const;
 
     /**
-     * Check if a group with the name @p name exists.
+     * Check if a group with the given @p name exists.
      */
     [[nodiscard]] bool has_group(const std::string& name) const;
 

src/core/io/src/4C_io_input_parameter_container.templates.hpp

@@ -22,27 +22,34 @@ FOUR_C_NAMESPACE_OPEN
 // into this special templates file.
 namespace Core::IO::Internal::InputParameterContainerImplementation
 {
-  // Default printer if not printable.
   template <typename T>
-  struct PrintHelper
-  {
-    void operator()(std::ostream& os, const std::any& data) { os << "<not printable> "; }
+  concept StreamInsertable = requires(std::ostream& os, const std::any& data) {
+    { os << std::any_cast<T>(data) };
   };
 
+  // Helper struct to print the data in the container.
   template <typename T>
-  concept StreamInsertable = requires(std::ostream& os, const T& t) { os << t; };
-
-  // Specialization for stream insert.
-  template <StreamInsertable T>
-  struct PrintHelper<T>
+  struct PrintHelper
   {
-    void operator()(std::ostream& os, const std::any& data) { os << std::any_cast<T>(data) << " "; }
+    void operator()(std::ostream& os, const std::any& data) const
+    {
+      if constexpr (StreamInsertable<std::remove_reference_t<T>> || std::is_enum_v<T>)
+      {
+        using EnumTools::operator<<;
+        os << std::any_cast<T>(data) << " ";
+      }
+      else
+      {
+        os << "<not printable> ";
+      }
+    }
   };
 
-  template <StreamInsertable T>
+  // Specialization for std::optional.
+  template <SupportedType T>
   struct PrintHelper<std::optional<T>>
   {
-    void operator()(std::ostream& os, const std::any& data)
+    void operator()(std::ostream& os, const std::any& data) const
     {
       auto val = std::any_cast<std::optional<T>>(data);
       if (val.has_value())
@@ -53,10 +60,10 @@ namespace Core::IO::Internal::InputParameterContainerImplementation
   };
 
   // Specialization for vectors.
-  template <typename T>
+  template <SupportedType T>
   struct PrintHelper<std::vector<T>>
   {
-    void operator()(std::ostream& os, const std::any& data)
+    void operator()(std::ostream& os, const std::any& data) const
     {
       FOUR_C_ASSERT(typeid(std::vector<T>) == data.type(), "Implementation error.");
       const auto& vec = std::any_cast<std::vector<T>>(data);
@@ -68,10 +75,10 @@ namespace Core::IO::Internal::InputParameterContainerImplementation
   };
 
   // Specialization for maps.
-  template <typename Key, typename Value>
+  template <typename Key, SupportedType Value>
   struct PrintHelper<std::map<Key, Value>>
   {
-    void operator()(std::ostream& os, const std::any& data)
+    void operator()(std::ostream& os, const std::any& data) const
     {
       FOUR_C_ASSERT(typeid(std::map<Key, Value>) == data.type(), "Implementation error.");
       const auto& map = std::any_cast<std::map<Key, Value>>(data);

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