iox-eclipse-iceoryx#992 Add templated from/into free functions for co…

…nversions of enums and other types

CHANGELOG.md

@@ -19,6 +19,7 @@
 - Axivion analysis on CI[\#409](https://github.com/eclipse-iceoryx/iceoryx/issues/409)
 - Cpptoml can be provided by an external source[\#951](https://github.com/eclipse-iceoryx/iceoryx/issues/)
 - Extend cxx::optional constructor for in place construction so that copy/move for values inside the optional even could be deleted[\#967](https://github.com/eclipse-iceoryx/iceoryx/issues/967)
+- Add templated `from`/`into` free functions to formalize conversions from enums and other types [#992](https://github.com/eclipse-iceoryx/iceoryx/issues/992)
 
 **Bugfixes:**
 

iceoryx_hoofs/include/iceoryx_hoofs/cxx/helplets.hpp

@@ -17,7 +17,9 @@
 #ifndef IOX_HOOFS_CXX_HELPLETS_HPP
 #define IOX_HOOFS_CXX_HELPLETS_HPP
 
-#include <assert.h>
+#include "iceoryx_hoofs/cxx/type_traits.hpp"
+
+#include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <iostream>
@@ -277,6 +279,62 @@ bool isValidFileName(const string<StringCapacity>& name) noexcept;
 template <uint64_t StringCapacity>
 bool isValidFilePath(const string<StringCapacity>& name) noexcept;
 
+/// @brief Converts a value of type F to a corresponding value of type T. This function needs to be specialized by the
+/// user for the types to be converted.
+/// @code
+/// enum class LowLevel
+/// {
+///     FileDescriptorInvalid,
+///     FileDescriptorCorrupt,
+///     Timeout
+/// };
+///
+/// enum class HighLevel
+/// {
+///     FileDescriptorError,
+///     Timeout
+/// };
+///
+/// namespace iox
+/// {
+/// namespace cxx
+/// {
+/// template <>
+/// constexpr HighLevel from<LowLevel, HighLevel>(LowLevel e) noexcept
+/// {
+///     switch (e)
+///     {
+///     case LowLevel::FileDescriptorCorrupt:
+///         return HighLevel::FileDescriptorError;
+///     case LowLevel::FileDescriptorInvalid:
+///         return HighLevel::FileDescriptorError;
+///     case LowLevel::Timeout:
+///         return HighLevel::Timeout;
+///     }
+/// }
+/// } // namespace cxx
+/// } // namespace iox
+/// @endcode
+/// @tparam F is the 'from' type
+/// @tparam T is the 'to' type
+/// @param[in] value of type F to convert to T
+/// @return converted value of F to corresponding value of T
+template <typename F, typename T>
+constexpr T from(const F value) noexcept;
+
+/// @brief Converts a value of type F to a corresponding value of type T. This is a convenience function which is
+/// automatically available when `from` is implemented. This function shall therefore not be specialized but always the
+/// `from` function.
+/// @code
+/// Bar b = iox::cxx::into<Bar>(Foo::ENUM_VALUE);
+/// @endcode
+/// @tparam T is the 'to' type
+/// @tparam F is the 'from' type
+/// @param[in] value of type F to convert to T
+/// @return converted value of F to corresponding value of T
+template <typename T, typename F>
+constexpr T into(const F value) noexcept;
+
 } // namespace cxx
 } // namespace iox
 

iceoryx_hoofs/include/iceoryx_hoofs/cxx/type_traits.hpp

@@ -45,6 +45,15 @@ struct add_const_conditionally<T, const C>
 template <typename T, typename C>
 using add_const_conditionally_t = typename add_const_conditionally<T, C>::type;
 
+///
+/// @brief Helper value to bind a static_assert to a type
+/// @code
+/// static_assert(always_false_v<Foo>, "Not implemented for the given type!");
+/// @endcode
+///
+template <typename>
+constexpr bool always_false_v = false;
+
 ///
 /// @brief Verifies whether the passed Callable type is in fact invocable with the given arguments
 ///

iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/helplets.inl

@@ -126,6 +126,19 @@ inline bool isValidFilePath(const string<StringCapacity>& name) noexcept
 
     return false;
 }
+
+template <typename F, typename T>
+constexpr T from(const F) noexcept
+{
+    static_assert(always_false_v<F> && always_false_v<T>, "Conversion for the specified types is not implemented!\
+    Please specialize `template <typename F, typename T> constexpr T from(const F) noexcept`!");
+}
+
+template <typename T, typename F>
+constexpr T into(const F e) noexcept
+{
+    return from<F, T>(e);
+}
 } // namespace cxx
 } // namespace iox
 

iceoryx_hoofs/test/moduletests/test_cxx_helplets.cpp

@@ -23,6 +23,40 @@
 #include <string>
 #include <type_traits>
 
+namespace
+{
+enum A
+{
+    A1 = 13,
+    A2
+};
+
+enum B
+{
+    B1 = 42,
+    B2
+};
+} // namespace
+
+namespace iox
+{
+namespace cxx
+{
+template <>
+constexpr B from<A, B>(A e) noexcept
+{
+    switch (e)
+    {
+    case A1:
+        return B1;
+    case A2:
+        return B2;
+    }
+}
+
+} // namespace cxx
+} // namespace iox
+
 namespace
 {
 using namespace ::testing;
@@ -449,5 +483,20 @@ TEST(Helplets_test_isValidFilePath, EmptyFilePathIsInvalid)
     EXPECT_FALSE(isValidFilePath(string<FILE_PATH_LENGTH>("")));
 }
 
+TEST(Helplets_test_from, fromWorksAsConstexpr)
+{
+    constexpr A FROM_VALUE{A1};
+    constexpr B TO_VALUE{B1};
+    constexpr B SUT = iox::cxx::from<A, B>(FROM_VALUE);
+    EXPECT_EQ(SUT, TO_VALUE);
+}
+
+TEST(Helplets_test_into, intoWorksWhenFromIsSpecialized)
+{
+    constexpr A FROM_VALUE{A2};
+    constexpr B TO_VALUE{B2};
+    constexpr B SUT = iox::cxx::into<B>(FROM_VALUE);
+    EXPECT_EQ(SUT, TO_VALUE);
+}
 
 } // namespace

iceoryx_hoofs/test/moduletests/test_cxx_type_traits.cpp

@@ -126,6 +126,14 @@ TEST(TypeTraitsTest, AddConstConditionallyTypeAliasWorks)
     EXPECT_TRUE(std::is_const<SutTypeResult>::value);
 }
 
+TEST(TypeTraitsTest, AlwaysFalseWorks)
+{
+    struct Foo
+    {
+    };
+    EXPECT_FALSE(always_false_v<Foo>);
+}
+
 TEST(TypeTraitsTest, IsFunctionPointerResolvesToTrue)
 {
     auto result = is_function_pointer<void (*)(double)>::value;