kfsm/io.jumpco.open.kfsm.async

Package-level declarations

Types

AsyncAnyStateMachineBuilder

typealias AsyncAnyStateMachineBuilder<S, E, C> = AsyncStateMachineBuilder<S, E, C, Any, Any>

AsyncAnyStateMachineInstance

typealias AsyncAnyStateMachineInstance<S, E, C> = AsyncStateMachineInstance<S, E, C, Any, Any>

AsyncDslStateMachineHandler

class AsyncDslStateMachineHandler<S, E, C, A, R>(fsm: AsyncStateMachineBuilder<S, E, C, A, R>)

AsyncDslStateMapDefaultEventHandler

class AsyncDslStateMapDefaultEventHandler<S, E, C, A, R>(fsm: AsyncStateMapBuilder<S, E, C, A, R>)

AsyncDslStateMapEventHandler

class AsyncDslStateMapEventHandler<S, E, C, A, R>(currentState: S, fsm: AsyncStateMapBuilder<S, E, C, A, R>)

AsyncDslStateMapHandler

class AsyncDslStateMapHandler<S, E, C, A, R>(fsm: AsyncStateMapBuilder<S, E, C, A, R>)

This handler will be active inside the top level of the stateMachine definition.

AsyncGuardedTransition

open class AsyncGuardedTransition<S, E, C, A, R>(startState: S, event: E?, targetState: S?, targetMap: String?, automatic: Boolean, type: TransitionType, val guard: StateGuard<C, A>, action: AsyncStateAction<C, A, R>?) : SimpleAsyncTransition<S, E, C, A, R>

AsyncStateMachineBuilder

class AsyncStateMachineBuilder<S, E, C, A, R>(validMapStates: Set<S>, validEvents: Set<E>)

AsyncStateMachineDefinition

class AsyncStateMachineDefinition<S, E, C, A, R>(val defaultInitialState: S?, deriveInitialState: StateQuery<C, S>?, deriveInitialMap: StateMapQuery<C, S>?, val defaultStateMap: AsyncStateMapDefinition<S, E, C, A, R>, val namedStateMaps: Map<String, AsyncStateMapDefinition<S, E, C, A, R>>)

AsyncStateMachineInstance

class AsyncStateMachineInstance<S, E, C, A, R>(context: C, val definition: AsyncStateMachineDefinition<S, E, C, A, R>, val coroutineScope: CoroutineScope, initialState: S? = null, initialExternalState: ExternalState<S>? = null)

AsyncStateMapBuilder

class AsyncStateMapBuilder<S, E, C, A, R>(val validStates: Set<S>, val name: String? = null, val parentBuilder: AsyncStateMachineBuilder<S, E, C, A, R>)

AsyncStateMapDefinition

class AsyncStateMapDefinition<S, E, C, A, R>(val name: String?, val validStates: Set<S>, val invariants: Set<Pair<String, Condition<C>>>, val transitionRules: Map<Pair<S, E>, AsyncTransitionRules<S, E, C, A, R>>, val defaultTransitions: Map<E, DefaultAsyncTransition<S, E, C, A, R>>, val entryActions: Map<S, DefaultEntryExitAction<C, S, A>>, val exitActions: Map<S, DefaultEntryExitAction<C, S, A>>, val defaultActions: Map<S, DefaultAsyncStateAction<C, S, E, A, R>>, val automaticTransitions: Map<S, AsyncTransitionRules<S, E, C, A, R>>, val timerDefinitions: Map<S, AsyncTimerDefinition<S, E, C, A, R>>, val globalDefault: DefaultAsyncStateAction<C, S, E, A, R>?, val defaultEntryAction: DefaultEntryExitAction<C, S, A>?, val defaultExitAction: DefaultEntryExitAction<C, S, A>?, val afterStateChangeAction: AsyncStateChangeAction<C, S>?)

AsyncStateMapInstance

class AsyncStateMapInstance<S, E, C, A, R>(val context: C, val newState: S, val name: String?, val parentFsm: AsyncStateMachineInstance<S, E, C, A, R>, val definition: AsyncStateMapDefinition<S, E, C, A, R>, val coroutineScope: CoroutineScope)

AsyncTimer

expect class AsyncTimer<S, E, C, A, R>(parentFsm: AsyncStateMapInstance<S, E, C, A, R>, context: C, arg: A?, definition: AsyncTimerDefinition<S, E, C, A, R>, coroutineScope: CoroutineScope)

actual class AsyncTimer<S, E, C, A, R>(val parentFsm: AsyncStateMapInstance<S, E, C, A, R>, val context: C, val arg: A?, val definition: AsyncTimerDefinition<S, E, C, A, R>, coroutineScope: CoroutineScope)

AsyncTimerDefinition

class AsyncTimerDefinition<S, E, C, A, R>(val timeout: C.() -> Long, val rule: AsyncTransitionRules<S, E, C, A, R>)

AsyncTransition

open class AsyncTransition<S, E, C, A, R>(val targetState: S? = null, val targetMap: String? = null, val automatic: Boolean = false, val type: TransitionType = TransitionType.NORMAL, val action: AsyncStateAction<C, A, R>? = null)

AsyncTransitionRules

class AsyncTransitionRules<S, E, C, A, R>(val guardedTransitions: MutableList<AsyncGuardedTransition<S, E, C, A, R>> = mutableListOf(), transition: SimpleAsyncTransition<S, E, C, A, R>? = null)

DefaultAsyncTransition

class DefaultAsyncTransition<S, E, C, A, R>(event: E, targetState: S?, targetMap: String?, automatic: Boolean, type: TransitionType, action: AsyncStateAction<C, A, R>?) : AsyncTransition<S, E, C, A, R>

SimpleAsyncTransition

open class SimpleAsyncTransition<S, E, C, A, R>(startState: S, event: E?, targetState: S?, targetMap: String?, automatic: Boolean, type: TransitionType, action: AsyncStateAction<C, A, R>?) : AsyncTransition<S, E, C, A, R>

Functions

asyncFunctionalStateMachine

inline fun <S, E, C : Any> asyncFunctionalStateMachine(validStates: Set<S>, validEvents: Set<E>, contextClass: KClass<out C>, handler: AsyncDslStateMachineHandler<S, E, C, C, C>.() -> Unit): AsyncDslStateMachineHandler<S, E, C, C, C>

asyncStateMachine

inline fun <S, E, C : Any> asyncStateMachine(validStates: Set<S>, validEvents: Set<E>, contextClass: KClass<out C>, handler: AsyncDslStateMachineHandler<S, E, C, Any, Any>.() -> Unit): AsyncDslStateMachineHandler<S, E, C, Any, Any>

Defines the start of a state machine DSL declaration with Any as the type of arguments and returns types for events/actions

inline fun <S, E, C : Any, A : Any> asyncStateMachine(validStates: Set<S>, validEvents: Set<E>, contextClass: KClass<out C>, argumentClass: KClass<out A>, handler: AsyncDslStateMachineHandler<S, E, C, A, Any>.() -> Unit): AsyncDslStateMachineHandler<S, E, C, A, Any>

Defines the start of a state machine DSL declaration with Any as the return type

inline fun <S, E, C : Any, A : Any, R : Any> asyncStateMachine(validStates: Set<S>, validEvents: Set<E>, contextClass: KClass<out C>, argumentClass: KClass<out A>, returnClass: KClass<out R>, handler: AsyncDslStateMachineHandler<S, E, C, A, R>.() -> Unit): AsyncDslStateMachineHandler<S, E, C, A, R>

These function are used to create statemachines where the actions are suspend functions.

ifApply

inline fun <T> T.ifApply(expression: Boolean, block: T.() -> Unit, otherwise: T.() -> Unit): T

An extension function that evaluates the expression and invokes the provided block if true or the otherwise block is false.