fsm: add draft for state handlers list traverse

Author: polesskiy-dev

src/active-object/active_object_impl.h

@@ -17,14 +17,20 @@
     void ACTIVE_OBJECT_T##_Dispatch(ACTIVE_OBJECT_T *const self, EVENT_T event) { \
         if (QUEUE_##EVENT_T##_IsFull(&self->queue)) return; /* TODO Handle error, e.g., logging */ \
         QUEUE_##EVENT_T##_Enqueue(&self->queue, event); \
-    } \
+    }                                                                                               \
+                                                                                                    \
+    /* TODO add non basic transition, handle start, traverse, exit state functions */ \
     \
     bool ACTIVE_OBJECT_T##_basicTransitionToNextState(ACTIVE_OBJECT_T *const self, STATE_T nextState) { \
         self->state = nextState; \
         return true; \
     } \
     \
-    void ACTIVE_OBJECT_T##_ProcessQueue(ACTIVE_OBJECT_T *const self, EVENT_T##_HANDLER_F eventHandlerCb, STATE_T##_TRANSITION_F transitionToNextStateCb, ACTIVE_OBJECT_T##HAS_EMPTY_QUEUE_F hasEmptyQueueCb) { \
+    void ACTIVE_OBJECT_T##_ProcessQueue(                                                            \
+            ACTIVE_OBJECT_T *const self,                                \
+            EVENT_T##_HANDLER_F eventHandlerCb,                                                             \
+            STATE_T##_TRANSITION_F transitionToNextStateCb,                                                 \
+            ACTIVE_OBJECT_T##HAS_EMPTY_QUEUE_F hasEmptyQueueCb) { \
         bool isEmptyQueue = EMPTY_QUEUE == QUEUE_##EVENT_T##_GetSize(&self->queue); \
         if (isEmptyQueue) return hasEmptyQueueCb(self); \
         EVENT_T e = QUEUE_##EVENT_T##_Dequeue(&self->queue); \

src/fsm/fsm.h

@@ -52,8 +52,9 @@ typedef struct {                                                              \
 \
 STATE_T ACTIVE_OBJECT_T##_FSM_ProcessEventToNextState(\
         ACTIVE_OBJECT_T *const activeObject, \
-        EVENT_T event,                                                       \
-        EVENT_T##_HANDLE_F transitionTable[statesMax][eventsMax]             \
+        EVENT_T event,                                                          \
+        EVENT_T##_HANDLE_F transitionTable[statesMax][eventsMax],                \
+        STATE_T##_HANDLE_FUNCTIONS stateHandlersList[statesMax]                 \
     );
 
 /**

src/fsm/fsm_impl.h

@@ -8,15 +8,16 @@
 STATE_T ACTIVE_OBJECT_T##_FSM_ProcessEventToNextState(\
         ACTIVE_OBJECT_T *const activeObject, \
         EVENT_T event,                                                       \
-        EVENT_T##_HANDLE_F transitionTable[statesMax][eventsMax]             \
+        EVENT_T##_HANDLE_F transitionTable[statesMax][eventsMax],                    \
+        STATE_T##_HANDLE_FUNCTIONS stateHandlersList[statesMax]                 \
     ) {                                                                      \
         STATE_T currState = activeObject->state; \
         EVENT_T##_HANDLE_F stateHandler = transitionTable[currState][event.sig];     \
                                                                              \
         assert(NULL != stateHandler);                                        \
                                                                              \
-        STATE_T nextState = stateHandler(activeObject, event);               \
-                                                                             \
+        STATE_T nextState = stateHandler(activeObject, event);                      \
+                                                                                    \
         return nextState;                                                    \
     };
 

test/fsm/fsm.test.c

@@ -59,19 +59,19 @@ void test_fsm_process_event_to_next_state(void) {
     // Process MOCK_EVENT_A_SIG while in MOCK_STATE_IDLE -> should transition to MOCK_STATE_RUNNING
     ao.state = MOCK_STATE_IDLE;
     MockEvent e = { .sig = MOCK_EVENT_A_SIG };
-    MockState nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e, transitionTable);
+    MockState nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e, transitionTable, NULL);
     TEST_ASSERT_EQUAL(MOCK_STATE_RUNNING, nextState);
 
     // Process MOCK_EVENT_B_SIG while in MOCK_STATE_RUNNING -> should transition to MOCK_STATE_PAUSED
     ao.state = MOCK_STATE_RUNNING;
     e.sig = MOCK_EVENT_B_SIG;
-    nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e, transitionTable);
+    nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e, transitionTable, NULL);
     TEST_ASSERT_EQUAL(MOCK_STATE_PAUSED, nextState);
 
     // Process MOCK_EVENT_C_SIG while in MOCK_STATE_PAUSED -> should transition to MOCK_STATE_IDLE
     ao.state = MOCK_STATE_PAUSED;
     e.sig = MOCK_EVENT_C_SIG;
-    nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e, transitionTable);
+    nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e, transitionTable, NULL);
     TEST_ASSERT_EQUAL(MOCK_STATE_IDLE, nextState);
 }
 

test/integration/fsm_active_object.test.c

@@ -89,21 +89,21 @@ void integration_test_active_object_with_fsm_and_queue(void) {
     TEST_ASSERT_EQUAL(1, QUEUE_MockEvent_GetSize(&ao.queue));
 
     // Process Event with FSM
-    MockState nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e1, stateTransitionTable);
+    MockState nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e1, stateTransitionTable, NULL);
     TEST_ASSERT_EQUAL(MOCK_STATE_RUNNING, nextState);
     ao.state = nextState;  // Update the actual state of the active object
 
     // Dispatching and processing a second event
     MockEvent e2 = { .sig = MOCK_EVENT_B_SIG };
     MockActiveObject_Dispatch(&ao, e2);
-    nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e2, stateTransitionTable);
+    nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e2, stateTransitionTable, NULL);
     TEST_ASSERT_EQUAL(MOCK_STATE_PAUSED, nextState);
     ao.state = nextState;  // Update the actual state of the active object
 
     // Dispatching and processing a third event
     MockEvent e3 = { .sig = MOCK_EVENT_C_SIG };
     MockActiveObject_Dispatch(&ao, e3);
-    nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e3, stateTransitionTable);
+    nextState = MockActiveObject_FSM_ProcessEventToNextState(&ao, e3, stateTransitionTable, NULL);
     TEST_ASSERT_EQUAL(MOCK_STATE_IDLE, nextState);
     ao.state = nextState;  // Update the actual state of the active object
 }