reactive/com.lightningkite.reactive.core

Package-level declarations

Types

BaseListenable

abstract class BaseListenable : Listenable

Base implementation of Listenable for managing listeners and activation lifecycle.

BaseReactive

abstract class BaseReactive<T>(start: ReactiveState<T> = ReactiveState.notReady) : BaseListenable, Reactive<T>

Base implementation of Reactive for managing reactive state and listener notification.

BaseReactiveValue

abstract class BaseReactiveValue<T>(start: T) : BaseListenable, ReactiveValue<T>

Base implementation of ReactiveValue for managing a mutable value and listener notification.

BasicListenable

class BasicListenable : BaseListenable

A basic implementation of a listenable object. Can invoke all listeners and provides a unique identifier for debugging.

Constant

class Constant<T>(val value: T) : ReactiveValue<T>

A reactive value that always holds a constant value and does not notify listeners.

Draft

class Draft<T> : ReactiveWithMutableValue<T>

A mutable reactive value that supports draft editing and publishing. Essentially, this provides an input buffer for a MutableReactive.

Emitter

interface Emitter<T> : CoroutineScope

InternalReactiveApi

@Target(allowedTargets = [AnnotationTarget.CLASS])

annotation class InternalReactiveApi

LateInitSignal

class LateInitSignal<T> : BaseReactive<T> , ReactiveWithMutableValue<T>

A reactive value that can be set after initialization and unset to a not-ready state. Useful for cases where the value is not available at construction time.

Listenable

interface Listenable : ResourceUse

Represents an object that can have listeners attached for change events.

Mutable

interface Mutable<T>

Represents a mutable value that can be set asynchronously.

MutableReactive

interface MutableReactive<T> : Reactive<T> , Mutable<T>

Represents a reactive value that can be modified and observed for changes.

MutableReactiveValue

interface MutableReactiveValue<T> : MutableValue<T> , ReactiveValue<T> , MutableReactive<T> , MutableWithReactiveValue<T> , ReactiveWithMutableValue<T> , ReadWriteProperty<Any?, T>

Represents a mutable reactive value that can be modified and observed for changes.

MutableRemember

class MutableRemember<T>(stopListeningWhenOverridden: Boolean = true, useLastWhileLoading: Boolean = false, coroutineContext: CoroutineContext = Dispatchers.Unconfined, initialValue: ReactiveContext.() -> T) : BaseReactive<T> , ReactiveWithMutableValue<T>

A mutable reactive value that can be set directly or calculated automatically from dependencies.

MutableRememberSuspending

class MutableRememberSuspending<T>(stopListeningWhenOverridden: Boolean = true, useLastWhileLoading: Boolean = false, coroutineContext: CoroutineContext = Dispatchers.Unconfined, initialValue: suspend CalculationContext.() -> T) : BaseReactive<T> , ReactiveWithMutableValue<T>

This is a suspending version of MutableRemember. A mutable reactive value that can be set directly or calculated automatically from dependencies using a suspending block.

MutableValue

interface MutableValue<T> : Mutable<T>

Represents a mutable value that can be set synchronously and/or asynchronously.

MutableWithReactiveValue

interface MutableWithReactiveValue<T> : MutableReactive<T> , ReactiveValue<T>

A ReactiveValue that can be asynchronously modified.

NotReadyException

class NotReadyException(message: String? = null) : IllegalStateException

RawReactive

class RawReactive<T>(start: ReactiveState<T> = ReactiveState.notReady) : BaseReactive<T>

A reactive value that exposes its state and allows direct mutation. Used for low-level reactive state management.

Reactive

interface Reactive<out T> : Listenable

Represents a reactive value that can be observed for changes.

ReactiveMutableList

class ReactiveMutableList<T>(list: ArrayList<T>) : BaseListenable, MutableList<T> , MutableReactiveValue<List<T>>

A wrapper around ArrayList that signals its listeners whenever it is mutated

ReactiveMutableMap

class ReactiveMutableMap<K, V>(map: HashMap<K, V>) : BaseListenable, MutableMap<K, V> , MutableReactiveValue<Map<K, V>>

A wrapper around HashMap that signals its listeners whenever it is mutated

ReactiveMutableSet

class ReactiveMutableSet<T>(hashSet: LinkedHashSet<T>) : BaseListenable, MutableSet<T> , MutableReactiveValue<Set<T>>

A wrapper around LinkedHashSet that signals its listeners whenever it is mutated

ReactiveState

@JvmInline

value class ReactiveState<out T>(val raw: T)

Represents the state of a reactive value, including loading, success, and error conditions.

ReactiveValue

interface ReactiveValue<out T> : Reactive<T> , ReadOnlyProperty<Any?, T>

Represents an infallible reactive value.

ReactiveWithMutableValue

interface ReactiveWithMutableValue<T> : MutableReactive<T> , MutableValue<T>

A Reactive that can be synchronously modified.

Remember

class Remember<T>(coroutineContext: CoroutineContext = Dispatchers.Unconfined, useLastWhileLoading: Boolean = false, action: ReactiveContext.() -> T) : BaseListenable, Reactive<T> , CoroutineScope

A reactive value that remembers the result of a calculation and shares the result among its listeners.

RememberSuspending

class RememberSuspending<T>(coroutineContext: CoroutineContext = Dispatchers.Unconfined, useLastWhileLoading: Boolean = false, action: suspend CalculationContext.() -> T) : BaseListenable, Reactive<T> , CoroutineScope

A reactive value that remembers the result of a calculation and shares the result among its listeners.

ResourceUse

interface ResourceUse

Represents a resource that can be used and released. Implementations should provide logic for starting and stopping resource usage.

Signal

class Signal<T>(startValue: T) : BaseReactiveValue<T> , MutableReactiveValue<T>

A mutable reactive value that can be updated and observed.

Properties

AppJob

val AppJob: CompletableJob

AppScope

val AppScope: CoroutineScope

Functions

addAndRunListener

fun Listenable.addAndRunListener(listener: () -> Unit): () -> Unit

Adds a listener and immediately runs it once.

mutableRemember

fun <T> mutableRemember(useLastWhileLoading: Boolean = false, coroutineContext: CoroutineContext = Dispatchers.Unconfined, initialValue: ReactiveContext.() -> T): ReactiveWithMutableValue<T>

Creates a mutable reactive value that can be set directly or calculated automatically.

mutableRememberSuspending

fun <T> mutableRememberSuspending(useLastWhileLoading: Boolean = false, coroutineContext: CoroutineContext = Dispatchers.Unconfined, initialValue: suspend CalculationContext.() -> T): ReactiveWithMutableValue<T>

This is a suspending version of mutableRemember. Creates a mutable reactive value that can be set directly or calculated automatically using a suspending block.

rawReactiveProcess

fun <T> rawReactiveProcess(scope: CoroutineScope = AppScope, emitter: suspend Emitter<ReactiveState<T>>.() -> Unit): Reactive<T>

reactiveProcess

fun <T> reactiveProcess(scope: CoroutineScope = AppScope, emitter: suspend Emitter<T>.() -> Unit): Reactive<T>

reactiveProcess

@JvmName(name = "reactiveProcessImplicit")

fun <T> CoroutineScope.reactiveProcess(emitter: suspend Emitter<T>.() -> Unit): Reactive<T>

reactiveState

inline fun <T> reactiveState(action: () -> T): ReactiveState<T>

remember

fun <T> remember(coroutineContext: CoroutineContext = Dispatchers.Unconfined, useLastWhileLoading: Boolean = false, action: ReactiveContext.() -> T): Reactive<T>

Creates a reactive value that automatically updates when its dependencies change.

rememberSuspending

fun <T> rememberSuspending(coroutineContext: CoroutineContext = Dispatchers.Unconfined, useLastWhileLoading: Boolean = false, action: suspend CalculationContext.() -> T): Reactive<T>

This is a suspending version of remember. Creates a reactive value that automatically updates when its dependencies change.

toReactiveState

inline fun <T> Result<T>.toReactiveState(): ReactiveState<T>