All Classes

Class	Description
AlwaysFalseBooleanSupplier	A BooleanSupplier implementation that is always false.
AlwaysTrueBooleanSupplier	A BooleanSupplier implementation that is always true.
AnyValue	Placeholder instance when one has to return something (and used to return null in 1.x).
AsyncFlowable	Utility methods to convert functions and actions into asynchronous operations through the Publisher/Subscriber pattern.
AsyncObservable	Utility methods to convert functions and actions into asynchronous operations through the Observable/Observer pattern.
BasicEmitter<T>	Abstraction over a Subscriber.
BasicMergeSubscription<T>	Subscription coordinator that merges items from a fixed set of source Publishers by picking the smallest available next item from them based on a Comparator.
BiFunctionSecondIdentity	A BiFunction that returns its second parameter; use BiFunctionSecondIdentity.instance() to get a correctly typed (shared) instance.
BlockingScheduler	A Scheduler that uses the current thread, in an event-loop and blocking fashion to execute actions.
CompletableConsumers	Utility methods for creating and using consumers Completables.
Completables	Additional operators in the form of CompletableConverters, use Completable.to(CompletableConverter) to apply the operators to an existing sequence.
CompletableTransformers	Additional operators in the form of CompletableTransformer, use Completable.compose(CompletableTransformer) to apply the operators to an existing sequence.
CompositeSubscription	Container for Subscriptions and atomic operations on them.
Consumer3<T1,T2,T3>	Functional interface for a callback that consumes multipe values at the same and may throw a checked exception.
Consumer4<T1,T2,T3,T4>	Functional interface for a callback that consumes multipe values at the same and may throw a checked exception.
Consumer5<T1,T2,T3,T4,T5>	Functional interface for a callback that consumes multipe values at the same and may throw a checked exception.
Consumer6<T1,T2,T3,T4,T5,T6>	Functional interface for a callback that consumes multipe values at the same and may throw a checked exception.
Consumer7<T1,T2,T3,T4,T5,T6,T7>	Functional interface for a callback that consumes multipe values at the same and may throw a checked exception.
Consumer8<T1,T2,T3,T4,T5,T6,T7,T8>	Functional interface for a callback that consumes multipe values at the same and may throw a checked exception.
Consumer9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	Functional interface for a callback that consumes multipe values at the same and may throw a checked exception.
DispatchWorkProcessor<T>	A FlowableProcessor variant that queues up items and dispatches them asynchronously so that one of the currently subscribed Subscribers can pick it up one by one, otherwise* cache it until at least an Subscriber subscribes.
DispatchWorkSubject<T>	A Subject variant that queues up items and dispatches them asynchronously so that one of the currently subscribed Observers can pick it up one by one, otherwise* cache it until at least an Observer subscribes.
DisposableFlowable<T>	A Flowable that also offers a means to dispose it, cancelling/disposing some shared underlying computation or resource via Disposable.dispose().
DisposableObservable<T>	A Observable that also offers a means to dispose it, cancelling/disposing some shared underlying computation or resource via Disposable.dispose().
ExpandStrategy	Represents the strategies for recursive expansion with the expand() operator.
FlowableAsyncEmitter<T>	Provides an API on top of the Emitter signals that allow setting and replacing a Cancellable resource to be cancelled when the associated flow is cancelled.
FlowableConsumers	Utility methods for creating and using consumers Flowables.
FlowableProcessors	Utility methods to work with Reactive-Streams Processors and RxJava 2 FlowableProcessors.
Flowables	Utility class to create Flowable sources.
FlowableTransformers	Additional operators in the form of FlowableTransformer, use Flowable.compose(FlowableTransformer) to apply the operators to an existing sequence.
FunctionsEx	Utility methods to work with functional interfaces of this package.
FunctionTagging	Wraps the regular io.reactivex.functions function types and appends the user-specified tag to the exception the wrapped function produces.
FunctionTagging.FunctionTaggingException	The stackless tagging exception appended to the chain of causes of the original exception thrown by the wrapped function.
JoinObservable<T>	Represents an observable that supports join operations.
MathFlowable	Utility methods to work with numerical Flowable sources: sum, min, max and average.
MathObservable	Utility methods to work with numerical Observable sources: sum, min, max and average.
MaybeConsumers	Utility methods for creating and using consumers Maybes.
Maybes	Additional operators in the form of MaybeConverters, use Maybe.to(MaybeConverter) to apply the operators to an existing sequence.
MaybeTransformers	Additional operators in the form of MaybeTransformer, use Maybe.compose(MaybeTransformer) to apply the operators to an existing sequence.
MultiHandlerManager<H>	Manages an array of handlers.
MultipleOnSubscribeCallsException	Indicates there were multiple onSubscribe calls.
MultipleTerminationsException	Indicates there were multiple onError or onComplete calls.
Nono	Represents the base reactive class with fluent API for Publisher-based, no-item just onError or onComplete source.
NonoProcessor	A hot Nono that signals the terminal event to Subscribers.
NullOnErrorParameterException	Indicates the onError was called with a null Throwable.
NullOnNextParameterException	Indicates the onNext was called with a null value.
NullOnSubscribeParameterException	Indicates the onSubscribe was called with a null Disposable or Subscription.
NullOnSuccessParameterException	Indicates the onSuccess was called with a null value.
ObservableAverageDouble
ObservableAverageFloat
ObservableConsumers	Utility methods for creating and using consumers Observables.
Observables	Utility class to create Observable sources.
ObservableSumDouble
ObservableSumFloat
ObservableSumLong
ObservableTransformers	Additional operators in the form of ObservableTransformer, use Observable.compose(ObservableTransformer) to apply the operators to an existing sequence.
OnNextAfterTerminationException	The onNext was invoked after an onError or onComplete call.
OnScheduleMultiHandlerManager	Handles the OnSchedule hooks.
OnSubscribeNotCalledException	The onSubscribe was not called before calling onNext, onSuccess, onError or onComplete.
OnSuccessAfterTerminationException	The onSuccess was invoked after an onError or onComplete call.
ParallelScheduler	Scheduler with a configurable fixed amount of thread-pools.
ParallelTransformers	Transformers for RxJava 2 ParallelFlowable sequences.
PartialCollectEmitter<T,I,A,R>	Provides callbacks and methods to support the partial collect operator: access to cached elements, save and retrieve an input index and accumulator and produce the output instance.
Pattern1<T1>	Represents a join pattern over Observable sequences.
Pattern2<T1,T2>	Represents a join pattern over observable sequences.
Pattern3<T1,T2,T3>	Represents a join pattern over observable sequences.
Pattern4<T1,T2,T3,T4>	Represents a join pattern over observable sequences.
Pattern5<T1,T2,T3,T4,T5>	Represents a join pattern over observable sequences.
Pattern6<T1,T2,T3,T4,T5,T6>	Represents a join pattern over observable sequences.
Pattern7<T1,T2,T3,T4,T5,T6,T7>	Represents a join pattern over observable sequences.
Pattern8<T1,T2,T3,T4,T5,T6,T7,T8>	Represents a join pattern over observable sequences.
Pattern9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	Represents a join pattern over observable sequences.
PatternN	Represents a join pattern over observable sequences.
Perhaps<T>	A 0-1-error base reactive type, similar to Maybe, implementing the Reactive-Streams Publisher interface.
PerhapsProcessor<T>	A Processor based on the Perhaps type that emits an onNext+onComplete, only onComplete or an onError.
PlainBiConsumer<T1,T2>	A BiConsumer with suppressed exception on its PlainBiConsumer.accept(Object, Object) method.
PlainBiFunction<T1,T2,R>	A BiFunction with suppressed exception on its PlainBiFunction.apply(Object, Object) method.
PlainConsumer<T>	A Consumer with suppressed exception on its PlainConsumer.accept(Object) method.
PlainFunction<T,R>	A Function with suppressed exception on its PlainFunction.apply(Object) method.
PlainFunction3<T1,T2,T3,R>	A Function3 with suppressed exception on its PlainFunction3.apply(Object, Object, Object) method.
PlainFunction4<T1,T2,T3,T4,R>	A Function4 with suppressed exception on its PlainFunction4.apply(Object, Object, Object, Object) method.
PlainFunction5<T1,T2,T3,T4,T5,R>	A Function5 with suppressed exception on its PlainFunction5.apply(Object, Object, Object, Object, Object) method.
PlainFunction6<T1,T2,T3,T4,T5,T6,R>	A Function6 with suppressed exception on its PlainFunction6.apply(Object, Object, Object, Object, Object, Object) method.
PlainFunction7<T1,T2,T3,T4,T5,T6,T7,R>	A Function7 with suppressed exception on its PlainFunction7.apply(Object, Object, Object, Object, Object, Object, Object) method.
PlainFunction8<T1,T2,T3,T4,T5,T6,T7,T8,R>	A Function8 with suppressed exception on its PlainFunction8.apply(Object, Object, Object, Object, Object, Object, Object, Object) method.
PlainFunction9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>	A Function9 with suppressed exception on its PlainFunction9.apply(Object, Object, Object, Object, Object, Object, Object, Object, Object) method.
Plan<R>	Represents an execution plan for join patterns.
ProtocolNonConformanceException	Base exception type indicating a failure in conforming the Reactive-Streams or derived protocol.
RxJavaAssemblyException	Holds onto the assembly stacktrace.
RxJavaAssemblyTracking	Utility class to enable and disable tracking of operator application (source.map().filter()) by capturing the current stacktrace (warning: very expensive!)
RxJavaProtocolValidator	Installs assembly hooks that validate the Reactive-Streams and derived protocols are honored.
SavedHooks	Remembers the previous hooks overridden by the debug function and allows restoring them via the SavedHooks.restore() method call.
SelfComparator	Comparator that compares Comparables.
SharedScheduler	A Scheduler implementation that uses one of the Workers from another Scheduler and shares the access to it through its own Workers.
SimpleCallable<T>	A Callable with suppressed exception on its SimpleCallable.call() method.
SingleConsumers	Utility methods for creating and using consumers SingleObservers.
Singles	Additional operators in the form of SingleConverters, use Single.to(SingleConverter) to apply the operators to an existing sequence.
SingleTransformers	Additional operators in the form of SingleTransformer, use Single.compose(SingleTransformer) to apply the operators to an existing sequence.
SneakyThrows	Utility class to throw arbitrary Throwables.
Solo<T>	Base class with fluent API for supporting a Publisher with exactly 1 element or an error.
SoloProcessor<T>	A Processor based on the Solo type that emits an onNext+onComplete or an onError.
SpmcLinkedArrayQueue<T>	A single-producer multiple-conumer queue implementation with array islands.
SpscOneQueue<T>	A single-producer single-consumer queue with exactly one slot of value.
StatementCompletable	Imperative statements expressed as Completable operators.
StatementFlowable	Imperative statements expressed as Flowable operators.
StatementMaybe	Imperative statements expressed as Maybe operators.
StatementObservable	Imperative statements expressed as Observable operators.
StatementSingle	Imperative statements expressed as Single operators.
StringFlowable	Utility class for String operations with Flowables.
StringObservable	Utility class for String operations with Observables.
Subjects	Utility methods to work with RxJava 2 Subjects.
UnicastWorkSubject<T>	A Subject that holds an unbounded queue of items and relays/replays it to a single Observer at a time, making sure that when the Observer disposes, any unconsumed items are available for the next Observer.