com.diffplug.common.rx

Interface RxBox<T>

All Superinterfaces:

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

All Known Implementing Classes:

RxBiMap, RxBox.Default, RxList, RxMap, RxOptional, RxOrderedSet, RxSet, RxSortedMap, RxSortedSet

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

Modifier and Type	Interface and Description
static class	RxBox.Default<T> Standard implementation of an RxBox.

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

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

Method Summary

Modifier and Type	Method and Description
default RxBox<T>	enforce(Function<? super T,? extends T> getMapper) Provides a mechanism for enforcing an invariant.
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(Function<? super T,? extends R> getMapper, Function<? super R,? extends T> setMapper) 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, map

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

asObservable

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

accept, from, from, modify, 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(Function<? super T,? extends R> getMapper,
                         Function<? super R,? extends T> setMapper)

Maps one RxBox to another RxBox.

Specified by:

map in interface Box<T>

enforce

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

Provides a mechanism for enforcing an invariant.

For example, let's say that there is an RxBox<List<T>> which represents a user's multiselection in some widget. You would like the user to select a pair of values - you want to enforce that the selection doesn't grow beyond 2 elements.

You could write code like this:

 
 RxBox<List<T>> selection = widget.rxSelection();
 RxGetter<List<T>> onlyPairs = selection.map(list -> list.stream().limit(2).collect(Collectors.toList()));
 Rx.subscribe(onlyPairs, selection);
 
 

But there's a subtle bug in this code. Because RxGetter and RxBox only fire their observables when their value changes, the selection invariant won't be enforced unless onlyPairs actually changes. It's easy to fix:

 
 RxBox<List<T>> selection = widget.rxSelection();
 Observable<List<T>> onlyPairs = selection.asObservable().map(list -> list.stream().limit(2).collect(Collectors.toList()));
 Rx.subscribe(onlyPairs, selection);
 
 

But there's still a problem - selection will momentarily contain values which violate the invariant. That means you can't write listener code that relies on the invariant being true. Which is why the enforce() method exists:

 
 RxBox<List<T>> onlyPairs = widget.rxSelection().enforce(list -> list.stream().limit(2).collect(Collectors.toList()));
 
 

This creates a new RxBox which will always satisfy the invariant, and it will enforce this invariant on the original RxBox.

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.