@ParametersAreNonnullByDefault

Package com.diffplug.common.rx

DurianRx unifies RxJava's [Observable](http://reactivex.io/documentation/observable.html) with Guava's [ListenableFuture](https://code.google.com/p/guava-libraries/wiki/ListenableFutureExplained).

See: Description

Interface Summary

Interface	Description
CasBox<T>	CasBox is a lock-free and race-condition-free mechanism for updating a value.
IObservable<T>	An object which can be supplied in an Observable form.
LockBox<T>	LockBox is a box where every call to LockBox.modify(Function) happens within a synchronized block.
RxBox<T>	RxGetter and Box combined in one: a value you can set, get, and subscribe to.
RxExecutor.Has	Marker interface which allows an Executor to specify its own Scheduler.
RxGetter<T>	Represents a value which can be accessed through a traditional `get()` method or by listening to its Observable.
RxLockBox<T>	RxBox and LockBox in one.
RxSubscriber	An object which can subscribe observables to RxListener listeners.
RxTracingPolicy	Plugin which gets notified of every call to Rx.subscribe, allowing various kinds of tracing.

Class Summary

Class	Description
Breaker<T>	A mechanism for "turning off" an existing `RxBox`, much like a a circuit breaker.
ForwardingBox<T,BoxType extends Box<T>>	Utility class for wrapping one kind of box with another.
ForwardingBox.Cas<T>
ForwardingBox.Lock<T>
ForwardingBox.Rx<T>
ForwardingBox.RxLock<T>
OrderedLock	All code which takes locks using this code is guaranteed to do so in the same order, guaranteeing there won't be a deadlock.
RateProbe	A probe for inspecting rates in reactive systems.
Rx	Unifies the listener models of RxJava's Observable with Guava's ListenableFuture , and also adds tracing capabilities.
RxExecutor	This class holds an instance of Executor (for ListenableFuture) and Scheduler (for Observable).
RxListener<T>
RxTracingPolicy.LogSubscriptionTrace	An RxTracingPolicy which logs the stack trace of every subscription, so that it can decorate any exceptions with the stack trace at the time they were subscribed.

Package com.diffplug.common.rx Description

DurianRx unifies RxJava's [Observable](http://reactivex.io/documentation/observable.html) with Guava's [ListenableFuture](https://code.google.com/p/guava-libraries/wiki/ListenableFutureExplained). If you happen to be using SWT as a widget toolkit, then you'll want to look at [DurianSwt](https://github.com/diffplug/durian-swt) as well. ```java Observable observable = someObservable(); ListenableFuture future = someFuture(); Rx.subscribe(observable, val -> doSomething(val)); Rx.subscribe(future, val -> doSomething(val)); ``` It also provides reactive getters, a simple abstraction for piping data which allows access via `T get()` or `Observable asObservable()`. ```java RxBox mousePos = RxBox.of(new Point(0, 0)); this.addMouseListener(e -> mousePos.set(new Point(e.x, e.y))); Rectangle hotSpot = new Rectangle(0, 0, 10, 10) RxGetter isMouseOver = mousePos.map(hotSpot::contains); ``` Debugging an error which involves lots of callbacks can be difficult. To make this easier, DurianRx includes a tracing capability, which makes this task easier. ```java // anytime an error is thrown in an Rx callback, the stack trace of the error // will be wrapped by the stack trace of the original subscription DurianPlugins.set(RxTracingPolicy.class, new LogSubscriptionTrace()). ```