kstatemachine/ru.nsk.kstatemachine.transition

Package-level declarations

Types

abstract class BaseGuardedTransitionBuilder<E : Event>(name: String?, sourceState: IState) : TransitionBuilder<E>

class ConditionalTransitionBuilder<E : Event>(name: String?, sourceState: IState) : TransitionBuilder<E>

class DataGuardedTransitionBuilder<E : DataEvent<D>, D : Any>(name: String?, sourceState: IState) : BaseGuardedTransitionBuilder<E>

Type safe argument transition builder

DataGuardedTransitionOnBuilder

class DataGuardedTransitionOnBuilder<E : DataEvent<D>, D : Any>(name: String?, sourceState: IState) : GuardedTransitionOnBuilder<E, DataState<D>>

Type safe argument transitionOn builder

DefaultTransition

open class DefaultTransition<E : Event>(val name: String?, val eventMatcher: EventMatcher<E>, val type: TransitionType, sourceState: IState, val metaInfo: MetaInfo?) : InternalTransition<E>

EventAndArgument

data class EventAndArgument<E : Event>(val event: E, val argument: Any?)

Pair of event and argument coming from processEvent() method. Used as single argument in all guard and conditional callbacks same as TransitionParams for transitions

GuardedTransitionBuilder

abstract class GuardedTransitionBuilder<E : Event, S : IState>(name: String?, sourceState: IState) : BaseGuardedTransitionBuilder<E>

GuardedTransitionOnBuilder

abstract class GuardedTransitionOnBuilder<E : Event, S : IState>(name: String?, sourceState: IState) : BaseGuardedTransitionBuilder<E>

InternalTransition

interface InternalTransition<E : Event> : Transition<E>

Defines transition API for internal library usage. All transitions must implement this interface. This is safe to cast any Transition to InternalTransition by design.

ResolvedTransition

typealias ResolvedTransition<E> = Pair<InternalTransition<E>, TransitionDirection>

Transition that matches event and has a meaningful direction (except NoTransition)

Transition

interface Transition<E : Event> : VisitorAcceptor

Represent a transition between states, which gets triggered when specified Event is posted to StateMachine

TransitionBuilder

abstract class TransitionBuilder<E : Event>(name: String?, sourceState: IState)

TransitionDirection

sealed interface TransitionDirection

Caller should check subclass to recognise/distinguish NoTransition and Stay cases.

TransitionDirectionProducerPolicy

sealed class TransitionDirectionProducerPolicy<E : Event>

TransitionParams

data class TransitionParams<E : Event>

TransitionType

enum TransitionType : Enum<TransitionType>

Most of the cases EXTERNAL and LOCAL transition are functionally equivalent except in cases where transition is happening between super and sub-states. Local transition doesn't cause exit and entry to source state if target state is a sub-state of a source state. Other way around, local transition doesn't cause exit and entry to target state if target is a superstate of a source state.

UnitGuardedTransitionBuilder

class UnitGuardedTransitionBuilder<E : Event>(name: String?, sourceState: IState) : GuardedTransitionBuilder<E, State>

Any Event (with any data) can lead to State

UnitGuardedTransitionOnBuilder

class UnitGuardedTransitionOnBuilder<E : Event>(name: String?, sourceState: IState) : GuardedTransitionOnBuilder<E, State>

Properties

unwrappedArgument

val TransitionParams<*>.unwrappedArgument: Any?

Convenience property for unwrapping original argument. If the event is not WrappedEvent this is same as TransitionParams.argument property

unwrappedEvent

val TransitionParams<*>.unwrappedEvent: Event

Convenience property for unwrapping original event. If the event is not WrappedEvent this is same as TransitionParams.event property

Functions

noTransition

fun noTransition(): TransitionDirection

onComplete

inline fun <E : Event> TransitionBuilder<E>.onComplete(crossinline block: suspend (activeStates: Set<IState>, transitionParams: TransitionParams<E>) -> Unit): Transition.Listener

inline fun <E : Event> Transition<E>.onComplete(crossinline block: suspend (activeStates: Set<IState>, TransitionParams<E>) -> Unit): Transition.Listener

onTriggered

inline fun <E : Event> TransitionBuilder<E>.onTriggered(crossinline block: suspend (TransitionParams<E>) -> Unit): Transition.Listener

inline fun <E : Event> Transition<E>.onTriggered(crossinline block: suspend (TransitionParams<E>) -> Unit): Transition.Listener

stay

fun stay(): TransitionDirection

targetParallelStates

suspend fun EventAndArgument<*>.targetParallelStates(targetStates: Set<IState>): TransitionDirection

suspend fun EventAndArgument<*>.targetParallelStates(targetState1: IState, targetState2: IState, vararg targetStates: IState): TransitionDirection

targetState

suspend fun EventAndArgument<*>.targetState(targetState: IState): TransitionDirection

Transition is triggered with a targetState, resolving it in place if it is a PseudoState