Repeated Events and Mapping to States

[aedenj]

If I receive an event that serves as a heartbeat from some device, it would appear each of those events re-use the same state instance. My question is inline below.

class Started : Event
class Heartbeat : Event
class Finished: Event

class Start : DefaultState()
class Heartbeat : DefaultState()
class Finish : DefaultFinalState()

val machine = createStdLibStateMachine(..) {
    val start = Start()
    val hearbeat = Heartbeat()
    val finish = Finish()
    

    addInitialState(start) {
       transition<Heartbeat>(...) { targetState = heartbeat }
     }

     addState(heartbeat) {
       transition<Heartbeat>(...) { 
            // don't change the kind of states
            // QUESTION: It would appear the same instance is being used. I have metadata from the event that will be different for each
            //  heartbeat state, but i can't just do this targetState = Heartbeat() and modify that. What am I misunderstanding?
       }
     }
     addFinalState(finish)  
}

// My use case is to take measurements as a result of transitions and previous states.
machine.processEventBlocking(someEvent, sessionSummary) 

[nsk90]

Hi!
First of all
transition generic argument is Event, not State like in this sample code.

looks this should help:

class Heartbeat : DefaultState() {
   var currentHeartBeat: YourHeartbeatData // or List if you need full history.
}

[aedenj]

@nsk90 Thanks for the response. I'd like to revisit this post.

transition generic argument is Event, not State like in this sample code.

Absolutely, I created confusion here because the state and event have the same name.

Regarding your suggestion. The trouble I see with that is there can be other events that can happen in between for example,

heartbeat, paused, resumed, hearbeat, heartbeat. etc...

Ideally I can have the history of the states in order with any associated metadata.

[nsk90]

I am not sure if I understand the question correctly, but check this sample out, maybe it can help you)

            data class HeartbeatEvent(val value: Int) : Event

            class StartState : DefaultState()
            class HeartbeatState : DefaultState()
            class FinishState : DefaultFinalState()

            val machine = createStdLibStateMachine {
                val startState = StartState()
                val heartbeatState = HeartbeatState()
                addInitialState(startState) {
                    transition<HeartbeatEvent> { targetState = heartbeatState }
                }

                addState(heartbeatState) {
                    transition<HeartbeatEvent> { // target-less transition
                        onTriggered { transitionParams ->
                            println("store your metadata of target-less transition $transitionParams")
                        }
                    }
                }
                addFinalState(FinishState())

                onTransitionTriggered { transitionParams ->
                    println("store your metadata of any transition $transitionParams")
                }
            }

            machine.processEvent(HeartbeatEvent(1))
            machine.processEvent(HeartbeatEvent(2))
            machine.processEvent(HeartbeatEvent(3))

this will output:

stored your metadata of any transition TransitionParams(transition=DefaultTransition, direction=ru.nsk.kstatemachine.TargetState@2cf511c5, event=HeartbeatEvent(value=1), argument=null)
store your metadata of target-less transition TransitionParams(transition=DefaultTransition, direction=ru.nsk.kstatemachine.Stay@35176423, event=HeartbeatEvent(value=2), argument=null)
stored your metadata of any transition TransitionParams(transition=DefaultTransition, direction=ru.nsk.kstatemachine.Stay@35176423, event=HeartbeatEvent(value=2), argument=null)
store your metadata of target-less transition TransitionParams(transition=DefaultTransition, direction=ru.nsk.kstatemachine.Stay@35176423, event=HeartbeatEvent(value=3), argument=null)
stored your metadata of any transition TransitionParams(transition=DefaultTransition, direction=ru.nsk.kstatemachine.Stay@35176423, event=HeartbeatEvent(value=3), argument=null)

[aedenj]

The issue I'm experiencing is that in the onTriggered listener here

                addState(heartbeatState) {
                    transition<HeartbeatEvent> { // target-less transition
                        onTriggered { transitionParams ->
                            println("store your metadata of target-less transition $transitionParams")
                        }
                    }
                }

the heartbeatState is the same instance for each HeartbeatEvent and so I end up overwriting previous values from older events. I'm expecting there to be a unique HeartbeatState instance per successful transition so I don't end up overwriting metadata on the state and to preserve the whole state history in the order in which it occurs. Does that make sense?

[nsk90]

No, that is not possible. This library is a Final State Machine implementation. Final means that we know all possible states at machine start time. So new states cannot be produced and added during machine runtime (after start() called).

I don't see benefits of having separate state to store each heartbeat data.

As I posted before you can archive required behaviour with a mutable field in the Heartbeat state and fill it on transition triggering.

class Heartbeat : DefaultState() {
   private val heartBeats: MutableList<HeartbeatData>
}

You don't have to overwrite heartBeats field, just add your information into collection.