Last

Holder of a value that is computed in time.

Example usage is in automatic registering and unregistering of listeners.

Imagine a hypothetical API: - registerListener(Consumercallback) - unregisterListener(Consumer

Wrapping this type of API into a Lastis trivial:

Last.of(acceptor -> { Consumercallback = acceptor::onValue; acceptor.onDisposed(() -> api.unregisterListener(callback)); api.registerListener(callback); }, () -> "initial value");

Inheritors

SharedPreference

Constructors

Last

constructor(@NonNull holder: Consumer<Last.Acceptor<T>>, @Nullable defaultValue: T)

Types

Acceptor

interface Acceptor<T>

Functions

open fun close()

abstract fun close()

dispose

open fun dispose()

Dispose the resource.

disposed

@NonNull

@Contract(value = " -> new")

@CheckResult

open fun disposed(): Disposable

Constructs and empty disposable that is already disposed.

fromRunnable

@NonNull

@Contract(value = "_ -> new")

@CheckResult

open fun fromRunnable(@NonNull run: Runnable): Disposable

Construct a Disposable by wrapping a Runnable that is executed exactly once when the Disposable is disposed.

get

open fun get(): T

isDisposed

open fun isDisposed(): Boolean

Returns true if this resource has been disposed.

map

open fun <R> map(mapper: (T) -> R): Last<R>

observe

open fun observe(consumer: Consumer<T>): Disposable

@NonNull

@Contract(value = "_ -> new", pure = true)

open fun <T> of(@NonNull holder: Consumer<Last.Acceptor<T>>): Last<T>

@NonNull

@Contract(value = "_, _ -> new", pure = true)

open fun <T> of(@NonNull holder: Consumer<Last.Acceptor<T>>, @NonNull defaultValue: T): Last<T>