com.diffplug.common.rx

Interface RxBox<T>

All Superinterfaces:

Box<T>, Consumer<T>, IObservable<T>, ObservableSource<T>, RxGetter<T>, Supplier<T>

All Known Subinterfaces:

RxLockBox<T>

All Known Implementing Classes:

Breaker, ForwardingBox.Rx, ForwardingBox.RxLock, RxOrderedSet

public interface RxBox<T>
extends RxGetter<T>, Box<T>

RxGetter and Box combined in one: a value you can set, get, and subscribe to.

Nested Class Summary

Nested classes/interfaces inherited from interface com.diffplug.common.base.Box

Box.Dbl, Box.Int, Box.Lng, Box.Nullable<T>

Method Summary

Modifier and Type	Method and Description
default RxBox<T>	enforce(Function<? super T,? extends T> enforcer) Provides a mechanism for enforcing an invariant on an existing `RxBox`.
static <T> RxBox<T>	from(RxGetter<T> getter, Consumer<T> setter) Creates an `RxBox` which implements the "getter" part with `RxGetter`, and the setter part with `Consumer`.
default <R> RxBox<R>	map(Converter<T,R> converter) Maps one `RxBox` to another `RxBox`.
static <T> RxBox<T>	of(T initial) Creates an `RxBox` with the given initial value.
default RxGetter<T>	readOnly() Returns a read-only version of this `RxBox`.

Methods inherited from interface com.diffplug.common.rx.RxGetter

combineLatest, from, fromVolatile, map

Methods inherited from interface com.diffplug.common.rx.IObservable

asObservable, subscribe, wrap

Methods inherited from interface com.diffplug.common.base.Box

accept, from, modify, ofVolatile, set

Methods inherited from interface java.util.function.Supplier

get

Methods inherited from interface java.util.function.Consumer

andThen

Method Detail

readOnly

default RxGetter<T> readOnly()

Returns a read-only version of this `RxBox`.

map

default <R> RxBox<R> map(Converter<T,R> converter)

Maps one `RxBox` to another `RxBox`.

Specified by:

map in interface Box<T>

enforce

default RxBox<T> enforce(Function<? super T,? extends T> enforcer)

Provides a mechanism for enforcing an invariant on an existing `RxBox`. The returned `RxBox` and its observable will **always** satisfy the given invariant. If the underlying `RxBox` changes in a way which does not satisfy the invariant, it will be set so that it does match the invariant. During this process, the underlying `RxBox` will momentarily fail to meet the invariant, and its `Observable` will emit values which fail the invariant. The returned `RxBox`, however, will always meet the invariant, so downstream consumers can rely on the invariant holding true at all times. The returned `RxBox` can be mapped, and has the same atomicity guarantees as the underlying `RxBox` (e.g. an enforced RxLockBox can still be modified atomically). Conflicting calls to `enforce` can cause an infinite loop, see Breaker for a possible solution. ```java // this will not end well... RxBox.of(1).enforce(Math::abs).enforce(i -> -Math.abs(i)); ```

of

static <T> RxBox<T> of(T initial)

Creates an `RxBox` with the given initial value.

Specified by:

of in interface Box<T>

from

static <T> RxBox<T> from(RxGetter<T> getter,
                         Consumer<T> setter)

Creates an `RxBox` which implements the "getter" part with `RxGetter`, and the setter part with `Consumer`.