Uses of Annotation Interface
rx.annotations.Experimental
Packages that use Experimental
Package
Description
Base reactive classes: Observable, Single and Completable; base reactive consumers;
other common base interfaces.
Annotations for indicating experimental and beta operators, classes, methods, types or fields.
Exception handling utilities, safe subscriber exception classes,
lifecycle exception classes.
Classes extending the Observable base reactive class, synchronous and
asynchronous event generators.
Default wrappers and implementations for the base reactive consumer classes and interfaces;
utility classes for creating them from callbacks.
Callback types and a central plugin handler class to hook into the lifecycle
of the base reactive types and schedulers.
Scheduler implementations, value+time record classes and the standard factory class to
return standard RxJava schedulers or wrap any Executor-based (thread pool) instances.
Classes extending the Single base reactive class.
Classes extending the Observable base reactive class and implementing
the Observer interface at the same time (aka hot Observables).
-
Uses of Experimental in rx
Classes in rx with annotations of type ExperimentalModifier and TypeInterfaceDescriptioninterface
AsyncEmitter<T>
Abstraction over a RxJava Subscriber that allows associating a resource with it and exposes the current number of downstream requested amount.final class
Generic strategy and default implementations to deal with backpressure buffer overflows.class
Represents a deferred computation without any value but only indication for completion or exception.Methods in rx with annotations of type ExperimentalModifier and TypeMethodDescriptionstatic <T> Observable
<T> Observable.concatDelayError
(Iterable<? extends Observable<? extends T>> sources) Concatenates the Iterable sequence of Observables into a single sequence by subscribing to each Observable, one after the other, one at a time and delays any errors till the all inner Observables terminate.static <T> Observable
<T> Observable.concatDelayError
(Observable<? extends Observable<? extends T>> sources) Concatenates the Observable sequence of Observables into a single sequence by subscribing to each inner Observable, one after the other, one at a time and delays any errors till the all inner and the outer Observables terminate.static <T> Observable
<T> Observable.concatEager
(Iterable<? extends Observable<? extends T>> sources) Concatenates a sequence of Observables eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Iterable<? extends Observable<? extends T>> sources, int capacityHint) Concatenates a sequence of Observables eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends Observable<? extends T>> sources) Concatenates an Observable sequence of Observables eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends Observable<? extends T>> sources, int capacityHint) Concatenates an Observable sequence of Observables eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends T> o1, Observable<? extends T> o2) Concatenates two source Observables eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3) Concatenates three sources eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4) Concatenates four sources eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5) Concatenates five sources eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6) Concatenates six sources eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7) Concatenates seven sources eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8) Concatenates eight sources eagerly into a single stream of values.static <T> Observable
<T> Observable.concatEager
(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8, Observable<? extends T> o9) Concatenates nine sources eagerly into a single stream of values.final <R> Observable
<R> Observable.concatMapDelayError
(Func1<? super T, ? extends Observable<? extends R>> func) Maps each of the items into an Observable, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Observables till all of them terminate.final <R> Observable
<R> Observable.concatMapEager
(Func1<? super T, ? extends Observable<? extends R>> mapper) Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.final <R> Observable
<R> Observable.concatMapEager
(Func1<? super T, ? extends Observable<? extends R>> mapper, int capacityHint) Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.final <R> Observable
<R> Observable.concatMapEager
(Func1<? super T, ? extends Observable<? extends R>> mapper, int capacityHint, int maxConcurrent) Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.static <S,
T> Observable <T> Observable.create
(AsyncOnSubscribe<S, T> asyncOnSubscribe) Returns an Observable that respects the back-pressure semantics.static <T> Single
<T> Returns an Single that emits the items emitted by the source Single shifted forward in time by a specified delay.Returns an Single that emits the items emitted by the source Single shifted forward in time by a specified delay.final <U> Observable
<T> Observable.delaySubscription
(Observable<U> other) Returns an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.Single.delaySubscription
(Observable<?> other) Returns a Single that delays the subscription to this Single until the Observable completes.final Observable
<T> Observable.distinctUntilChanged
(Func2<? super T, ? super T, Boolean> comparator) Returns an Observable that emits all items emitted by the source Observable that are distinct from their immediate predecessors when compared with each other via the provided comparator function.Single.doAfterTerminate
(Action0 action) Registers anAction0
to be called when thisSingle
invokes eitherSingleSubscriber.onSuccess(Object)
onSuccess} oronError
.Modifies the sourceSingle
so that it invokes an action if it callsonError
.Single.doOnSubscribe
(Action0 subscribe) Modifies the sourceSingle
so that it invokes the given action when it is subscribed from its subscribers.Single.doOnSuccess
(Action1<? super T> onSuccess) Modifies the sourceSingle
so that it invokes an action when it callsonSuccess
.Single.doOnUnsubscribe
(Action0 action) Modifies the sourceSingle
so that it invokes the given action when it is unsubscribed from its subscribers.<R> R
Observable.extend
(Func1<? super Observable.OnSubscribe<T>, ? extends R> conversion) Passes all emitted values from this Observable to the provided conversion function to be collected and returned as a single value.static <T> Observable
<T> Observable.fromAsync
(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) Provides an API (via a cold Observable) that bridges the reactive world with the callback-style, generally non-backpressured world.final <K,
R> Observable <GroupedObservable<K, R>> Observable.groupBy
(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends R> elementSelector, Func1<Action1<K>, Map<K, Object>> evictingMapFactory) Groups the items emitted by anObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <R> Single
<R> Single.lift
(Observable.Operator<? extends R, ? super T> lift) Lifts a function to the current Single and returns a new Single that when subscribed to will pass the values of the current Single through the Operator function.static <T> Observable
<T> Observable.mergeDelayError
(Observable<? extends Observable<? extends T>> source, int maxConcurrent) Flattens an Observable that emits Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Observables.final Observable
<T> Observable.onBackpressureBuffer
(long capacity, Action0 onOverflow, BackpressureOverflow.Strategy overflowStrategy) Instructs an Observable that is emitting items faster than its observer can consume them to buffer up to a given amount of items until they can be emitted.Single.onErrorResumeNext
(Func1<Throwable, ? extends Single<? extends T>> resumeFunctionInCaseOfError) Instructs a Single to pass control to another Single rather than invokingObserver.onError(Throwable)
if it encounters an error.Single.onErrorResumeNext
(Single<? extends T> resumeSingleInCaseOfError) Instructs a Single to pass control to another Single rather than invokingObserver.onError(Throwable)
if it encounters an error.final Observable
<T> Observable.onTerminateDetach()
Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream unsubscribes.final Observable
<T> Observable.rebatchRequests
(int n) Requestsn
initially from the upstream and then 75% ofn
subsequently after 75% ofn
values have been emitted to the downstream.final <R> Observable
<R> Observable.switchMapDelayError
(Func1<? super T, ? extends Observable<? extends R>> func) Returns a new Observable by applying a function that you supply to each item emitted by the source Observable that returns an Observable, and then emitting the items emitted by the most recently emitted of these Observables and delays any error until all Observables terminate.static <T> Observable
<T> Observable.switchOnNextDelayError
(Observable<? extends Observable<? extends T>> sequenceOfSequences) Converts an Observable that emits Observables into an Observable that emits the items emitted by the most recently emitted of those Observables and delays any exception until all Observables terminate.final BlockingSingle
<T> Single.toBlocking()
Converts a Single into aBlockingSingle
(a Single with blocking operators).Observable.toCompletable()
Returns a Completable that discards all onNext emissions (similar toignoreAllElements()
) and calls onCompleted when this source observable calls onCompleted.final Completable
Single.toCompletable()
Returns aCompletable
that discards result of theSingle
(similar toObservable.ignoreElements()
) and callsonCompleted
when this sourceSingle
callsonSuccess
.final Observable
<List<T>> Observable.toSortedList
(int initialCapacity) Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order.final Observable
<List<T>> Observable.toSortedList
(Func2<? super T, ? super T, Integer> sortFunction, int initialCapacity) Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order based on a specified comparison function.static <T,
Resource>
Observable<T> Observable.using
(Func0<Resource> resourceFactory, Func1<? super Resource, ? extends Observable<? extends T>> observableFactory, Action1<? super Resource> disposeAction, boolean disposeEagerly) Constructs an Observable that creates a dependent resource object which is disposed of just before termination if you have setdisposeEagerly
totrue
and unsubscription does not occur before termination.static <T,
Resource>
Single<T> Single.using
(Func0<Resource> resourceFactory, Func1<? super Resource, ? extends Single<? extends T>> singleFactory, Action1<? super Resource> disposeAction) Constructs an Single that creates a dependent resource object which is disposed of on unsubscription.static <T,
Resource>
Single<T> Single.using
(Func0<Resource> resourceFactory, Func1<? super Resource, ? extends Single<? extends T>> singleFactory, Action1<? super Resource> disposeAction, boolean disposeEagerly) Constructs an Single that creates a dependent resource object which is disposed of just before termination if you have setdisposeEagerly
totrue
and unsubscription does not occur before termination.<S extends Scheduler & Subscription>
SScheduler.when
(Func1<Observable<Observable<Completable>>, Completable> combine) Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.final <R> Observable
<R> Observable.withLatestFrom
(Iterable<Observable<?>> others, FuncN<R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.final <R> Observable
<R> Observable.withLatestFrom
(Observable<?>[] others, FuncN<R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.final <U,
R> Observable <R> Observable.withLatestFrom
(Observable<? extends U> other, Func2<? super T, ? super U, ? extends R> resultSelector) Merges the specified Observable into this Observable sequence by using theresultSelector
function only when the source Observable (this instance) emits an item.final <T1,
T2, R>
Observable<R> Observable.withLatestFrom
(Observable<T1> o1, Observable<T2> o2, Func3<? super T, ? super T1, ? super T2, R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.final <T1,
T2, T3, T4, T5, R>
Observable<R> Observable.withLatestFrom
(Observable<T1> o1, Observable<T2> o2, Observable<T1> o3, Observable<T2> o4, Observable<T1> o5, Func6<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.final <T1,
T2, T3, T4, T5, T6, R>
Observable<R> Observable.withLatestFrom
(Observable<T1> o1, Observable<T2> o2, Observable<T1> o3, Observable<T2> o4, Observable<T1> o5, Observable<T2> o6, Func7<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.final <T1,
T2, T3, T4, T5, T6, T7, R>
Observable<R> Observable.withLatestFrom
(Observable<T1> o1, Observable<T2> o2, Observable<T1> o3, Observable<T2> o4, Observable<T1> o5, Observable<T2> o6, Observable<T1> o7, Func8<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.final <T1,
T2, T3, T4, T5, T6, T7, T8, R>
Observable<R> Observable.withLatestFrom
(Observable<T1> o1, Observable<T2> o2, Observable<T1> o3, Observable<T2> o4, Observable<T1> o5, Observable<T2> o6, Observable<T1> o7, Observable<T2> o8, Func9<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.final <T1,
T2, T3, R>
Observable<R> Observable.withLatestFrom
(Observable<T1> o1, Observable<T2> o2, Observable<T3> o3, Func4<? super T, ? super T1, ? super T2, ? super T3, R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.final <T1,
T2, T3, T4, R>
Observable<R> Observable.withLatestFrom
(Observable<T1> o1, Observable<T2> o2, Observable<T3> o3, Observable<T4> o4, Func5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.static <R> Observable
<R> Observable.zip
(Observable<?>[] ws, FuncN<? extends R> zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Observables. -
Uses of Experimental in rx.annotations
Classes in rx.annotations with annotations of type ExperimentalModifier and TypeClassDescription@interface
Signifies that a public API (public class, method or field) is will almost certainly be changed or removed in a future release. -
Uses of Experimental in rx.exceptions
Classes in rx.exceptions with annotations of type ExperimentalModifier and TypeClassDescriptionfinal class
A RuntimeException that is stackless but holds onto a textual stacktrace from tracking the assembly location of operators.Methods in rx.exceptions with annotations of type ExperimentalModifier and TypeMethodDescriptionstatic void
Exceptions.throwOrReport
(Throwable t, Observer<?> o) Forwards a fatal exception or reports it to the given Observer.static void
Exceptions.throwOrReport
(Throwable t, Observer<?> o, Object value) Forwards a fatal exception or reports it along with the value caused it to the given Observer.static void
Exceptions.throwOrReport
(Throwable throwable, SingleSubscriber<?> subscriber) Forwards a fatal exception or reports it to the given Observer.Constructors in rx.exceptions with annotations of type ExperimentalModifierConstructorDescriptionCompositeException
(Throwable... errors) Constructs a CompositeException instance with the supplied initial Throwables. -
Uses of Experimental in rx.internal.schedulers
Classes in rx.internal.schedulers with annotations of type ExperimentalModifier and TypeClassDescriptionclass
Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done. -
Uses of Experimental in rx.internal.util
Classes in rx.internal.util with annotations of type ExperimentalModifier and TypeClassDescriptionfinal class
Manages the producer-backpressure-consumer interplay by matching up available elements with requested elements and/or terminal events.final class
Utility functions relating to blocking types.Methods in rx.internal.util with annotations of type ExperimentalModifier and TypeMethodDescriptionstatic void
BlockingUtils.awaitForComplete
(CountDownLatch latch, Subscription subscription) Blocks and waits for aSubscription
to complete. -
Uses of Experimental in rx.observables
Classes in rx.observables with annotations of type ExperimentalModifier and TypeClassDescriptionclass
AsyncOnSubscribe<S,
T> A utility class to createOnSubscribe<T>
functions that respond correctly to back pressure requests from subscribers.Methods in rx.observables with annotations of type ExperimentalModifier and TypeMethodDescriptionstatic <S,
T> AsyncOnSubscribe <S, T> AsyncOnSubscribe.createSingleState
(Func0<? extends S> generator, Action3<? super S, Long, ? super Observer<Observable<? extends T>>> next) Generates a synchronousAsyncOnSubscribe
that calls the providednext
function to generate data to downstream subscribers.static <S,
T> AsyncOnSubscribe <S, T> AsyncOnSubscribe.createSingleState
(Func0<? extends S> generator, Action3<? super S, Long, ? super Observer<Observable<? extends T>>> next, Action1<? super S> onUnsubscribe) Generates a synchronousAsyncOnSubscribe
that calls the providednext
function to generate data to downstream subscribers.static <S,
T> AsyncOnSubscribe <S, T> AsyncOnSubscribe.createStateful
(Func0<? extends S> generator, Func3<? super S, Long, ? super Observer<Observable<? extends T>>, ? extends S> next) Generates a synchronousAsyncOnSubscribe
that calls the providednext
function to generate data to downstream subscribers.static <S,
T> AsyncOnSubscribe <S, T> AsyncOnSubscribe.createStateful
(Func0<? extends S> generator, Func3<? super S, Long, ? super Observer<Observable<? extends T>>, ? extends S> next, Action1<? super S> onUnsubscribe) Generates a synchronousAsyncOnSubscribe
that calls the providednext
function to generate data to downstream subscribers.static <T> AsyncOnSubscribe
<Void, T> AsyncOnSubscribe.createStateless
(Action2<Long, ? super Observer<Observable<? extends T>>> next) Generates a synchronousAsyncOnSubscribe
that calls the providednext
function to generate data to downstream subscribers.static <T> AsyncOnSubscribe
<Void, T> AsyncOnSubscribe.createStateless
(Action2<Long, ? super Observer<Observable<? extends T>>> next, Action0 onUnsubscribe) Generates a synchronousAsyncOnSubscribe
that calls the providednext
function to generate data to downstream subscribers.void
BlockingObservable.subscribe()
Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.void
Subscribes to the source and calls the given action on the current thread and rethrows any exception wrapped into OnErrorNotImplementedException.void
Subscribes to the source and calls the given actions on the current thread.void
BlockingObservable.subscribe
(Action1<? super T> onNext, Action1<? super Throwable> onError, Action0 onCompleted) Subscribes to the source and calls the given actions on the current thread.void
Subscribes to the source and calls back the Observer methods on the current thread.void
BlockingObservable.subscribe
(Subscriber<? super T> subscriber) Subscribes to the source and calls the Subscriber methods on the current thread. -
Uses of Experimental in rx.observers
Classes in rx.observers with annotations of type ExperimentalModifier and TypeClassDescriptionclass
An abstract base class for CompletableSubscriber implementations that want to expose an unsubscription capability.final class
Wraps another CompletableSubscriber and handles exceptions thrown from onError and onCompleted.Methods in rx.observers with annotations of type ExperimentalModifier and TypeMethodDescriptionfinal boolean
TestSubscriber.awaitValueCount
(int expected, long timeout, TimeUnit unit) Wait until the current committed value count is less than the expected amount by sleeping 1 unit at most timeout times and return true if at least the required amount of onNext values have been received.final int
TestSubscriber.getCompletions()
Returns the number of times onCompleted was called on this TestSubscriber. -
Uses of Experimental in rx.plugins
Classes in rx.plugins with annotations of type ExperimentalModifier and TypeClassDescriptionclass
Abstract ExecutionHook with invocations at different lifecycle points ofCompletable
execution with a default no-op implementation.final class
Utility class that holds hooks for various Observable, Single and Completable lifecycle-related points as well as Scheduler hooks.Methods in rx.plugins with annotations of type ExperimentalModifier and TypeMethodDescriptionstatic Scheduler
RxJavaSchedulersHook.createComputationScheduler()
Create an instance of the defaultScheduler
used forSchedulers.computation()
.static Scheduler
RxJavaSchedulersHook.createComputationScheduler
(ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.computation()
except usingthreadFactory
for thread creation.static Scheduler
RxJavaSchedulersHook.createIoScheduler()
Create an instance of the defaultScheduler
used forSchedulers.io()
.static Scheduler
RxJavaSchedulersHook.createIoScheduler
(ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.io()
except usingthreadFactory
for thread creation.static Scheduler
RxJavaSchedulersHook.createNewThreadScheduler()
Create an instance of the defaultScheduler
used forSchedulers.newThread()
.static Scheduler
RxJavaSchedulersHook.createNewThreadScheduler
(ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.newThread()
except usingthreadFactory
for thread creation.RxJavaPlugins.getCompletableExecutionHook()
Retrieves the instance ofRxJavaCompletableExecutionHook
to use based on order of precedence as defined inRxJavaPlugins
class header.void
RxJavaPlugins.registerCompletableExecutionHook
(RxJavaCompletableExecutionHook impl) Register anRxJavaCompletableExecutionHook
implementation as a global override of any injected or default implementations.void
RxJavaPlugins.reset()
ResetRxJavaPlugins
instance -
Uses of Experimental in rx.schedulers
Methods in rx.schedulers with annotations of type ExperimentalModifier and TypeMethodDescriptionstatic void
Schedulers.reset()
Resets the currentSchedulers
instance. -
Uses of Experimental in rx.singles
Classes in rx.singles with annotations of type ExperimentalModifier and TypeClassDescriptionfinal class
BlockingSingle
is a blocking "version" ofSingle
that provides blocking operators.Methods in rx.singles with annotations of type ExperimentalModifier and TypeMethodDescriptionstatic <T> BlockingSingle
<T> Converts aSingle
into aBlockingSingle
.BlockingSingle.toFuture()
Returns aFuture
representing the value emitted by thisBlockingSingle
.BlockingSingle.value()
Returns the item emitted by thisBlockingSingle
. -
Uses of Experimental in rx.subjects
Classes in rx.subjects with annotations of type ExperimentalModifier and TypeClassDescriptionfinal class
A Subject variant which buffers events until a single Subscriber arrives and replays them to it and potentially switches to direct delivery once the Subscriber caught up and requested an unlimited amount.