Implement support for multiple entry and exit functions

Author: dziegel

include/cpp_event_framework/Statemachine.hxx

@@ -264,27 +264,41 @@ public:
         StatePtr const initial_ = nullptr;
 
         /**
-         * @brief Optional entry action
-         *
+         * @brief Optional list of entry actions
          */
-        EntryExitType const on_entry_ = nullptr;
+        std::span<const EntryExitType> const on_entry_;
         /**
-         * @brief Optional exit action
-         *
+         * @brief Optional single entry action
+         */
+        EntryExitType const on_single_entry_ = nullptr;
+        /**
+         * @brief Optional list of exit actions
          */
-        EntryExitType const on_exit_ = nullptr;
+        std::span<const EntryExitType> const on_exit_;
+        /**
+         * @brief Optional single exit action
+         */
+        EntryExitType const on_single_exit_ = nullptr;
         /**
          * @brief Statemachine handler, must be assigned
          */
         HandlerType const handler_ = nullptr;
 
         /**
          * @brief Construct a new Statemachine State object
-         *
          */
         constexpr State(const char* name, HandlerType handler, StatePtr parent = nullptr, StatePtr initial = nullptr,
                         EntryExitType on_entry = nullptr, EntryExitType on_exit = nullptr) noexcept
-            : State(name, handler, parent, initial, on_entry, on_exit, EFlags::kNone)
+            : State(name, handler, parent, initial, on_entry, {}, on_exit, {}, EFlags::kNone)
+        {
+        }
+
+        /**
+         * @brief Construct a new Statemachine State object
+         */
+        constexpr State(const char* name, HandlerType handler, StatePtr parent, StatePtr initial,
+                        std::span<const EntryExitType> on_entry, std::span<const EntryExitType> on_exit) noexcept
+            : State(name, handler, parent, initial, nullptr, on_entry, nullptr, on_exit, EFlags::kNone)
         {
         }
 
@@ -301,33 +315,31 @@ public:
         /**
          * @brief Stream operator for logging
          */
-        friend inline std::ostream& operator<<(std::ostream& os, StateRef state)
+        friend std::ostream& operator<<(std::ostream& os, StateRef state)
         {
             return os << state.Name();
         }
 
     protected:
         /**
          * @brief Construct a new Statemachine State object
-         *
          */
         constexpr State(const char* name, HandlerType handler, StatePtr parent, StatePtr initial,
-                        EntryExitType on_entry, EntryExitType on_exit, EFlags flags) noexcept
+                        EntryExitType on_single_entry, std::span<const EntryExitType> on_entry,
+                        EntryExitType on_single_exit, std::span<const EntryExitType> on_exit, EFlags flags) noexcept
             : flags_(flags)
             , parent_(parent)
             , initial_(initial)
             , on_entry_(on_entry)
+            , on_single_entry_(on_single_entry)
             , on_exit_(on_exit)
+            , on_single_exit_(on_single_exit)
             , handler_(handler)
             , name_(name)
         {
         }
 
     private:
-        /**
-         * @brief Statename, optional, useful for logging
-         *
-         */
         const char* name_ = nullptr;
     };
 
@@ -339,13 +351,22 @@ public:
     {
     public:
         /**
-         * @brief Construct a new Statemachine State object
-         *
+         * @brief Construct a new History State
          */
         constexpr HistoryState(const char* name, typename State::HandlerType handler, StatePtr parent = nullptr,
                                StatePtr initial = nullptr, typename State::EntryExitType on_entry = nullptr,
                                typename State::EntryExitType on_exit = nullptr) noexcept
-            : State(name, handler, parent, initial, on_entry, on_exit, EFlags::kHistory)
+            : State(name, handler, parent, initial, on_entry, {}, on_exit, {}, EFlags::kHistory)
+        {
+        }
+
+        /**
+         * @brief Construct a new History State
+         */
+        constexpr HistoryState(const char* name, typename State::HandlerType handler, StatePtr parent, StatePtr initial,
+                               std::span<typename State::EntryExitType> on_entry,
+                               std::span<typename State::EntryExitType> on_exit) noexcept
+            : State(name, handler, parent, initial, nullptr, on_entry, nullptr, on_exit, EFlags::kNone)
         {
         }
     };
@@ -721,9 +742,13 @@ private:
             on_state_exit_(*this, *state);
         }
 
-        if (state->on_exit_ != nullptr)
+        if (state->on_single_exit_ != nullptr)
         {
-            (impl_->*state->on_exit_)();
+            (impl_->*state->on_single_exit_)();
+        }
+        for (const auto& on_ex : state->on_exit_)
+        {
+            (impl_->*on_ex)();
         }
     }
 
@@ -762,9 +787,13 @@ private:
             on_state_entry_(*this, state);
         }
 
-        if (state.on_entry_ != nullptr)
+        if (state.on_single_entry_ != nullptr)
+        {
+            (impl_->*state.on_single_entry_)();
+        }
+        for (const auto& on_en : state.on_entry_)
         {
-            (impl_->*state.on_entry_)();
+            (impl_->*on_en)();
         }
     }
 

test/Statemachine_unittest.cxx

@@ -41,6 +41,9 @@ class Fsm : public cpp_event_framework::Statemachine<StatemachineImpl, const cpp
     static const State kRedYellow;
 
 private:
+    static const std::array<State::EntryExitType, 2> FsmOffEntryActions;
+    static const std::array<State::EntryExitType, 2> FsmOffExitActions;
+
     static Transition FsmOffHandler(ImplPtr /*impl*/, Event event);
 
     static Transition FsmOnHandler(ImplPtr /*impl*/, Event event);
@@ -93,7 +96,9 @@ class StatemachineImpl
     }
 
     bool off_entry_called_ = false;
+    bool off_entry2_called_ = false;
     bool off_exit_called_ = false;
+    bool off_exit2_called_ = false;
     bool on_entry_called_ = false;
     bool on_exit_called_ = false;
     bool yellow_red_transition1_called_ = false;
@@ -112,7 +117,9 @@ class StatemachineImpl
     void CheckAllFalse() const
     {
         assert(off_entry_called_ == false);
+        assert(off_entry2_called_ == false);
         assert(off_exit_called_ == false);
+        assert(off_exit2_called_ == false);
         assert(on_entry_called_ == false);
         assert(on_exit_called_ == false);
         assert(yellow_red_transition1_called_ == false);
@@ -127,13 +134,23 @@ class StatemachineImpl
         off_entry_called_ = true;
         std::cout << "Off entry\n";
     }
+    void FsmOffEntry2()
+    {
+        off_entry2_called_ = true;
+        std::cout << "Off entry2\n";
+    }
 
     void FsmOffExit()
     {
         off_exit_called_ = true;
         fsm_.RecallEvents();
         std::cout << "Off exit\n";
     }
+    void FsmOffExit2()
+    {
+        off_exit2_called_ = true;
+        std::cout << "Off exit2\n";
+    }
 
     void FsmOnEntry()
     {
@@ -179,26 +196,34 @@ class StatemachineImpl
         assert(fsm_.CurrentState() == &Fsm::kOff);
         assert(off_entry_called_ == true);
         off_entry_called_ = false;
+        assert(off_entry2_called_ == true);
+        off_entry2_called_ = false;
         CheckAllFalse();
 
         fsm_.React(EvtSelfTransition::MakeShared());
         assert(fsm_.CurrentState() == &Fsm::kOff);
         assert(off_entry_called_ == true);
         off_entry_called_ = false;
+        assert(off_entry2_called_ == true);
+        off_entry2_called_ = false;
         assert(off_exit_called_ == true);
         off_exit_called_ = false;
+        assert(off_exit2_called_ == true);
+        off_exit2_called_ = false;
         assert(on_recall_event_called_ == true);
         on_recall_event_called_ = false;
         CheckAllFalse();
 
         fsm_.React(EvtTurnOn::MakeShared());
         assert(off_exit_called_ == true);
-        assert(on_entry_called_ == true);
-        assert(on_recall_event_called_ == true);
-        assert(fsm_.CurrentState() == &Fsm::kGreen);
         off_exit_called_ = false;
+        assert(off_exit2_called_ == true);
+        off_exit2_called_ = false;
+        assert(on_entry_called_ == true);
         on_entry_called_ = false;
+        assert(on_recall_event_called_ == true);
         on_recall_event_called_ = false;
+        assert(fsm_.CurrentState() == &Fsm::kGreen);
         CheckAllFalse();
 
         fsm_.React(EvtTurnOn::MakeShared());
@@ -211,10 +236,10 @@ class StatemachineImpl
 
         fsm_.React(EvtGoRed::MakeShared());
         assert(yellow_red_transition1_called_ == true);
-        assert(yellow_red_transition2_called_ == true);
-        assert(fsm_.CurrentState() == &Fsm::kRed);
         yellow_red_transition1_called_ = false;
+        assert(yellow_red_transition2_called_ == true);
         yellow_red_transition2_called_ = false;
+        assert(fsm_.CurrentState() == &Fsm::kRed);
         CheckAllFalse();
 
         fsm_.React(EvtGoYellow::MakeShared());
@@ -235,10 +260,12 @@ class StatemachineImpl
 
         fsm_.React(EvtTurnOff::MakeShared());
         assert(on_exit_called_ == true);
-        assert(off_entry_called_ == true);
-        assert(fsm_.CurrentState() == &Fsm::kOff);
         on_exit_called_ = false;
+        assert(off_entry_called_ == true);
         off_entry_called_ = false;
+        assert(off_entry2_called_ == true);
+        off_entry2_called_ = false;
+        assert(fsm_.CurrentState() == &Fsm::kOff);
         CheckAllFalse();
 
         fsm_.React(EvtGoGreen::MakeShared());
@@ -271,7 +298,11 @@ class StatemachineImpl
     }
 };
 
-const Fsm::State Fsm::kOff("Off", &FsmOffHandler, nullptr, nullptr, &Fsm::Impl::FsmOffEntry, &Fsm::Impl::FsmOffExit);
+const std::array<Fsm::State::EntryExitType, 2> Fsm::FsmOffEntryActions =
+    std::to_array<Fsm::State::EntryExitType>({&Fsm::Impl::FsmOffEntry, &Fsm::Impl::FsmOffEntry2});
+const std::array<Fsm::State::EntryExitType, 2> Fsm::FsmOffExitActions =
+    std::to_array<Fsm::State::EntryExitType>({&Fsm::Impl::FsmOffExit, &Fsm::Impl::FsmOffExit2});
+const Fsm::State Fsm::kOff("Off", &FsmOffHandler, nullptr, nullptr, FsmOffEntryActions, FsmOffExitActions);
 const Fsm::HistoryState Fsm::kOn("On", &FsmOnHandler, nullptr, &kGreen, &Fsm::Impl::FsmOnEntry, &Fsm::Impl::FsmOnExit);
 const Fsm::State Fsm::kGreen("Green", &FsmGreenHandler, &kOn);
 const Fsm::State Fsm::kYellow("Yellow", &FsmYellowHandler, &kOn);