Added auto format_as() generation with EnumStrings

include/aidge/data/DataFormat.hpp

@@ -97,8 +97,4 @@ constexpr const char* const EnumStrings<Aidge::DataFormat>::data[] = {
 };
 }
 
-namespace Aidge {
-inline auto format_as(DataFormat df) { return EnumStrings<DataFormat>::data[static_cast<int>(df)]; }
-} // namespace Aidge
-
 #endif /* AIDGE_CORE_DATA_DATAFORMAT_H_ */

include/aidge/data/DataType.hpp

@@ -180,10 +180,4 @@ const char* const EnumStrings<Aidge::DataType>::data[]
        "UInt5", "UInt6", "UInt7", "UInt8", "UInt16", "UInt32", "UInt64", "Any"};
 }
 
-namespace Aidge {
-inline auto format_as(DataType dt) {
-    return EnumStrings<DataType>::data[static_cast<int>(dt)];
-}
-} // namespace Aidge
-
 #endif /* AIDGE_CORE_DATA_DATATYPE_H_ */

include/aidge/data/Elts.hpp

@@ -118,8 +118,4 @@ const char* const EnumStrings<Aidge::Elts_t::EltType>::data[]
     = {"Data", "Token", "Undef"};
 }
 
-namespace Aidge {
-inline auto format_as(Elts_t::EltType elt) { return EnumStrings<Aidge::Elts_t::EltType>::data[static_cast<int>(elt)]; }
-}
-
 #endif /* AIDGE_ELTS_H_ */

include/aidge/data/Interpolation.hpp

@@ -148,4 +148,29 @@ class Interpolation {
 };
 } // namespace Aidge
 
+/**
+ * @brief EnumStrings specialization for Interpolation::CoordinateTransformation.
+ */
+template <>
+const char* const EnumStrings<Aidge::Interpolation::CoordinateTransformation>::data[] = {
+    "HalfPixel",
+    "HalfPixelSymmetric",
+    "PytorchHalfPixel",
+    "AlignCorners",
+    "Asymmetric"
+};
+
+/**
+ * @brief EnumStrings specialization for Interpolation::Mode.
+ */
+template <>
+const char* const EnumStrings<Aidge::Interpolation::Mode>::data[] = {
+    "Cubic",
+    "Linear",
+    "RoundPreferFloor",
+    "RoundPreferCeil",
+    "Floor",
+    "Ceil"
+};
+
 #endif

include/aidge/operator/BitShift.hpp

@@ -193,4 +193,12 @@ inline std::shared_ptr<Node> BitShift(const BitShift_Op::BitShiftDirection direc
 
 #undef LIST_BITSHIFT_ATTR
 
+/**
+ * @brief EnumStrings specialization for BitShift_Op::BitShiftDirection.
+ */
+template <>
+const char* const EnumStrings<Aidge::BitShift_Op::BitShiftDirection>::data[] = {
+    "left", "right"
+};
+
 #endif /* AIDGE_CORE_OPERATOR_BITSHIFT_H_ */

include/aidge/operator/DepthToSpace.hpp

@@ -209,4 +209,12 @@ std::shared_ptr<Node> DepthToSpace(const std::uint32_t blockSize,
 
 #undef LIST_DEPTHTOSPACE_ATTR
 
+/**
+ * @brief EnumStrings specialization for DepthToSpace_Op::Mode.
+ */
+template <>
+const char* const EnumStrings<Aidge::DepthToSpace_Op::Mode>::data[] = {
+    "DCR", "CRD"
+};
+
 #endif //AIDGE_CORE_OPERATOR_DEPTHTOSPACE_H_

include/aidge/operator/GridSample.hpp

@@ -223,4 +223,20 @@ std::shared_ptr<Node> GridSample(
 
 #undef LIST_GRIDSAMPLE_ATTR
 
+/**
+ * @brief EnumStrings specialization for GridSample_Op::Mode.
+ */
+template <>
+const char* const EnumStrings<Aidge::GridSample_Op::Mode>::data[] = {
+    "Linear", "Nearest", "Cubic"
+};
+
+/**
+ * @brief EnumStrings specialization for GridSample_Op::PaddingMode.
+ */
+template <>
+const char* const EnumStrings<Aidge::GridSample_Op::PaddingMode>::data[] = {
+    "Zeros", "Border", "Reflection"
+};
+
 #endif /* AIDGE_CORE_OPERATOR_GRIDSAMPLE_H_ */

include/aidge/utils/Log.hpp

@@ -260,16 +260,6 @@ private:
 
 } // namespace Aidge
 
-// Formatter specialization for Log::Level
-template <>
-struct fmt::formatter<Aidge::Log::Level> : formatter<const char*> {
-    template <typename FormatContext>
-    auto format(const Aidge::Log::Level& level, FormatContext& ctx) const {
-        const char* name = EnumStrings<Aidge::Log::Level>::data[static_cast<int>(level)];
-        return formatter<const char*>::format(name, ctx);
-    }
-};
-
 namespace {
 template <>
 const char* const EnumStrings<Aidge::Log::Level>::data[] = {

include/aidge/utils/logger/EnumString.hpp

@@ -12,6 +12,8 @@
 #ifndef AIDGE_CORE_UTILS_LOGGER_ENUMSTRING_H_
 #define AIDGE_CORE_UTILS_LOGGER_ENUMSTRING_H_
 
+#include <fmt/format.h>
+
 namespace {
 // This is the type that will hold all the strings. Each enumerate type will
 // declare its own specialization.
@@ -20,4 +22,9 @@ template <typename T> struct EnumStrings {
 };
 }
 
+namespace Aidge {
+template <class T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
+inline auto format_as(T elt) { return EnumStrings<T>::data[static_cast<int>(elt)]; }
+}
+
 #endif /* AIDGE_CORE_UTILS_LOGGER_ENUMSTRING_H_ */