Merge pull request #1595 from ApexAI/iox-#1594-pass-cleanupcapacity-to-cxx-function

iox-#1594 Pass `CleanupCapacity` to underlying `cxx::function` in `ScopeGuard`

Author: mossmaurice-apexai

doc/website/release-notes/iceoryx-unreleased.md

@@ -45,6 +45,7 @@
 - Add "inline" keyword to smart_lock method implementation [\#1551](https://github.com/eclipse-iceoryx/iceoryx/issues/1551)
 - Fix RouDi crash due to uninitialized `ServiceRegistry` chunk [\#1575](https://github.com/eclipse-iceoryx/iceoryx/issues/1575)
 - Add check in `cxx::unique_ptr::get` to avoid `nullptr` dereferencing [\#1571](https://github.com/eclipse-iceoryx/iceoryx/issues/1571)
+- Pass `CleanupCapacity` to underlying `cxx::function` in `ScopeGuard` (formerly known as `cxx::GenericRAII`) [\#1594](https://github.com/eclipse-iceoryx/iceoryx/issues/1594)
 
 **Refactoring:**
 

iceoryx_hoofs/include/iceoryx_hoofs/cxx/scope_guard.hpp

@@ -28,16 +28,17 @@ namespace cxx
 ///             idiom quickly. You set 2 functions, one which is called in the
 ///             constructor and another function is called in the destructor
 ///             which can be useful when handling resources.
+/// @tparam [in] CleanupCapacity The static storage capacity available to store a cleanup callable in bytes
 /// @code
 /// // This example leads to a console output of:
 /// // hello world
 /// // I am doing stuff
 /// // goodbye
 /// void someFunc() {
-///     auto raii{[](){ std::cout << "hello world\n"; },
+///     ScopeGuard myScopeGuard{[](){ std::cout << "hello world\n"; },
 ///                 [](){ std::cout << "goodbye\n"; }};
 ///     std::cout << "I am doing stuff\n";
-///     // raii goes out of scope here and the cleanupFunction is called in the
+///     // myScopeGuard goes out of scope here and the cleanupFunction is called in the
 ///     // destructor
 /// }
 /// @endcode
@@ -54,7 +55,7 @@ class ScopeGuardWithVariableCapacity
     /// @param[in] initFunction callable which will be called in the constructor
     /// @param[in] cleanupFunction callable which will be called in the destructor
     ScopeGuardWithVariableCapacity(const function_ref<void()>& initFunction,
-                                   const function<void()>& cleanupFunction) noexcept;
+                                   const function<void(), CleanupCapacity>& cleanupFunction) noexcept;
 
     /// @brief calls m_cleanupFunction callable if it was set in the constructor
     ~ScopeGuardWithVariableCapacity() noexcept;

iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/scope_guard.inl

@@ -24,54 +24,54 @@ namespace iox
 {
 namespace cxx
 {
-template <uint64_t Capacity>
-inline ScopeGuardWithVariableCapacity<Capacity>::ScopeGuardWithVariableCapacity(
-    const cxx::function<void(), Capacity>& cleanupFunction) noexcept
+template <uint64_t CleanupCapacity>
+inline ScopeGuardWithVariableCapacity<CleanupCapacity>::ScopeGuardWithVariableCapacity(
+    const cxx::function<void(), CleanupCapacity>& cleanupFunction) noexcept
     : m_cleanupFunction(cleanupFunction)
 {
 }
 
-template <uint64_t Capacity>
-inline ScopeGuardWithVariableCapacity<Capacity>::ScopeGuardWithVariableCapacity(
-    const function_ref<void()>& initFunction, const function<void()>& cleanupFunction) noexcept
+template <uint64_t CleanupCapacity>
+inline ScopeGuardWithVariableCapacity<CleanupCapacity>::ScopeGuardWithVariableCapacity(
+    const function_ref<void()>& initFunction, const function<void(), CleanupCapacity>& cleanupFunction) noexcept
     : m_cleanupFunction(cleanupFunction)
 {
     initFunction();
 }
 
-template <uint64_t Capacity>
-inline ScopeGuardWithVariableCapacity<Capacity>::~ScopeGuardWithVariableCapacity() noexcept
+template <uint64_t CleanupCapacity>
+inline ScopeGuardWithVariableCapacity<CleanupCapacity>::~ScopeGuardWithVariableCapacity() noexcept
 {
     destroy();
 }
 
-template <uint64_t Capacity>
-inline ScopeGuardWithVariableCapacity<Capacity>::ScopeGuardWithVariableCapacity(
+template <uint64_t CleanupCapacity>
+inline ScopeGuardWithVariableCapacity<CleanupCapacity>::ScopeGuardWithVariableCapacity(
     ScopeGuardWithVariableCapacity&& rhs) noexcept
 {
     *this = std::move(rhs);
 }
 
-template <uint64_t Capacity>
-inline ScopeGuardWithVariableCapacity<Capacity>&
-ScopeGuardWithVariableCapacity<Capacity>::operator=(ScopeGuardWithVariableCapacity<Capacity>&& rhs) noexcept
+template <uint64_t CleanupCapacity>
+inline ScopeGuardWithVariableCapacity<CleanupCapacity>& ScopeGuardWithVariableCapacity<CleanupCapacity>::operator=(
+    ScopeGuardWithVariableCapacity<CleanupCapacity>&& rhs) noexcept
 {
     if (this != &rhs)
     {
         destroy();
         m_cleanupFunction = rhs.m_cleanupFunction;
-        rhs.m_cleanupFunction = function<void()>();
+        rhs.m_cleanupFunction = function<void(), CleanupCapacity>();
     }
     return *this;
 }
 
-template <uint64_t Capacity>
-inline void ScopeGuardWithVariableCapacity<Capacity>::destroy() noexcept
+template <uint64_t CleanupCapacity>
+inline void ScopeGuardWithVariableCapacity<CleanupCapacity>::destroy() noexcept
 {
     if (m_cleanupFunction)
     {
         m_cleanupFunction();
-        m_cleanupFunction = function<void()>();
+        m_cleanupFunction = function<void(), CleanupCapacity>();
     }
 }