Allow deferring calls to lambdas and free functions

include/kouta/base/callback/base-callback.hpp

@@ -17,6 +17,7 @@ namespace kouta::base::callback
     class BaseCallback
     {
     public:
+        /// @brief The type of the callable the Callback points to.
         using Callable = std::function<void(TArgs...)>;
 
         /// @brief Default constructor.

include/kouta/base/callback/deferred-callback.hpp

@@ -13,9 +13,9 @@ namespace kouta::base::callback
     ///
     /// Because calling a deferred Callback posts an event to the destination's thread, **arguments passed to the
     /// callback must be copied during the call**, meaning that the following types of arguments should not be used
-    /// (or used with much care to prevent invalid memory access):
+    /// (or used with much care to prevent invalid memory access or race conditions):
     ///
-    /// - Pointers
+    /// - Raw pointers
     /// - Non-copyable objects
     /// - Objects referencing, but not owning, dynamic memory (e.g. @ref std::span)
     ///
@@ -26,6 +26,9 @@ namespace kouta::base::callback
     class DeferredCallback : public BaseCallback<TArgs...>
     {
     public:
+        /// @brief The type of the callable the Callback points to.
+        using Callable = BaseCallback<TArgs...>::Callable;
+
         // Copyable
         DeferredCallback(const DeferredCallback&) = default;
         DeferredCallback& operator=(const DeferredCallback&) = default;
@@ -59,5 +62,30 @@ namespace kouta::base::callback
                     object->template post<TClass, TArgs...>(method, args...);
                 });
         }
+
+        /// @brief Callback constructor from a callable.
+        ///
+        /// @details
+        /// This constructor initializes the intenal callable to the one specified in @p callable , so that it is
+        /// invoked from within the context of the provided @p object , which must implement a `post()` method to which
+        /// the invokation can be passed to defer execution.
+        ///
+        /// The developer must guarantee the lifetime of the @p object to rpevent invalid memory access.
+        ///
+        /// @tparam TClass              Object type.
+        ///
+        /// @param[in] object           Pointer to the object whose method is going to be called.
+        /// @param[in] callable         Callable to store. For instance, this could be a lambda or anything convertible
+        ///                             to `std::function`.
+        template<class TClass>
+        DeferredCallback(TClass* object, const DeferredCallback::Callable& callable)
+            : BaseCallback<TArgs...>{}
+        {
+            this->set_callable(
+                [object, callable](TArgs... args)
+                {
+                    object->template post<TArgs...>(callable, args...);
+                });
+        }
     };
 }  // namespace kouta::base::callback

include/kouta/base/component.hpp

@@ -2,8 +2,6 @@
 
 #include <boost/asio.hpp>
 
-#include <kouta/base/callback.hpp>
-
 namespace kouta::base
 {
     /// @brief Base class for asynchronous components.
@@ -22,7 +20,8 @@ namespace kouta::base
         ///                             hence its lifetime must, at least, surpass that of the child.
         explicit Component(Component* parent = nullptr)
             : m_parent{parent}
-        {}
+        {
+        }
 
         // Not copyable
         Component(const Component&) = delete;
@@ -50,12 +49,12 @@ namespace kouta::base
         ///
         /// @warning Arguments are **copied** before being passed to the event loop.
         ///
-        /// @tparam TClass              Child class whose method is going to be executed.
+        /// @tparam TClass              Child class whose method is going to be invoked.
         /// @tparam TMethodArgs         Types of the arguments that the method accepts.
         /// @tparam TArgs               Types of the arguments provided to the invocation.
         ///
-        /// @param[in] method           Method to execute. Its signature must match `void(TArgs...)`
-        /// @param[in] args             Arguments to execute the method with.
+        /// @param[in] method           Method to invoke. Its signature must match `void(TArgs...)`
+        /// @param[in] args             Arguments to invoke the method with.
         template<class TClass, class... TMethodArgs, class... TArgs>
         void post(void (TClass::*method)(TMethodArgs...), TArgs... args)
         {
@@ -67,6 +66,30 @@ namespace kouta::base
                 });
         }
 
+        /// @brief Post a function call to the event loop for deferred execution.
+        ///
+        /// @details
+        /// This allows other components, even those residing in another thread/event loop, to post a functor to this
+        /// specific component, for example a lambda function.
+        ///
+        /// @warning Arguments are **copied** before being passed to the event loop.
+        ///
+        /// @tparam TFuncArgs           Types of the arguments that the function accepts.
+        /// @tparam TArgs               Types of the arguments provided to the invocation.
+        ///
+        /// @param[in] functor          Functor to invoke invoked. Its signature must match `void(TArgs...)`
+        /// @param[in] args             Arguments to invoke the functor with.
+        template<class... TFuncArgs, class... TArgs>
+        void post(const std::function<void(TFuncArgs...)>& functor, TArgs... args)
+        {
+            boost::asio::post(
+                context().get_executor(),
+                [functor, args...]()
+                {
+                    functor(std::move(args)...);
+                });
+        }
+
     private:
         Component* m_parent;
     };

tests/base/test-base.cpp

@@ -71,10 +71,17 @@ namespace kouta::tests::base
         RootMock root{};
 
         callback::DeferredCallback<std::uint16_t> cb_a{&root, &RootMock::handler_a};
+        callback::DeferredCallback<std::uint16_t> cb_a_2{
+            &root,
+            [&root](std::uint16_t value)
+            {
+                root.handler_a(value);
+            }};
         callback::DirectCallback<std::int32_t, const std::string&> cb_b{&root, &RootMock::handler_b};
         callback::DeferredCallback<const std::vector<std::uint8_t>&> cb_c{&root, &RootMock::handler_c};
 
         std::uint16_t data_a{127};
+        std::uint16_t data_a_2{564};
 
         std::int32_t data_b_a{42};
         std::string data_b_b{"this is a test"};
@@ -86,7 +93,9 @@ namespace kouta::tests::base
 
         EXPECT_CALL(root, handler_c(data_c_copy)).Times(1);
 
-        EXPECT_CALL(root, handler_a(data_a))
+        EXPECT_CALL(root, handler_a(data_a)).Times(1);
+
+        EXPECT_CALL(root, handler_a(data_a_2))
             .WillOnce(
                 [&root]
                 {
@@ -99,6 +108,7 @@ namespace kouta::tests::base
 
         cb_a(data_a);
         cb_b(data_b_a, data_b_b);
+        cb_a_2(data_a_2);
 
         alarm(1);
         root.run();
@@ -123,7 +133,12 @@ namespace kouta::tests::base
         callback::CallbackList<std::int32_t, const std::string&> cb_list_deferred{
             callback::DeferredCallback{&root, &RootMock::handler_b},
             callback::DeferredCallback{&root, &RootMock::handler_b},
-            callback::DeferredCallback{&root, &RootMock::handler_b}};
+            callback::DeferredCallback<std::int32_t, const std::string&>{
+                &root,
+                [&root](std::int32_t value_a, const std::string& value_b)
+                {
+                    root.handler_b(value_a, value_b);
+                }}};
 
         std::uint16_t data_a{127};