Remove possibility to use delegates as actions. Not useful enough.

Author: dziegel

README.md

@@ -25,7 +25,6 @@ Header-only C++ event, statemachine and active object framework
 - Designed to call member functions of a C++ interface
 - It is fairly simple to write statemachines "by hand" without a code generator
 - Suitable for small systems: state declarations can be const and in RO section
-- Allow non-capturing lambdas as transition action
 - Logging support (state entry/exit/handler events)
 - States have names for logging (and an ostream operator<<)
 - Statemachines have names for logging (and an ostream operator<<)
@@ -315,10 +314,6 @@ The predefined HeapAllocator is simply an allocator based on std::pmr::new_delet
         // Using class StatemachineImplementation member function
         return Fsm::TransitionTo(Fsm::kState1, &StatemachineImplementation::SomeAction);
 
-        // using non-capturing lambda
-        return Fsm::TransitionTo(Fsm::kState1,
-            [](Fsm::ImplPtr, Fsm::Event) { std::cout << "Transition action" << std::endl; });
-
 3) No transition - event is handled, but no state transition occurs:
 
         return Fsm::NoTransition();
@@ -328,9 +323,6 @@ The predefined HeapAllocator is simply an allocator based on std::pmr::new_delet
         // Using class StatemachineImplementation member function
         return Fsm::NoTransition(&StatemachineImplementation::SomeAction);
 
-        // using non-capturing lambda
-        return Fsm::NoTransition([](Fsm::ImplPtr, Fsm::Event) { std::cout << "Transition action" << std::endl; });
-
 5) Event is not handled in this state. In hierarchical statemachines, the event will be passed to parent state handler.
    When topmost state does not handle the event, fsm_.on_unhandled_event_ is called.
 
@@ -420,10 +412,9 @@ Example:
 
         void (Fsm::ImplPtr)()
 
-- Transition actions. The signature allows to use class member functions and non-capturing lambdas as actions. The argument "event" may be useful in actions because the action may depend on the event type or attributes of the event.
+- Transition actions. The signature allows to use class/interface member functions as actions. The argument "event" may be useful in actions because the action may depend on the event type or attributes of the event.
 
-        void (*)(Fsm::ImplPtr impl, Fsm::Event event) // Non-capturing lambda
-        void (Fsm::ImplPtr)(Fsm::Event event)         // C++
+        void (Fsm::ImplPtr)(Fsm::Event event)
 
 ### Logging
 

include/cpp_event_framework/Statemachine.hxx

@@ -146,12 +146,6 @@ public:
      */
     using ActionType = void (ImplType::*)(Event);
 
-    /**
-     * @brief Type of action handler
-     *
-     */
-    using DelegateActionType = void (*)(ImplPtr, Event);
-
     /**
      * @brief State machine transition class, used internally
      */
@@ -164,12 +158,6 @@ public:
          */
         using ActionType = Statemachine::ActionType;
 
-        /**
-         * @brief Type of action handler (for compatibility, use Statemachine::DelegateActionType instead)
-         *
-         */
-        using DelegateActionType = Statemachine::DelegateActionType;
-
     private:
         // this class is for internal use by Statemachine only
         friend class Statemachine;
@@ -187,10 +175,6 @@ public:
          */
         void ExecuteActions(ImplPtr impl, Event event)
         {
-            if (delegate_action_ != nullptr)
-            {
-                delegate_action_(impl, event);
-            }
             if (single_action_ != nullptr)
             {
                 (impl->*single_action_)(event);
@@ -216,17 +200,6 @@ public:
         constexpr explicit Transition(StateRef target) noexcept : target_(&target)
         {
         }
-        /**
-         * @brief Construct a new Statemachine Transition object
-         * Use Statemachine::TransitionTo() instead
-         *
-         * @param target Target state
-         * @param action Transition action
-         */
-        constexpr Transition(StateRef target, DelegateActionType action) noexcept
-            : target_(&target), delegate_action_(action)
-        {
-        }
         /**
          * @brief Construct a new Statemachine Transition object
          * Use Statemachine::TransitionTo() instead
@@ -255,12 +228,6 @@ public:
          * Provides storage for single transition actions
          */
         ActionType single_action_ = nullptr;
-        /**
-         * @brief Optional single lambda transition action
-         *
-         * std::function<> cannot be used here - not longer possible to store Transition in RO section!
-         */
-        DelegateActionType delegate_action_ = nullptr;
         /**
          * @brief Optional transition actions
          *
@@ -629,16 +596,6 @@ public:
     {
         return Transition(kNone);
     }
-    /**
-     * @brief Event was handled, but no transition shall be executed, with action
-     *
-     * @param action Action to execute
-     * @return Transition
-     */
-    static inline Transition NoTransition(DelegateActionType action)
-    {
-        return Transition(kNone, action);
-    }
     /**
      * @brief Event was handled, but no transition shall be executed, with action
      *
@@ -670,17 +627,6 @@ public:
     {
         return Transition(target);
     }
-    /**
-     * @brief Create transition to target state, with action
-     *
-     * @param target Target state
-     * @param action Action to execute on transition
-     * @return Transition
-     */
-    static inline Transition TransitionTo(StateRef target, DelegateActionType action)
-    {
-        return Transition(target, action);
-    }
     /**
      * @brief Create transition to target state, with action
      *

test/Statemachine_unittest.cxx

@@ -155,6 +155,11 @@ class StatemachineImpl
         std::cout << "Don't walk 2\n";
     }
 
+    void Walk(Fsm::Event /*event*/)
+    {
+        std::cout << "Walk\n";
+    }
+
 public:
     void Main()
     {
@@ -319,7 +324,7 @@ Fsm::Transition Fsm::FsmRedYellowHandler(ImplPtr /*impl*/, Event event)
     switch (event->Id())
     {
     case EvtGoGreen::kId:
-        return TransitionTo(kGreen, [](ImplPtr /*impl*/, Event /*event*/) { std::cout << "Walk\n"; });
+        return TransitionTo(kGreen, &Fsm::Impl::Walk);
     case EvtGoYellow::kId:
         return NoTransition();
     default: