Add FinishedDataEvent which is generated on final data state entry

Author: nsk90

kstatemachine/src/main/kotlin/ru/nsk/kstatemachine/BaseStateImpl.kt

@@ -69,7 +69,7 @@ open class BaseStateImpl(override val name: String?, override val childMode: Chi
     override fun <S : IState> addState(state: S, init: StateBlock<S>?): S {
         check(!machine.isRunning) { "Can not add state after state machine started" }
         if (childMode == ChildMode.PARALLEL) {
-            require(state !is FinalState) { "Can not add FinalState in parallel child mode" }
+            require(state !is IFinalState) { "Can not add IFinalState in parallel child mode" }
             require(state !is PseudoState) { "Can not add PseudoState in parallel child mode" }
         }
 
@@ -114,10 +114,12 @@ open class BaseStateImpl(override val name: String?, override val childMode: Chi
 
     override fun doEnter(transitionParams: TransitionParams<*>) {
         if (!isActive) {
+            val machine = machine as InternalStateMachine
             if (parent != null) machine.log { "Parent $parent entering child $this" }
             data.isActive = true
             onDoEnter(transitionParams)
             stateNotify { onEntry(transitionParams) }
+            machine.machineNotify { onStateEntry(this@BaseStateImpl) }
         }
     }
 
@@ -135,7 +137,7 @@ open class BaseStateImpl(override val name: String?, override val childMode: Chi
     override fun afterChildFinished(finishedChild: InternalState, transitionParams: TransitionParams<*>) {
         if (childMode == ChildMode.PARALLEL && states.all { it.isFinished }) {
             data.isFinished = true
-            notifyStateFinish(transitionParams)
+            notifyStateFinish(finishedChild, transitionParams)
         }
     }
 
@@ -239,21 +241,26 @@ open class BaseStateImpl(override val name: String?, override val childMode: Chi
 
         state.doEnter(transitionParams)
 
-        val machine = machine as InternalStateMachine
-        machine.machineNotify { onStateEntry(state) }
-
         if (finished) {
-            notifyStateFinish(transitionParams)
+            notifyStateFinish(state, transitionParams)
             internalParent?.afterChildFinished(this, transitionParams)
         }
     }
 
-    private fun notifyStateFinish(transitionParams: TransitionParams<*>) {
+    private fun notifyStateFinish(state: InternalState, transitionParams: TransitionParams<*>) {
         machine.log { "$this finished" }
         stateNotify { onFinished(transitionParams) }
         // there is no sense to send event on state machine finish as it stops processing events in this case
         if (this !is StateMachine)
-            machine.processEvent(FinishedEvent(this))
+            machine.processEvent(makeFinishedEvent(state))
+    }
+
+    private fun makeFinishedEvent(state: InternalState): FinishedEvent {
+        // check for both interfaces as client is not forced to use FinalDataState
+        return if (state is DataState<*> && state is IFinalState) // possible in exclusive child mode only
+            FinishedDataEventImpl(this, state.data)
+        else
+            FinishedEventImpl(this)
     }
 
     internal fun switchToTargetState(

kstatemachine/src/main/kotlin/ru/nsk/kstatemachine/TransitionParams.kt

@@ -26,7 +26,14 @@ interface GeneratedEvent : Event
  * Special event generated by the library when a state is finished.
  * Transitions use special event matcher by default to match only related events.
  */
-class FinishedEvent internal constructor(val state: IState) : GeneratedEvent
+interface FinishedEvent : GeneratedEvent {
+    val state: IState
+}
+
+interface FinishedDataEvent<D : Any> : FinishedEvent, DataEvent<D>
+
+internal class FinishedEventImpl(override val state: IState) : FinishedEvent
+internal class FinishedDataEventImpl<D : Any>(override val state: IState, override val data: D) : FinishedDataEvent<D>
 
 /**
  * Initial event which is processed on state machine start

kstatemachine/src/test/kotlin/ru/nsk/kstatemachine/FinishedEventTest.kt

@@ -5,7 +5,7 @@ import io.kotest.matchers.shouldBe
 import io.mockk.verifySequence
 
 class FinishedEventTest : StringSpec({
-    "finished event in machine is not working as machine ignores events" {
+    "FinishedEvent in machine is not working as machine ignores events" {
         val callbacks = mockkCallbacks()
         lateinit var state2: State
         val machine = createStateMachine {
@@ -28,7 +28,7 @@ class FinishedEventTest : StringSpec({
         machine.isFinished shouldBe true
     }
 
-    "finished event in composite state" {
+    "FinishedEvent in composite state" {
         val callbacks = mockkCallbacks()
         lateinit var state1: State
         lateinit var state2: State
@@ -56,4 +56,36 @@ class FinishedEventTest : StringSpec({
         state1.isFinished shouldBe false
         machine.isFinished shouldBe false
     }
+
+    "FinishedDataEvent" {
+        val callbacks = mockkCallbacks()
+        data class IntEvent(override val data: Int) : DataEvent<Int>
+        val intData = 42
+
+        val machine = createStateMachine {
+            val state2 = state("state2")
+
+            initialState("state1") {
+                val childFinal = finalDataState<Int>("state11")
+
+                initialState("state12") {
+                    dataTransition<IntEvent, Int> {
+                        targetState = childFinal
+                    }
+                }
+
+                transitionOn<FinishedDataEvent<Int>> {
+                    targetState = {
+                        event.data shouldBe intData
+                        state2
+                    }
+                    callbacks.listen(this)
+                }
+            }
+        }
+        machine.processEvent(IntEvent(intData))
+        verifySequence {
+            callbacks.onTriggeredTransition(ofType<FinishedDataEvent<Int>>())
+        }
+    }
 })

kstatemachine/src/test/kotlin/ru/nsk/kstatemachine/StateMachineTest.kt

@@ -130,16 +130,19 @@ class StateMachineTest : StringSpec({
     }
 
 
-    "onStateChanged() notification" {
+    "onEntryState() notification" {
         val callbacks = mockkCallbacks()
         lateinit var first: State
 
-        createStateMachine {
+        val machine = createStateMachine {
             first = initialState("first")
             onStateEntry { callbacks.onEntryState(it) }
         }
 
-        verifySequence { callbacks.onEntryState(first) }
+        verifySequence {
+            callbacks.onEntryState(machine)
+            callbacks.onEntryState(first)
+        }
     }
 
     "add same state listener" {
@@ -295,6 +298,7 @@ class StateMachineTest : StringSpec({
 
         verifySequence {
             callbacks.onStarted(machine)
+            callbacks.onEntryState(machine)
             callbacks.onEntryState(state1)
             callbacks.onEntryState(state2)
             callbacks.onFinished(machine)