Add extended SFINAE capabilities for eckit::Translator

src/eckit/CMakeLists.txt

@@ -684,6 +684,7 @@ list( APPEND eckit_utils_srcs
   utils/MD5.h
   utils/EnumBitmask.h
   utils/Optional.h
+  utils/Overloaded.h
   utils/RLE.cc
   utils/RLE.h
   utils/Regex.cc

src/eckit/utils/Overloaded.h

@@ -0,0 +1,28 @@
+#pragma once
+
+//-----------------------------------------------------------------------------
+
+namespace eckit {
+
+// Overload pattern for visiting std::variant using std::visit, see
+// https://en.cppreference.com/w/cpp/utility/variant/visit
+
+// The struct Overloaded can have arbitrary many base classes (Ts ...). It publicly inherits from each class and brings
+// the call operator (Ts::operator...) of each base class into its scope. The base classes need an overloaded call
+// operator (Ts::operator()).
+
+
+// Overload pattern
+template <typename... Ts>
+struct Overloaded : Ts... {
+    using Ts::operator()...;
+};
+
+// Explicit deduction guide for the overload pattern above (not needed as of C++20)
+template <typename... Ts>
+Overloaded(Ts...) -> Overloaded<Ts...>;
+
+}  // namespace eckit
+
+
+//-----------------------------------------------------------------------------

src/eckit/utils/Translator.cc

@@ -316,12 +316,19 @@ char Translator<std::string, char>::operator()(const std::string& s) {
     return s[0];
 }
 
+
 std::string Translator<char, std::string>::operator()(char c) {
     std::string s;
     s = c;
     return s;
 }
 
+
+std::string Translator<signed char, std::string>::operator()(signed char v) {
+    return Translator<int, std::string>{}(static_cast<int>(v));
+};
+
+
 //----------------------------------------------------------------------------------------------------------------------
 
 }  // namespace eckit

src/eckit/utils/Translator.h

@@ -18,6 +18,7 @@
 
 #include <set>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 namespace eckit {
@@ -30,8 +31,27 @@ namespace eckit {
 template <class From, class To>
 struct Translator {
 
-    // Default template calls cast
-    To operator()(const From& from) { return To(from); }
+    // Test for explicit conversion through constructor (also involves implicit conversion or or user-defined conversion operator).
+    // Note: To(from) is called with () brackets and not with {} because it includes conversion of plain datatypes - MIR is using this
+    template <typename F, std::enable_if_t<
+                              (!std::is_same_v<std::decay_t<F>, To> && std::is_constructible_v<To, F>),
+                              bool> = true>
+    auto operator()(F&& from) {
+        return To(std::forward<F>(from));
+    }
+
+
+    // If from and to type are same - simply forward - i.e. allow moving or passing references instead of performing copies
+    template <typename F, std::enable_if_t<std::is_same_v<std::decay_t<F>, To>,
+                                           bool> = true>
+    decltype(auto) operator()(F&& from) {
+        if constexpr (std::is_lvalue_reference_v<F> && !std::is_const_v<F>) {
+            return const_cast<const To&>(from);
+        }
+        else {
+            return std::forward<F>(from);
+        }
+    }
 };
 
 // Those are predefined
@@ -159,12 +179,12 @@ struct Translator<char, std::string> {
 };
 
 template <>
-struct Translator<std::string, std::vector<std::string> > {
+struct Translator<std::string, std::vector<std::string>> {
     std::vector<std::string> operator()(const std::string&);
 };
 
 template <>
-struct Translator<std::string, std::vector<long> > {
+struct Translator<std::string, std::vector<long>> {
     std::vector<long> operator()(const std::string&);
 };
 
@@ -179,7 +199,7 @@ struct Translator<std::vector<std::string>, std::string> {
 };
 
 template <>
-struct Translator<std::string, std::set<std::string> > {
+struct Translator<std::string, std::set<std::string>> {
     std::set<std::string> operator()(const std::string&);
 };
 
@@ -188,18 +208,36 @@ struct Translator<std::set<std::string>, std::string> {
     std::string operator()(const std::set<std::string>&);
 };
 
+template <>
+struct Translator<signed char, std::string> {
+    std::string operator()(signed char v);
+};
+
 
 //----------------------------------------------------------------------------------------------------------------------
 
 // This allows using the Translator without having to explicitly name the type of an argument. For example in case of
 // generic string conversion: translate<std::strig>(someVariable)
 template <typename To, typename From>
-To translate(From&& from) {
-    return Translator<typename std::decay<From>::type, To>()(std::forward<From>(from));
+decltype(auto) translate(From&& from) {
+    return Translator<std::decay_t<From>, To>{}(std::forward<From>(from));
 }
 
 //----------------------------------------------------------------------------------------------------------------------
 
+
+// primary template handles types that do not support pre-increment:
+template <typename From, typename To, class = void>
+struct IsTranslatable : std::false_type {};
+
+// specialization recognizes types that do support pre-increment:
+template <typename From, typename To>
+struct IsTranslatable<From, To,
+                      std::void_t<decltype(Translator<From, To>{}(std::declval<const From&>()))>> : std::true_type {};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
 }  // namespace eckit
 
 #endif

tests/utils/test_translator.cc

@@ -131,6 +131,13 @@ CASE("Translate strings to double") {
     EXPECT_THROWS_AS(t("foo555bar"), BadParameter);
 }
 
+
+CASE("Translate signed char as a number") {
+    Translator<signed char, std::string> t;
+
+    EXPECT(t((signed char)127) == std::string("127"));
+}
+
 //----------------------------------------------------------------------------------------------------------------------
 
 }  // namespace eckit::test