Use if constexpr instead of sfinae where possible

Author: filipe-cuim

libs/bsw/middleware/include/middleware/core/MessagePayloadBuilder.h

@@ -41,51 +41,34 @@ class MessagePayloadBuilder final
      * \param numberOfReferences Number of references sharing this payload (1 = unique)
      * \return HRESULT indicating success or failure
      */
-    /// Non-trivially copyable types: externally allocated + serialized.
-    template<
-        typename T,
-        typename etl::enable_if<!etl::is_trivially_copyable<T>::value, int>::type = 0>
+    template<typename T>
     [[nodiscard]] HRESULT
     allocate(T const& obj, Message& msg, uint8_t const numberOfReferences = 1U)
     {
-        HRESULT ret = HRESULT::CannotAllocatePayload;
-
-        size_t const payloadSize = T::AllocationPolicy::getNeededSize(obj);
-        etl::optional<etl::span<uint8_t>> buffer
-            = allocateNonTrivialType(payloadSize, msg, numberOfReferences);
-        if (buffer.has_value())
+        if constexpr (!etl::is_trivially_copyable_v<T>)
         {
-            T::AllocationPolicy::serialize(obj, buffer.value());
-            ret = HRESULT::Ok;
+            HRESULT ret = HRESULT::CannotAllocatePayload;
+
+            size_t const payloadSize = T::AllocationPolicy::getNeededSize(obj);
+            etl::optional<etl::span<uint8_t>> buffer
+                = allocateNonTrivialType(payloadSize, msg, numberOfReferences);
+            if (buffer.has_value())
+            {
+                T::AllocationPolicy::serialize(obj, buffer.value());
+                ret = HRESULT::Ok;
+            }
+
+            return ret;
+        }
+        else if constexpr (sizeof(T) <= Message::MAX_PAYLOAD_SIZE)
+        {
+            msg.constructObjectAtPayload(obj);
+            return HRESULT::Ok;
+        }
+        else
+        {
+            return allocateTrivialType(&obj, sizeof(obj), msg, numberOfReferences);
         }
-
-        return ret;
-    }
-
-    /// Small trivially copyable types: stored in internal buffer.
-    template<
-        typename T,
-        typename etl::enable_if<
-            etl::is_trivially_copyable<T>::value && (sizeof(T) <= Message::MAX_PAYLOAD_SIZE),
-            int>::type
-        = 0>
-    [[nodiscard]] HRESULT allocate(T const& obj, Message& msg, uint8_t const = 1U)
-    {
-        msg.constructObjectAtPayload(obj);
-        return HRESULT::Ok;
-    }
-
-    /// Large trivially copyable types: externally allocated.
-    template<
-        typename T,
-        typename etl::enable_if<
-            etl::is_trivially_copyable<T>::value && (sizeof(T) > Message::MAX_PAYLOAD_SIZE),
-            int>::type
-        = 0>
-    [[nodiscard]] HRESULT
-    allocate(T const& obj, Message& msg, uint8_t const numberOfReferences = 1U)
-    {
-        return allocateTrivialType(&obj, sizeof(obj), msg, numberOfReferences);
     }
 
     /**
@@ -96,20 +79,6 @@ class MessagePayloadBuilder final
      * \param numberOfReferences Number of shared references
      * \return HRESULT indicating success or failure
      */
-    [[nodiscard]] HRESULT
-    allocate(etl::span<uint8_t> const span, Message& msg, uint8_t const numberOfReferences = 1U)
-    {
-        return allocate(static_cast<etl::span<uint8_t const>>(span), msg, numberOfReferences);
-    }
-
-    /**
-     * Specialization for const byte spans to copy the span's data contents.
-     *
-     * \param span Span of const bytes to copy into the message
-     * \param msg The message to store the payload in
-     * \param numberOfReferences Number of shared references
-     * \return HRESULT indicating success or failure
-     */
     [[nodiscard]] HRESULT allocate(
         etl::span<uint8_t const> const span, Message& msg, uint8_t const numberOfReferences = 1U)
     {
@@ -118,10 +87,7 @@ class MessagePayloadBuilder final
             msg.copyRawBytesToPayload(span);
             return HRESULT::Ok;
         }
-        else
-        {
-            return allocateTrivialType(span.data(), span.size_bytes(), msg, numberOfReferences);
-        }
+        return allocateTrivialType(span.data(), span.size_bytes(), msg, numberOfReferences);
     }
 
     /**
@@ -131,41 +97,25 @@ class MessagePayloadBuilder final
      * \param msg The message containing the payload
      * \return The deserialized object
      */
-    /// Non-trivially copyable types: deserialize from external allocation.
-    template<
-        typename T,
-        typename etl::enable_if<!etl::is_trivially_copyable<T>::value, int>::type = 0>
-    T readPayload(Message const& msg)
-    {
-        uint8_t* ptr = getAllocatorPointerFromMessage(msg);
-        T obj = T::AllocationPolicy::deserialize(etl::span<uint8_t>(ptr, msg.getPayloadSize()));
-
-        return obj;
-    }
-
-    /// Small trivially copyable types: read from internal buffer.
-    template<
-        typename T,
-        typename etl::enable_if<
-            etl::is_trivially_copyable<T>::value && (sizeof(T) <= Message::MAX_PAYLOAD_SIZE),
-            int>::type
-        = 0>
+    template<typename T>
     T readPayload(Message const& msg)
     {
-        return msg.getObjectStoredInPayload<T>();
-    }
+        if constexpr (!etl::is_trivially_copyable_v<T>)
+        {
+            uint8_t* ptr = getAllocatorPointerFromMessage(msg);
+            T obj = T::AllocationPolicy::deserialize(etl::span<uint8_t>(ptr, msg.getPayloadSize()));
 
-    /// Large trivially copyable types: read from external allocation.
-    template<
-        typename T,
-        typename etl::enable_if<
-            etl::is_trivially_copyable<T>::value && (sizeof(T) > Message::MAX_PAYLOAD_SIZE),
-            int>::type
-        = 0>
-    T readPayload(Message const& msg)
-    {
-        uint8_t* ptr = getAllocatorPointerFromMessage(msg);
-        return etl::get_object_at<T>(ptr);
+            return obj;
+        }
+        else if constexpr (sizeof(T) <= Message::MAX_PAYLOAD_SIZE)
+        {
+            return msg.getObjectStoredInPayload<T>();
+        }
+        else
+        {
+            uint8_t* ptr = getAllocatorPointerFromMessage(msg);
+            return etl::get_object_at<T>(ptr);
+        }
     }
 
     /**

libs/bsw/middleware/include/middleware/core/ProxyEventBase.h

@@ -69,19 +69,18 @@ class ProxyEventBase
     void unsetReceiveHandler() noexcept { _cbk = OnFieldChangedCallback(); }
 
 private:
-    template<typename E = EventType, typename etl::enable_if<etl::is_void<E>::value, int>::type = 0>
-    void setEvent_(Message const& /* msg */) const
+    void setEvent_([[maybe_unused]] Message const& msg) const
     {
-        _cbk.call_if();
-    }
-
-    template<
-        typename E                                                  = EventType,
-        typename etl::enable_if<!etl::is_void<E>::value, int>::type = 0>
-    void setEvent_(Message const& msg) const
-    {
-        E const& data = MessagePayloadBuilder::getInstance().template readPayload<E>(msg);
-        _cbk.call_if(data);
+        if constexpr (etl::is_void_v<EventType>)
+        {
+            _cbk.call_if();
+        }
+        else
+        {
+            EventType const& data
+                = MessagePayloadBuilder::getInstance().readPayload<EventType>(msg);
+            _cbk.call_if(data);
+        }
     }
 
     OnFieldChangedCallback _cbk;

libs/bsw/middleware/test/src/core/FutureDispatcherTest.cpp

@@ -253,7 +253,7 @@ void callUpdateTimeouts(Dispatcher&, long)
 TYPED_TEST(FutureDispatcherTestSuite, TestTimeoutDispatching)
 {
     using TraitsUnderTest = typename TypeParam::TraitsUnderTest;
-    if (TraitsUnderTest::TIMEOUT_VALUE > 0U)
+    if constexpr (TraitsUnderTest::TIMEOUT_VALUE > 0U)
     {
         using RefApp = typename TestFixture::RefApp;
         etl::optional<uint16_t> requestId{};
@@ -276,6 +276,11 @@ TYPED_TEST(FutureDispatcherTestSuite, TestTimeoutDispatching)
             callUpdateTimeouts(*this, 0);
         }
     }
+    else
+    {
+        GTEST_SKIP() << "Test should only run for dispatchers that contain future objects with "
+                        "timeouts bigger than 0.";
+    }
 }
 
 TYPED_TEST(FutureDispatcherTestSuite, TestRequestIdWraparound)