reactive/com.lightningkite.reactive.core/ReactiveMutableSet

ReactiveMutableSet

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

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

Constructors

ReactiveMutableSet

constructor()

constructor(items: Set<T>)

constructor(vararg startingItems: T)

constructor(hashSet: LinkedHashSet<T>)

Properties

size

open override val size: Int

state

open override val state: ReactiveState<Set<T>>

value

open override var value: Set<T>

value

@set:JvmName(name = "setValue2")

var <T> MutableValue<T>.value: T

waitForNotNull

val <T : Any> MutableReactive<T?>.waitForNotNull: MutableReactive<T>

val <T : Any> Reactive<T?>.waitForNotNull: Reactive<T>

Functions

add

open override fun add(element: T): Boolean

addAll

open override fun addAll(elements: Collection<T>): Boolean

addAndRunListener

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

Adds a listener and immediately runs it once.

addListener

abstract fun addListener(listener: () -> Unit): () -> Unit

Adds the listener to be called every time this event fires.

asByte

@JvmName(name = "writableStringAsByte")

fun MutableReactiveValue<String>.asByte(): MutableReactiveValue<Byte?>

@JvmName(name = "writableStringAsByte")

fun MutableReactive<String>.asByte(): MutableReactive<Byte?>

asByteHex

@JvmName(name = "writableStringAsByteHex")

fun MutableReactiveValue<String>.asByteHex(): MutableReactiveValue<Byte?>

@JvmName(name = "writableStringAsByteHex")

fun MutableReactive<String>.asByteHex(): MutableReactive<Byte?>

asDouble

@JvmName(name = "writableIntAsDoubleNullable")

fun MutableReactiveValue<Int?>.asDouble(): MutableReactiveValue<Double?>

@JvmName(name = "writableStringAsDouble")

fun MutableReactiveValue<String>.asDouble(): MutableReactiveValue<Double?>

@JvmName(name = "writableIntAsDoubleNullable")

fun MutableReactive<Int?>.asDouble(): MutableReactive<Double?>

@JvmName(name = "writableStringAsDouble")

fun MutableReactive<String>.asDouble(): MutableReactive<Double?>

asFloat

@JvmName(name = "writableStringAsFloat")

fun MutableReactiveValue<String>.asFloat(): MutableReactiveValue<Float?>

@JvmName(name = "writableStringAsFloat")

fun MutableReactive<String>.asFloat(): MutableReactive<Float?>

asInt

@JvmName(name = "writableStringAsInt")

fun MutableReactiveValue<String>.asInt(): MutableReactiveValue<Int?>

@JvmName(name = "writableStringAsInt")

fun MutableReactive<String>.asInt(): MutableReactive<Int?>

asIntHex

@JvmName(name = "writableStringAsIntHex")

fun MutableReactiveValue<String>.asIntHex(): MutableReactiveValue<Int?>

@JvmName(name = "writableStringAsIntHex")

fun MutableReactive<String>.asIntHex(): MutableReactive<Int?>

asLong

@JvmName(name = "writableStringAsLong")

fun MutableReactiveValue<String>.asLong(): MutableReactiveValue<Long?>

@JvmName(name = "writableStringAsLong")

fun MutableReactive<String>.asLong(): MutableReactive<Long?>

asLongHex

@JvmName(name = "writableStringAsLongHex")

fun MutableReactiveValue<String>.asLongHex(): MutableReactiveValue<Long?>

@JvmName(name = "writableStringAsLongHex")

fun MutableReactive<String>.asLongHex(): MutableReactive<Long?>

assert

fun <T> MutableReactiveValue<T>.assert(summary: String, description: String = summary, setOnIssue: Boolean = true, condition: (T) -> Boolean): MutableValidatedValue<T>

Asserts a condition on this MutableReactiveValue instance and reports an issue if the condition fails.

fun <T> MutableReactive<T>.assert(summary: String, description: String = summary, setOnIssue: Boolean = true, condition: (T) -> Boolean): MutableValidated<T>

Asserts a condition on this MutableReactive instance and reports an issue if the condition fails.

asShort

@JvmName(name = "writableStringAsShort")

fun MutableReactiveValue<String>.asShort(): MutableReactiveValue<Short?>

@JvmName(name = "writableStringAsShort")

fun MutableReactive<String>.asShort(): MutableReactive<Short?>

asShortHex

@JvmName(name = "writableStringAsShortHex")

fun MutableReactiveValue<String>.asShortHex(): MutableReactiveValue<Short?>

@JvmName(name = "writableStringAsShortHex")

fun MutableReactive<String>.asShortHex(): MutableReactive<Short?>

asUByteHex

@JvmName(name = "writableStringAsUByteHex")

fun MutableReactiveValue<String>.asUByteHex(): MutableReactiveValue<UByte?>

@JvmName(name = "writableStringAsUByteHex")

fun MutableReactive<String>.asUByteHex(): MutableReactive<UByte?>

asUIntHex

@JvmName(name = "writableStringAsUIntHex")

fun MutableReactiveValue<String>.asUIntHex(): MutableReactiveValue<UInt?>

@JvmName(name = "writableStringAsUIntHex")

fun MutableReactive<String>.asUIntHex(): MutableReactive<UInt?>

asULongHex

@JvmName(name = "writableStringAsULongHex")

fun MutableReactiveValue<String>.asULongHex(): MutableReactiveValue<ULong?>

@JvmName(name = "writableStringAsULongHex")

fun MutableReactive<String>.asULongHex(): MutableReactive<ULong?>

asUShortHex

@JvmName(name = "writableStringAsUShortHex")

fun MutableReactiveValue<String>.asUShortHex(): MutableReactiveValue<UShort?>

@JvmName(name = "writableStringAsUShortHex")

fun MutableReactive<String>.asUShortHex(): MutableReactive<UShort?>

await

suspend fun <T> ReactiveValue<T>.await(): T

suspend fun <T> Reactive<T>.await(): T

awaitNotNull

suspend fun <T : Any> Reactive<T?>.awaitNotNull(): T

awaitOnce

suspend fun <T> Reactive<T>.awaitOnce(): T

beginUse

open override fun beginUse(): () -> Unit

Begins using the resource. Returns a function to stop using the resource.

checkForIssue

fun <T> MutableReactiveValue<T>.checkForIssue(validate: (T) -> Issue?): MutableValidatedValue<T>

Adds a validation check to a MutableReactiveValue instance, returning a MutableValidatedValue that tracks issues.

fun <T> MutableReactive<T>.checkForIssue(validate: (T) -> Issue?): MutableValidated<T>

Adds a validation check to a MutableReactive instance, returning a MutableValidated that tracks issues.

clear

open override fun clear()

contains

open operator override fun contains(element: T): Boolean

contains

@JvmName(name = "containsList")

infix fun <T> MutableReactive<List<T>>.contains(value: T): MutableReactive<Boolean>

infix fun <T> MutableReactive<Set<T>>.contains(value: T): MutableReactive<Boolean>

containsAll

open override fun containsAll(elements: Collection<T>): Boolean

debounce

fun Listenable.debounce(timeMs: Long): Listenable

fun Listenable.debounce(duration: Duration): Listenable

fun <T> Reactive<T>.debounce(timeMs: Long): Reactive<T>

fun <T> Reactive<T>.debounce(duration: Duration): Reactive<T>

debounceWrite

fun <T> MutableReactive<T>.debounceWrite(duration: Duration): MutableReactive<T>

equalTo

infix fun <T> MutableReactive<T>.equalTo(value: T): MutableReactive<Boolean>

exception

inline suspend fun <T> Reactive<T>.exception(): Exception?

flatten

fun <T> Reactive<MutableReactive<T>>.flatten(): MutableReactive<T>

fun <T> Reactive<Reactive<T>>.flatten(): Reactive<T>

getValue

open operator override fun getValue(thisRef: Any?, property: KProperty<*>): Set<T>

invoke

inline suspend operator fun <T> ReactiveValue<T>.invoke(): T

inline suspend operator fun <T> Reactive<T>.invoke(): T

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): MutableIterator<T>

lens

open override fun <L> lens(get: (Set<T>) -> L, set: (L) -> Set<T>): MutableReactiveValue<L>

'Lenses' a new type from this MutableReactive. This is useful when translating one type to another for user input, or safe type coercion.

open override fun <L> lens(get: (Set<T>) -> L, modify: (Set<T>, L) -> Set<T>): MutableReactiveValue<L>

'Lenses' a subtype from this MutableReactive. This is useful for extracting properties from a data class or modifying a single item in a collection.

lens

fun <T, L> ReactiveValue<T>.lens(get: (T) -> L): ReactiveValue<L>

fun <T, L> Reactive<T>.lens(get: (T) -> L): Reactive<L>

lensByElement

fun <E, ID> MutableReactive<List<E>>.~~lensByElement~~(identity: (E) -> ID): LensByElement<E, ID, LensByElement.Element<E, ID, *>>

@JvmName(name = "setLensByElement")

fun <E, ID> MutableReactive<Set<E>>.~~lensByElement~~(identity: (E) -> ID): LensByElement<E, ID, LensByElement.Element<E, ID, *>>

fun <E, ID, W> MutableReactive<List<E>>.~~lensByElement~~(identity: (E) -> ID, map: CalculationContext.(MutableWithReactiveValue<E>) -> W): LensByElement<E, ID, W>

@JvmName(name = "setLensByElement")

fun <E, ID, W> MutableReactive<Set<E>>.~~lensByElement~~(identity: (E) -> ID, map: CalculationContext.(MutableWithReactiveValue<E>) -> W): LensByElement<E, ID, W>

lensByElementAssumingSetNeverManipulates

fun <E> MutableReactive<List<E>>.lensByElementAssumingSetNeverManipulates(): Reactive<List<MutableReactiveElement<E>>>

fun <E, W> MutableReactive<List<E>>.lensByElementAssumingSetNeverManipulates(map: CalculationContext.(MutableReactiveElement<E>) -> W): Reactive<List<W>>

THIS ONLY WORKS IF THE set on the receiver never manipulates the input before notifying.

lensByElementWithIdentity

fun <E, ID> MutableReactive<List<E>>.lensByElementWithIdentity(identity: (E) -> ID): LensByElement<E, ID, LensByElement.Element<E, ID, *>>

@JvmName(name = "setLensByElementWithIdentity")

fun <E, ID> MutableReactive<Set<E>>.lensByElementWithIdentity(identity: (E) -> ID): LensByElement<E, ID, LensByElement.Element<E, ID, *>>

fun <E, ID, W> MutableReactive<List<E>>.lensByElementWithIdentity(identity: (E) -> ID, map: CalculationContext.(MutableWithReactiveValue<E>) -> W): LensByElement<E, ID, W>

@JvmName(name = "setLensByElementWithIdentity")

fun <E, ID, W> MutableReactive<Set<E>>.lensByElementWithIdentity(identity: (E) -> ID, map: CalculationContext.(MutableWithReactiveValue<E>) -> W): LensByElement<E, ID, W>

lensListenable

fun <T> Listenable.lensListenable(get: () -> T): Reactive<T>

modify

infix suspend fun <T> MutableReactiveValue<T>.modify(action: suspend (T) -> T)

infix suspend fun <T> MutableReactive<T>.modify(action: suspend (T) -> T)

notNull

fun <T : Any> MutableReactive<T?>.notNull(default: T): MutableReactive<T>

nullable

fun <T : Any> MutableReactive<T>.nullable(): MutableReactive<T?>

nullToBlank

fun MutableReactive<String?>.nullToBlank(): MutableReactive<String>

nullToZero

fun MutableReactive<Double>.nullToZero(): MutableReactive<Double?>

onNextSuccess

fun <T> Reactive<T>.onNextSuccess(action: (T) -> Unit): () -> Unit

plus

operator fun Listenable.plus(other: Listenable): Listenable

reactiveContains

fun reactiveContains(element: T): MutableReactiveValue<Boolean>

remove

open override fun remove(element: T): Boolean

removeAll

open override fun removeAll(elements: Collection<T>): Boolean

retainAll

open override fun retainAll(elements: Collection<T>): Boolean

set

open infix suspend override fun set(value: Set<T>)

setValue

open operator override fun setValue(thisRef: Any?, property: KProperty<*>, value: Set<T>)

state

suspend fun <T> Reactive<T>.state(): ReactiveState<T>

suspend fun <T, V> Reactive<T>.state(get: (ReactiveState<T>) -> V): V

toggle

fun MutableReactiveValue<Boolean>.toggle()

suspend fun MutableReactive<Boolean>.toggle()

validate

fun <T> MutableReactiveValue<T>.validate(setOnIssue: Boolean = true, validate: (T) -> String?): MutableValidatedValue<T>

Adds a validation check to this MutableReactiveValue instance.

fun <T> MutableReactive<T>.validate(setOnIssue: Boolean = true, validate: (T) -> String?): MutableValidated<T>

Adds a validation check to this MutableReactive instance.

validated

fun <T> MutableReactiveValue<T>.validated(): MutableValidatedValue<T>

Wraps a MutableReactiveValue as a MutableValidatedValue.

fun <T> MutableReactive<T>.validated(): MutableValidated<T>

Wraps a MutableReactive as a MutableValidated.

fun <T> ReactiveValue<T>.validated(validate: (T) -> Issue?): ValidatedValue<T>

fun <T> Reactive<T>.validated(validate: (T) -> Issue?): Validated<T>

validateNotBlank

fun MutableReactiveValue<String>.validateNotBlank(summary: String = "Cannot be blank.", description: String = summary, setOnIssue: Boolean = true): MutableValidatedValue<String>

Validates that the value of this MutableReactiveValue is not blank (for String values).

fun MutableReactive<String>.validateNotBlank(summary: String = "Cannot be blank.", description: String = summary, setOnIssue: Boolean = true): MutableValidated<String>

Validates that the value of this MutableReactive is not blank (for String values).

validateNotNull

fun <T : Any> MutableReactiveValue<T?>.validateNotNull(summary: String = "Cannot be blank.", description: String = summary, setOnIssue: Boolean = true): MutableValidatedValue<T?>

Validates that the value of this MutableReactiveValue is not null.

fun <T : Any> MutableReactive<T?>.validateNotNull(summary: String = "Cannot be blank.", description: String = summary, setOnIssue: Boolean = true): MutableValidated<T?>

Validates that the value of this MutableReactive is not null.

valueSet

open infix override fun valueSet(value: Set<T>)

withWrite

fun <T> Reactive<T>.withWrite(action: suspend Reactive<T>.(T) -> Unit): MutableReactive<T>