Index (RxJava Javadoc 0.1.0)

A B C D E F G H I J L M N O P Q R S T U W Z

A

add(Disposable) - Method in class io.reactivex.observable.observers.ResourceCompletableObserver: Adds a resource to this ResourceObserver.
add(Disposable) - Method in class io.reactivex.observable.observers.ResourceMaybeObserver: Adds a resource to this ResourceObserver.
add(Disposable) - Method in class io.reactivex.observable.observers.ResourceObserver: Adds a resource to this ResourceObserver.
add(Disposable) - Method in class io.reactivex.observable.observers.ResourceSingleObserver: Adds a resource to this ResourceObserver.
all(Predicate<? super T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits a Boolean that indicates whether all of the items emitted by the source ObservableSource satisfy a condition.
amb(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.observable.Completable: Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and cancels all other Completables.
amb(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Runs multiple Maybe sources and signals the events of the first one that signals (cancelling the rest).
amb(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends a termination notification.
amb(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.observable.Single: Runs multiple Single sources and signals the events of the first one that signals (cancelling the rest).
ambArray(CompletableSource...) - Static method in class io.reactivex.observable.Completable: Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and cancels all other Completables.
ambArray(MaybeSource<? extends T>...) - Static method in class io.reactivex.observable.Maybe: Runs multiple Maybe sources and signals the events of the first one that signals (cancelling the rest).
ambArray(ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Mirrors the one ObservableSource in an array of several ObservableSources that first either emits an item or sends a termination notification.
ambArray(SingleSource<? extends T>...) - Static method in class io.reactivex.observable.Single: Runs multiple Single sources and signals the events of the first one that signals (cancelling the rest).
ambWith(CompletableSource) - Method in class io.reactivex.observable.Completable: Returns a Completable that emits the a terminated event of either this Completable or the other Completable whichever fires first.
ambWith(MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: Mirrors the MaybeSource (current or provided) that first signals an event.
ambWith(ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Mirrors the ObservableSource (current or provided) that first either emits an item or sends a termination notification.
ambWith(SingleSource<? extends T>) - Method in class io.reactivex.observable.Single: Signals the event of this or the other SingleSource whichever signals first.
andThen(ObservableSource<T>) - Method in class io.reactivex.observable.Completable: Returns an Observable which will subscribe to this Completable and once that is completed then will subscribe to the next Observable.
andThen(SingleSource<T>) - Method in class io.reactivex.observable.Completable: Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to the next SingleSource.
andThen(MaybeSource<T>) - Method in class io.reactivex.observable.Completable: Returns a Maybe which will subscribe to this Completable and once that is completed then will subscribe to the next MaybeSource.
andThen(CompletableSource) - Method in class io.reactivex.observable.Completable: Returns a Completable that first runs this Completable and then the other completable.
ANY - Static variable in interface io.reactivex.observable.extensions.QueueFuseable: Request any of the QueueFuseable.SYNC or QueueFuseable.ASYNC modes.
any(Predicate<? super T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits true if any item emitted by the source ObservableSource satisfies a specified condition, otherwise false.
apply(CompletableObserver) - Method in interface io.reactivex.observable.CompletableOperator: Applies a function to the child CompletableObserver and returns a new parent CompletableObserver.
apply(Completable) - Method in interface io.reactivex.observable.CompletableTransformer: Applies a function to the upstream Completable and returns a CompletableSource.
apply(MaybeObserver<? super Downstream>) - Method in interface io.reactivex.observable.MaybeOperator: Applies a function to the child MaybeObserver and returns a new parent MaybeObserver.
apply(Maybe<Upstream>) - Method in interface io.reactivex.observable.MaybeTransformer: Applies a function to the upstream Maybe and returns a MaybeSource with optionally different element type.
apply(Observer<? super Downstream>) - Method in interface io.reactivex.observable.ObservableOperator: Applies a function to the child Observer and returns a new parent Observer.
apply(Observable<Upstream>) - Method in interface io.reactivex.observable.ObservableTransformer: Applies a function to the upstream Observable and returns an ObservableSource with optionally different element type.
apply(SingleObserver<? super Downstream>) - Method in interface io.reactivex.observable.SingleOperator: Applies a function to the child SingleObserver and returns a new parent SingleObserver.
apply(Single<Upstream>) - Method in interface io.reactivex.observable.SingleTransformer: Applies a function to the upstream Single and returns a SingleSource with optionally different element type.
assertNotSubscribed() - Method in class io.reactivex.observable.observers.TestObserver: Assert that the onSubscribe method hasn't been called at all.
assertOf(Consumer<? super TestObserver<T>>) - Method in class io.reactivex.observable.observers.TestObserver: Run a check consumer with this TestObserver instance.
assertSubscribed() - Method in class io.reactivex.observable.observers.TestObserver: Assert that the onSubscribe method was called exactly once.
ASYNC - Static variable in interface io.reactivex.observable.extensions.QueueFuseable: Request an asynchronous fusion mode and can be returned by QueueFuseable.requestFusion(int) for an accepted mode.
AsyncSubject<T> - Class in io.reactivex.observable.subjects: An Subject that emits the very last value followed by a completion event or the received error to Observers.
autoConnect() - Method in class io.reactivex.observable.ConnectableObservable: Returns an Observable that automatically connects to this ConnectableObservable when the first Subscriber subscribes.
autoConnect(int) - Method in class io.reactivex.observable.ConnectableObservable: Returns an Observable that automatically connects to this ConnectableObservable when the specified number of Subscribers subscribe to it.
autoConnect(int, Consumer<? super Disposable>) - Method in class io.reactivex.observable.ConnectableObservable: Returns an Observable that automatically connects to this ConnectableObservable when the specified number of Subscribers subscribe to it and calls the specified callback with the Subscription associated with the established connection.

B

BehaviorSubject<T> - Class in io.reactivex.observable.subjects: Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed Observer.
blockingAwait() - Method in class io.reactivex.observable.Completable: Subscribes to and awaits the termination of this Completable instance in a blocking manner and rethrows any exception emitted.
blockingAwait(long, TimeUnit) - Method in class io.reactivex.observable.Completable: Subscribes to and awaits the termination of this Completable instance in a blocking manner with a specific timeout and rethrows any exception emitted within the timeout window.
blockingFirst() - Method in class io.reactivex.observable.Observable: Returns the first item emitted by this Observable, or throws NoSuchElementException if it emits no items.
blockingFirst(T) - Method in class io.reactivex.observable.Observable: Returns the first item emitted by this Observable, or a default value if it emits no items.
blockingForEach(Consumer<? super T>) - Method in class io.reactivex.observable.Observable: Invokes a method on each item emitted by this Observable and blocks until the Observable completes.
blockingGet() - Method in class io.reactivex.observable.Completable: Subscribes to this Completable instance and blocks until it terminates, then returns null or the emitted exception if any.
blockingGet(long, TimeUnit) - Method in class io.reactivex.observable.Completable: Subscribes to this Completable instance and blocks until it terminates or the specified timeout elapses, then returns null for normal termination or the emitted exception if any.
blockingGet() - Method in class io.reactivex.observable.Maybe: Waits in a blocking fashion until the current Maybe signals a success value (which is returned), null if completed or an exception (which is propagated).
blockingGet(T) - Method in class io.reactivex.observable.Maybe: Waits in a blocking fashion until the current Maybe signals a success value (which is returned), defaultValue if completed or an exception (which is propagated).
blockingGet() - Method in class io.reactivex.observable.Single: Waits in a blocking fashion until the current Single signals a success value (which is returned) or an exception (which is propagated).
blockingIterable() - Method in class io.reactivex.observable.Observable: Converts this Observable into an Iterable.
blockingIterable(int) - Method in class io.reactivex.observable.Observable: Converts this Observable into an Iterable.
blockingLast() - Method in class io.reactivex.observable.Observable: Returns the last item emitted by this Observable, or throws NoSuchElementException if this Observable emits no items.
blockingLast(T) - Method in class io.reactivex.observable.Observable: Returns the last item emitted by this Observable, or a default value if it emits no items.
blockingLatest() - Method in class io.reactivex.observable.Observable: Returns an Iterable that returns the latest item emitted by this Observable, waiting if necessary for one to become available.
blockingMostRecent(T) - Method in class io.reactivex.observable.Observable: Returns an Iterable that always returns the item most recently emitted by this Observable.
blockingNext() - Method in class io.reactivex.observable.Observable: Returns an Iterable that blocks until this Observable emits another item, then returns that item.
blockingSingle() - Method in class io.reactivex.observable.Observable: If this Observable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.
blockingSingle(T) - Method in class io.reactivex.observable.Observable: If this Observable completes after emitting a single item, return that item; if it emits more than one item, throw an IllegalArgumentException; if it emits no items, return a default value.
blockingSubscribe() - Method in class io.reactivex.observable.Observable: Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
blockingSubscribe(Consumer<? super T>) - Method in class io.reactivex.observable.Observable: Subscribes to the source and calls the given callbacks on the current thread.
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.observable.Observable: Subscribes to the source and calls the given callbacks on the current thread.
blockingSubscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.observable.Observable: Subscribes to the source and calls the given callbacks on the current thread.
blockingSubscribe(Observer<? super T>) - Method in class io.reactivex.observable.Observable: Subscribes to the source and calls the Observer methods on the current thread.
BOUNDARY - Static variable in interface io.reactivex.observable.extensions.QueueFuseable: Used in binary or combination with the other constants as an input to QueueFuseable.requestFusion(int) indicating that the SimpleQueue.poll() will be called behind an asynchronous boundary and thus may change the non-trivial computation locations attached to the SimpleQueue.poll() chain of fused operators.
buffer(int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(int, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(int, int, Callable) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(int, Callable) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(long, long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(long, long, TimeUnit, Scheduler, Callable) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(long, TimeUnit, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(long, TimeUnit, Scheduler, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(long, TimeUnit, Scheduler, int, Callable, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(ObservableSource<? extends TOpening>, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(ObservableSource<? extends TOpening>, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>>, Callable) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(ObservableSource) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
buffer(ObservableSource, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
buffer(ObservableSource, Callable) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
buffer(Callable<? extends ObservableSource>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
buffer(Callable<? extends ObservableSource>, Callable) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits buffers of items it collects from the source ObservableSource.
bufferSize() - Static method in class io.reactivex.observable.Observable: Returns the default 'island' size or capacity-increment hint for unbounded buffers.

C

cache() - Method in class io.reactivex.observable.Completable: Subscribes to this Completable only once, when the first CompletableObserver subscribes to the result Completable, caches its terminal event and relays/replays it to observers.
cache() - Method in class io.reactivex.observable.Maybe: Returns a Maybe that subscribes to this Maybe lazily, caches its event and replays it, to all the downstream subscribers.
cache() - Method in class io.reactivex.observable.Observable: Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
cache() - Method in class io.reactivex.observable.Single: Stores the success value or exception from the current Single and replays it to late SingleObservers.
cacheWithInitialCapacity(int) - Method in class io.reactivex.observable.Observable: Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
call() - Method in interface io.reactivex.observable.extensions.ScalarCallable
cancel() - Method in class io.reactivex.observable.observers.DefaultObserver: Cancels the upstream's disposable.
cancel() - Method in class io.reactivex.observable.observers.TestObserver: Cancels the TestObserver (before or after the subscription happened).
cast(Class<? extends U>) - Method in class io.reactivex.observable.Maybe: Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.
cast(Class) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by the source ObservableSource, converted to the specified type.
cast(Class<? extends U>) - Method in class io.reactivex.observable.Single: Casts the success value of the current Single into the target type or signals a ClassCastException if not compatible.
clear() - Method in interface io.reactivex.observable.extensions.SimpleQueue: Removes all enqueued items from this queue.
collect(Callable<? extends U>, BiConsumer<? super U, ? super T>) - Method in class io.reactivex.observable.Observable: Collects items emitted by the source ObservableSource into a single mutable data structure and returns a Single that emits this structure.
collectInto(U, BiConsumer<? super U, ? super T>) - Method in class io.reactivex.observable.Observable: Collects items emitted by the source ObservableSource into a single mutable data structure and returns a Single that emits this structure.
combineLatest(Function<? super Object[], ? extends R>, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T>[], Function<? super Object[], ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T>[], Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from either of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines seven source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, ObservableSource<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines eight source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatest(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, ObservableSource<? extends T8>, ObservableSource<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines nine source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatestDelayError(ObservableSource<? extends T>[], Function<? super Object[], ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
combineLatestDelayError(Function<? super Object[], ? extends R>, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
combineLatestDelayError(ObservableSource<? extends T>[], Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
combineLatestDelayError(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
combineLatestDelayError(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>, int) - Static method in class io.reactivex.observable.Observable: Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
Completable - Class in io.reactivex.observable: Represents a deferred computation without any value but only indication for completion or exception.
Completable() - Constructor for class io.reactivex.observable.Completable
CompletableEmitter - Interface in io.reactivex.observable: Abstraction over an RxJava CompletableObserver that allows associating a resource with it.
CompletableObserver - Interface in io.reactivex.observable: Represents the subscription API callbacks when subscribing to a Completable instance.
CompletableOnSubscribe - Interface in io.reactivex.observable: A functional interface that has a subscribe() method that receives an instance of a CompletableEmitter instance that allows pushing an event in a cancellation-safe manner.
CompletableOperator - Interface in io.reactivex.observable: Interface to map/wrap a downstream observer to an upstream observer.
CompletableSource - Interface in io.reactivex.observable: Represents a basic Completable source base interface, consumable via an CompletableObserver.
CompletableSubject - Class in io.reactivex.observable.subjects: Represents a hot Completable-like source and consumer of events similar to Subjects.
CompletableTransformer - Interface in io.reactivex.observable: Convenience interface and callback used by the compose operator to turn a Completable into another Completable fluently.
complete() - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that completes immediately when subscribed to.
compose(CompletableTransformer) - Method in class io.reactivex.observable.Completable: Calls the given transformer function with this instance and returns the function's resulting Completable.
compose(MaybeTransformer<? super T, ? extends R>) - Method in class io.reactivex.observable.Maybe: Transform a Maybe by applying a particular Transformer function to it.
compose(ObservableTransformer<? super T, ? extends R>) - Method in class io.reactivex.observable.Observable: Transform an ObservableSource by applying a particular Transformer function to it.
compose(SingleTransformer<? super T, ? extends R>) - Method in class io.reactivex.observable.Single: Transform a Single by applying a particular Transformer function to it.
concat(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.observable.Completable: Returns a Completable which completes only when all sources complete, one after another.
concat(ObservableSource<? extends CompletableSource>) - Static method in class io.reactivex.observable.Completable: Returns a Completable which completes only when all sources complete, one after another.
concat(ObservableSource<? extends CompletableSource>, int) - Static method in class io.reactivex.observable.Completable: Returns a Completable which completes only when all sources complete, one after another.
concat(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence.
concat(MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Returns an Observable that emits the items emitted by two MaybeSources, one after the other.
concat(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Returns an Observable that emits the items emitted by three MaybeSources, one after the other.
concat(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Returns an Observable that emits the items emitted by four MaybeSources, one after the other.
concat(ObservableSource<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an ObservableSource sequence.
concat(ObservableSource<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.observable.Maybe: Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an ObservableSource sequence.
concat(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Concatenates elements of each ObservableSource provided via an Iterable sequence into a single sequence of elements without interleaving them.
concat(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the source ObservableSource, one after the other, without interleaving them.
concat(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the source ObservableSource, one after the other, without interleaving them.
concat(ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by two ObservableSources, one after the other, without interleaving them.
concat(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without interleaving them.
concat(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without interleaving them.
concat(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.observable.Single: Concatenate the single values, in a non-overlapping fashion, of the Single sources provided by an Iterable sequence.
concat(ObservableSource<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.observable.Single: Concatenate the single values, in a non-overlapping fashion, of the Single sources provided by an Observable sequence.
concat(ObservableSource<? extends SingleSource<? extends T>>, int) - Static method in class io.reactivex.observable.Single: Concatenate the single values, in a non-overlapping fashion, of the Single sources provided by an ObservableSource sequence and prefetched by the specified amount.
concat(SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.observable.Single: Returns an Observable that emits the items emitted by two Singles, one after the other.
concat(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.observable.Single: Returns an Observable that emits the items emitted by three Singles, one after the other.
concat(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.observable.Single: Returns an Observable that emits the items emitted by four Singles, one after the other.
concatArray(CompletableSource...) - Static method in class io.reactivex.observable.Completable: Returns a Completable which completes only when all sources complete, one after another.
concatArray(MaybeSource<? extends T>...) - Static method in class io.reactivex.observable.Maybe: Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array.
concatArray(ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Concatenates a variable number of ObservableSource sources.
concatArray(SingleSource<? extends T>...) - Static method in class io.reactivex.observable.Single: Concatenate the single values, in a non-overlapping fashion, of the Single sources provided in an array.
concatArrayDelayError(MaybeSource<? extends T>...) - Static method in class io.reactivex.observable.Maybe: Concatenates a variable number of MaybeSource sources and delays errors from any of them till all terminate.
concatArrayDelayError(ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Concatenates a variable number of ObservableSource sources and delays errors from any of them till all terminate.
concatArrayEager(MaybeSource<? extends T>...) - Static method in class io.reactivex.observable.Maybe: Concatenates a sequence of MaybeSource eagerly into a single stream of values.
concatArrayEager(ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Concatenates a sequence of ObservableSources eagerly into a single stream of values.
concatArrayEager(int, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Concatenates a sequence of ObservableSources eagerly into a single stream of values.
concatDelayError(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Concatenates the Iterable sequence of MaybeSources into a single sequence by subscribing to each MaybeSource, one after the other, one at a time and delays any errors till the all inner MaybeSources terminate.
concatDelayError(ObservableSource<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
concatDelayError(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Concatenates the Iterable sequence of ObservableSources into a single sequence by subscribing to each ObservableSource, one after the other, one at a time and delays any errors till the all inner ObservableSources terminate.
concatDelayError(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
concatDelayError(ObservableSource<? extends ObservableSource<? extends T>>, int, boolean) - Static method in class io.reactivex.observable.Observable: Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
concatEager(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Concatenates a sequence of MaybeSources eagerly into a single stream of values.
concatEager(ObservableSource<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
concatEager(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
concatEager(ObservableSource<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.observable.Observable: Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
concatEager(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Concatenates a sequence of ObservableSources eagerly into a single stream of values.
concatEager(Iterable<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.observable.Observable: Concatenates a sequence of ObservableSources eagerly into a single stream of values.
concatMap(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
concatMap(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then emitting the items that result from concatenating those resulting ObservableSources.
concatMap(Function<? super T, ? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.observable.Observable: Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then emitting the items that result from concatenating those resulting ObservableSources.
concatMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Maps each of the items into an ObservableSource, 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 ObservableSources till all of them terminate.
concatMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, int, boolean) - Method in class io.reactivex.observable.Observable: Maps each of the items into an ObservableSource, 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 ObservableSources till all of them terminate.
concatMapEager(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
concatMapEager(Function<? super T, ? extends ObservableSource<? extends R>>, int, int) - Method in class io.reactivex.observable.Observable: Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
concatMapEagerDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, boolean) - Method in class io.reactivex.observable.Observable: Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
concatMapEagerDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, int, int, boolean) - Method in class io.reactivex.observable.Observable: Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
concatMapIterable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that concatenate each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
concatMapIterable(Function<? super T, ? extends Iterable<? extends U>>, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that concatenate each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
concatWith(CompletableSource) - Method in class io.reactivex.observable.Completable: Concatenates this Completable with another Completable.
concatWith(MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: Returns an Observable that emits the items emitted from the current MaybeSource, then the next, one after the other, without interleaving them.
concatWith(ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted from the current ObservableSource, then the next, one after the other, without interleaving them.
concatWith(SingleSource<? extends T>) - Method in class io.reactivex.observable.Single: Returns an Observable that emits the item emitted by the source Single, then the item emitted by the specified Single.
connect(Consumer<? super Disposable>) - Method in class io.reactivex.observable.ConnectableObservable: Instructs the ConnectableObservable to begin emitting the items from its underlying Observable to its Observers.
connect() - Method in class io.reactivex.observable.ConnectableObservable: Instructs the ConnectableObservable to begin emitting the items from its underlying Observable to its Observers.
ConnectableObservable<T> - Class in io.reactivex.observable: A ConnectableObservable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableObservable.connect(io.reactivex.common.functions.Consumer<? super io.reactivex.common.Disposable>) method is called.
ConnectableObservable() - Constructor for class io.reactivex.observable.ConnectableObservable
contains(Object) - Method in class io.reactivex.observable.Maybe: Returns a Single that emits a Boolean that indicates whether the source Maybe emitted a specified item.
contains(Object) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits a Boolean that indicates whether the source ObservableSource emitted a specified item.
contains(Object) - Method in class io.reactivex.observable.Single: Signals true if the current Single signals a success value that is Object-equals with the value provided.
contains(Object, BiPredicate<Object, Object>) - Method in class io.reactivex.observable.Single: Signals true if the current Single signals a success value that is equal with the value provided by calling a bi-predicate.
count() - Method in class io.reactivex.observable.Maybe: Returns a Maybe that counts the total number of items emitted (0 or 1) by the source Maybe and emits this count as a 64-bit Long.
count() - Method in class io.reactivex.observable.Observable: Returns a Single that counts the total number of items emitted by the source ObservableSource and emits this count as a 64-bit Long.
create(CompletableOnSubscribe) - Static method in class io.reactivex.observable.Completable: Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
create(MaybeOnSubscribe<T>) - Static method in class io.reactivex.observable.Maybe: Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
create(ObservableOnSubscribe<T>) - Static method in class io.reactivex.observable.Observable: Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world.
create() - Static method in class io.reactivex.observable.observers.TestObserver: Constructs a non-forwarding TestObserver.
create(Observer<? super T>) - Static method in class io.reactivex.observable.observers.TestObserver: Constructs a forwarding TestObserver.
create(SingleOnSubscribe<T>) - Static method in class io.reactivex.observable.Single: Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
create() - Static method in class io.reactivex.observable.subjects.AsyncSubject: Creates a new AsyncProcessor.
create() - Static method in class io.reactivex.observable.subjects.BehaviorSubject: Creates a BehaviorSubject without a default item.
create() - Static method in class io.reactivex.observable.subjects.CompletableSubject: Creates a fresh CompletableSubject.
create() - Static method in class io.reactivex.observable.subjects.MaybeSubject: Creates a fresh MaybeSubject.
create() - Static method in class io.reactivex.observable.subjects.PublishSubject: Constructs a PublishSubject.
create() - Static method in class io.reactivex.observable.subjects.ReplaySubject: Creates an unbounded replay subject.
create(int) - Static method in class io.reactivex.observable.subjects.ReplaySubject: Creates an unbounded replay subject with the specified initial buffer capacity.
create() - Static method in class io.reactivex.observable.subjects.SingleSubject: Creates a fresh SingleSubject.
create() - Static method in class io.reactivex.observable.subjects.UnicastSubject: Creates an UnicastSubject with an internal buffer capacity hint 16.
create(int) - Static method in class io.reactivex.observable.subjects.UnicastSubject: Creates an UnicastSubject with the given internal buffer capacity hint.
create(int, Runnable) - Static method in class io.reactivex.observable.subjects.UnicastSubject: Creates an UnicastSubject with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription.
create(int, Runnable, boolean) - Static method in class io.reactivex.observable.subjects.UnicastSubject: Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Subscriber cancels its subscription.
create(boolean) - Static method in class io.reactivex.observable.subjects.UnicastSubject: Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag.
createComputationScheduler(ThreadFactory) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Create an instance of the default Scheduler used for Schedulers.computation() except using threadFactory for thread creation.
createDefault(T) - Static method in class io.reactivex.observable.subjects.BehaviorSubject: Creates a BehaviorSubject that emits the last item it observed and all subsequent items to each Observer that subscribes to it.
createIoScheduler(ThreadFactory) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Create an instance of the default Scheduler used for Schedulers.io() except using threadFactory for thread creation.
createNewThreadScheduler(ThreadFactory) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Create an instance of the default Scheduler used for Schedulers.newThread() except using threadFactory for thread creation.
createSingleScheduler(ThreadFactory) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Create an instance of the default Scheduler used for Schedulers.single() except using threadFactory for thread creation.
createWithSize(int) - Static method in class io.reactivex.observable.subjects.ReplaySubject: Creates a size-bounded replay subject.
createWithTime(long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.subjects.ReplaySubject: Creates a time-bounded replay subject.
createWithTimeAndSize(long, TimeUnit, Scheduler, int) - Static method in class io.reactivex.observable.subjects.ReplaySubject: Creates a time- and size-bounded replay subject.

D

debounce(Function<? super T, ? extends ObservableSource>) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by another item within a computed debounce duration.
debounce(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires.
debounce(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires on a specified Scheduler.
defaultIfEmpty(T) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the item emitted by the source Maybe or a specified default item if the source Maybe is empty.
defaultIfEmpty(T) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by the source ObservableSource or a specified default item if the source ObservableSource is empty.
DefaultObserver<T> - Class in io.reactivex.observable.observers: Abstract base implementation of an Observer with support for cancelling a subscription via DefaultObserver.cancel() (synchronously) and calls DefaultObserver.onStart() when the subscription happens.
DefaultObserver() - Constructor for class io.reactivex.observable.observers.DefaultObserver
defer(Callable<? extends CompletableSource>) - Static method in class io.reactivex.observable.Completable: Defers the subscription to a Completable instance returned by a supplier.
defer(Callable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to be subscribed to.
defer(Callable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer that subscribes.
defer(Callable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.observable.Single: Calls a Callable for each individual SingleObserver to return the actual Single source to be subscribed to.
delay(long, TimeUnit) - Method in class io.reactivex.observable.Completable: Returns a Completable which delays the emission of the completion event by the given time.
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Completable: Returns a Completable which delays the emission of the completion event by the given time while running on the specified scheduler.
delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.observable.Completable: Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specified scheduler.
delay(long, TimeUnit) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a specified delay.
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a specified delay running on the specified Scheduler.
delay(ObservableSource) - Method in class io.reactivex.observable.Maybe: Delays the emission of this Maybe until the given ObservableSource signals an item or completes.
delay(Function<? super T, ? extends ObservableSource>) - Method in class io.reactivex.observable.Observable: Returns an Observable that delays the emissions of the source ObservableSource via another ObservableSource on a per-item basis.
delay(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
delay(long, TimeUnit, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
delay(ObservableSource, Function<? super T, ? extends ObservableSource<V>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that delays the subscription to and emissions from the source ObservableSource via another ObservableSource on a per-item basis.
delay(long, TimeUnit) - Method in class io.reactivex.observable.Single: Delays the emission of the success or error signal from the current Single by the specified amount.
delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Single: Delays the emission of the success or error signal from the current Single by the specified amount.
delaySubscription(ObservableSource) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that delays the subscription to this Maybe until the other ObservableSource emits an element or completes normally.
delaySubscription(long, TimeUnit) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that delays the subscription to the source Maybe by a given amount of time.
delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that delays the subscription to the source Maybe by a given amount of time, both waiting and subscribing on a given Scheduler.
delaySubscription(ObservableSource) - Method in class io.reactivex.observable.Observable: Returns an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.
delaySubscription(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time.
delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time, both waiting and subscribing on a given Scheduler.
delaySubscription(CompletableSource) - Method in class io.reactivex.observable.Single: Delays the actual subscription to the current Single until the given other CompletableSource completes.
delaySubscription(SingleSource) - Method in class io.reactivex.observable.Single: Delays the actual subscription to the current Single until the given other SingleSource signals success.
delaySubscription(ObservableSource) - Method in class io.reactivex.observable.Single: Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.
delaySubscription(long, TimeUnit) - Method in class io.reactivex.observable.Single: Delays the actual subscription to the current Single until the given time delay elapsed.
delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Single: Delays the actual subscription to the current Single until the given time delay elapsed.
dematerialize() - Method in class io.reactivex.observable.Observable: Returns an Observable that reverses the effect of materialize by transforming the Notification objects emitted by the source ObservableSource into the items or notifications they represent.
DisposableCompletableObserver - Class in io.reactivex.observable.observers: An abstract CompletableObserver that allows asynchronous cancellation by implementing Disposable.
DisposableCompletableObserver() - Constructor for class io.reactivex.observable.observers.DisposableCompletableObserver
DisposableMaybeObserver<T> - Class in io.reactivex.observable.observers: An abstract MaybeObserver that allows asynchronous cancellation by implementing Disposable.
DisposableMaybeObserver() - Constructor for class io.reactivex.observable.observers.DisposableMaybeObserver
DisposableObserver<T> - Class in io.reactivex.observable.observers: An abstract Observer that allows asynchronous cancellation by implementing Disposable.
DisposableObserver() - Constructor for class io.reactivex.observable.observers.DisposableObserver
DisposableSingleObserver<T> - Class in io.reactivex.observable.observers: An abstract SingleObserver that allows asynchronous cancellation by implementing Disposable.
DisposableSingleObserver() - Constructor for class io.reactivex.observable.observers.DisposableSingleObserver
dispose() - Method in class io.reactivex.observable.observers.DisposableCompletableObserver
dispose() - Method in class io.reactivex.observable.observers.DisposableMaybeObserver
dispose() - Method in class io.reactivex.observable.observers.DisposableObserver
dispose() - Method in class io.reactivex.observable.observers.DisposableSingleObserver
dispose() - Method in class io.reactivex.observable.observers.ResourceCompletableObserver: Cancels the main disposable (if any) and disposes the resources associated with this ResourceObserver (if any).
dispose() - Method in class io.reactivex.observable.observers.ResourceMaybeObserver: Cancels the main disposable (if any) and disposes the resources associated with this ResourceObserver (if any).
dispose() - Method in class io.reactivex.observable.observers.ResourceObserver: Cancels the main disposable (if any) and disposes the resources associated with this ResourceObserver (if any).
dispose() - Method in class io.reactivex.observable.observers.ResourceSingleObserver: Cancels the main disposable (if any) and disposes the resources associated with this ResourceObserver (if any).
dispose() - Method in class io.reactivex.observable.observers.SafeObserver
dispose() - Method in class io.reactivex.observable.observers.SerializedObserver
dispose() - Method in class io.reactivex.observable.observers.TestObserver
distinct() - Method in class io.reactivex.observable.Observable: Returns an Observable that emits all items emitted by the source ObservableSource that are distinct.
distinct(Function<? super T, K>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function.
distinct(Function<? super T, K>, Callable<? extends Collection<? super K>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function.
distinctUntilChanged() - Method in class io.reactivex.observable.Observable: Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors.
distinctUntilChanged(Function<? super T, K>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors, according to a key selector function.
distinctUntilChanged(BiPredicate<? super T, ? super T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
doAfterNext(Consumer<? super T>) - Method in class io.reactivex.observable.Observable: Calls the specified consumer with the current item after this item has been emitted to the downstream.
doAfterSuccess(Consumer<? super T>) - Method in class io.reactivex.observable.Maybe: Calls the specified consumer with the success item after this item has been emitted to the downstream.
doAfterSuccess(Consumer<? super T>) - Method in class io.reactivex.observable.Single: Calls the specified consumer with the success item after this item has been emitted to the downstream.
doAfterTerminate(Action) - Method in class io.reactivex.observable.Completable: Returns a Completable instance that calls the given onTerminate callback after this Completable completes normally or with an exception Scheduler: doAfterTerminate does not operate by default on a particular Scheduler.
doAfterTerminate(Action) - Method in class io.reactivex.observable.Maybe: Registers an Action to be called when this Maybe invokes either onSuccess, onComplete or onError.
doAfterTerminate(Action) - Method in class io.reactivex.observable.Observable: Registers an Action to be called when this ObservableSource invokes either onComplete or onError.
doAfterTerminate(Action) - Method in class io.reactivex.observable.Single: Registers an Action to be called after this Single invokes either onSuccess or onError
doFinally(Action) - Method in class io.reactivex.observable.Completable: Calls the specified action after this Completable signals onError or onComplete or gets disposed by the downstream.
doFinally(Action) - Method in class io.reactivex.observable.Maybe: Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by the downstream.
doFinally(Action) - Method in class io.reactivex.observable.Observable: Calls the specified action after this Observable signals onError or onCompleted or gets disposed by the downstream.
doFinally(Action) - Method in class io.reactivex.observable.Single: Calls the specified action after this Single signals onSuccess or onError or gets disposed by the downstream.
doOnComplete(Action) - Method in class io.reactivex.observable.Completable: Returns a Completable which calls the given onComplete callback if this Completable completes.
doOnComplete(Action) - Method in class io.reactivex.observable.Maybe: Modifies the source Maybe so that it invokes an action when it calls onComplete.
doOnComplete(Action) - Method in class io.reactivex.observable.Observable: Modifies the source ObservableSource so that it invokes an action when it calls onComplete.
doOnDispose(Action) - Method in class io.reactivex.observable.Completable: Returns a Completable which calls the given onDispose callback if the child subscriber cancels the subscription.
doOnDispose(Action) - Method in class io.reactivex.observable.Maybe: Calls the shared runnable if a MaybeObserver subscribed to the current Maybe disposes the common Disposable it received via onSubscribe.
doOnDispose(Action) - Method in class io.reactivex.observable.Observable: Calls the dispose Action if the downstream disposes the sequence.
doOnDispose(Action) - Method in class io.reactivex.observable.Single: Calls the shared runnable if a SingleObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.
doOnEach(Consumer<? super Notification<T>>) - Method in class io.reactivex.observable.Observable: Modifies the source ObservableSource so that it invokes an action for each item it emits.
doOnEach(Observer<? super T>) - Method in class io.reactivex.observable.Observable: Modifies the source ObservableSource so that it notifies an Observer for each item and terminal event it emits.
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.observable.Completable: Returns a Completable which calls the given onError callback if this Completable emits an error.
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.observable.Maybe: Calls the shared consumer with the error sent via onError for each MaybeObserver that subscribes to the current Maybe.
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.observable.Observable: Modifies the source ObservableSource so that it invokes an action if it calls onError.
doOnError(Consumer<? super Throwable>) - Method in class io.reactivex.observable.Single: Calls the shared consumer with the error sent via onError for each SingleObserver that subscribes to the current Single.
doOnEvent(Consumer<? super Throwable>) - Method in class io.reactivex.observable.Completable: Returns a Completable which calls the given onEvent callback with the (throwable) for an onError or (null) for an onComplete signal from this Completable before delivering said signal to the downstream.
doOnEvent(BiConsumer<? super T, ? super Throwable>) - Method in class io.reactivex.observable.Maybe: Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwable) for an onError or (null, null) for an onComplete signal from this Maybe before delivering said signal to the downstream.
doOnEvent(BiConsumer<? super T, ? super Throwable>) - Method in class io.reactivex.observable.Single: Calls the shared consumer with the error sent via onError or the value via onSuccess for each SingleObserver that subscribes to the current Single.
doOnLifecycle(Consumer<? super Disposable>, Action) - Method in class io.reactivex.observable.Observable: Calls the appropriate onXXX method (shared between all Observer) for the lifecycle events of the sequence (subscription, cancellation, requesting).
doOnNext(Consumer<? super T>) - Method in class io.reactivex.observable.Observable: Modifies the source ObservableSource so that it invokes an action when it calls onNext.
doOnSubscribe(Consumer<? super Disposable>) - Method in class io.reactivex.observable.Completable: Returns a Completable instance that calls the given onSubscribe callback with the disposable that child subscribers receive on subscription.
doOnSubscribe(Consumer<? super Disposable>) - Method in class io.reactivex.observable.Maybe: Calls the shared consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Maybe.
doOnSubscribe(Consumer<? super Disposable>) - Method in class io.reactivex.observable.Observable: Modifies the source ObservableSource so that it invokes the given action when it is subscribed from its subscribers.
doOnSubscribe(Consumer<? super Disposable>) - Method in class io.reactivex.observable.Single: Calls the shared consumer with the Disposable sent through the onSubscribe for each SingleObserver that subscribes to the current Single.
doOnSuccess(Consumer<? super T>) - Method in class io.reactivex.observable.Maybe: Calls the shared consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Maybe.
doOnSuccess(Consumer<? super T>) - Method in class io.reactivex.observable.Single: Calls the shared consumer with the success value sent via onSuccess for each SingleObserver that subscribes to the current Single.
doOnTerminate(Action) - Method in class io.reactivex.observable.Completable: Returns a Completable instance that calls the given onTerminate callback just before this Completable completes normally or with an exception Scheduler: doOnTerminate does not operate by default on a particular Scheduler.
doOnTerminate(Action) - Method in class io.reactivex.observable.Observable: Modifies the source ObservableSource so that it invokes an action when it calls onComplete or onError.

E

elementAt(long) - Method in class io.reactivex.observable.Observable: Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Observable or completes if this Observable signals fewer elements than index.
elementAt(long, T) - Method in class io.reactivex.observable.Observable: Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable, or a default item if that index is out of range.
elementAtOrError(long) - Method in class io.reactivex.observable.Observable: Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable or signals a NoSuchElementException if this Observable signals fewer elements than index.
empty() - Static method in class io.reactivex.observable.Maybe: Returns a (singleton) Maybe instance that calls onComplete immediately.
empty() - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits no items to the Observer and immediately invokes its onComplete method.
equals(SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.observable.Single: Compares two SingleSources and emits true if they emit the same value (compared via Object.equals).
error(Callable<? extends Throwable>) - Static method in class io.reactivex.observable.Completable: Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.
error(Throwable) - Static method in class io.reactivex.observable.Completable: Creates a Completable instance that emits the given Throwable exception to subscribers.
error(Throwable) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that invokes a subscriber's onError method when the subscriber subscribes to it.
error(Callable<? extends Throwable>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that invokes a MaybeObserver's onError method when the MaybeObserver subscribes to it.
error(Callable<? extends Throwable>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.
error(Throwable) - Static method in class io.reactivex.observable.Observable: Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.
error(Callable<? extends Throwable>) - Static method in class io.reactivex.observable.Single: Signals a Throwable returned by the callback function for each individual SingleObserver.
error(Throwable) - Static method in class io.reactivex.observable.Single: Returns a Single that invokes a subscriber's onError method when the subscriber subscribes to it.

F

filter(Predicate<? super T>) - Method in class io.reactivex.observable.Maybe: Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.
filter(Predicate<? super T>) - Method in class io.reactivex.observable.Observable: Filters items emitted by an ObservableSource by only emitting those that satisfy a specified predicate.
filter(Predicate<? super T>) - Method in class io.reactivex.observable.Single: Filters the success item of the Single via a predicate function and emitting it if the predicate returns true, completing otherwise.
first(T) - Method in class io.reactivex.observable.Observable: Returns a Single that emits only the very first item emitted by the source ObservableSource, or a default item if the source ObservableSource completes without emitting any items.
firstElement() - Method in class io.reactivex.observable.Observable: Returns a Maybe that emits only the very first item emitted by the source ObservableSource, or completes if the source ObservableSource is empty.
firstOrError() - Method in class io.reactivex.observable.Observable: Returns a Single that emits only the very first item emitted by this Observable or signals a NoSuchElementException if this Observable is empty.
flatMap(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
flatMap(Function<? super T, ? extends MaybeSource<? extends R>>, Function<? super Throwable, ? extends MaybeSource<? extends R>>, Callable<? extends MaybeSource<? extends R>>) - Method in class io.reactivex.observable.Maybe: Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that MaybeSource's signals Scheduler: flatMap does not operate by default on a particular Scheduler.
flatMap(Function<? super T, ? extends MaybeSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified function to the pair of values emitted by the source Maybe and a specified mapped MaybeSource.
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, boolean, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, boolean, int, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, Function<? super Throwable, ? extends ObservableSource<? extends R>>, Callable<? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items.
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, Function<Throwable, ? extends ObservableSource<? extends R>>, Callable<? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
flatMap(Function<? super T, ? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource.
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource.
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, boolean, int, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
flatMap(Function<? super T, ? extends ObservableSource<? extends U>>, BiFunction<? super T, ? super U, ? extends R>, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
flatMap(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.observable.Single: Returns a Single that is based on applying a specified function to the item emitted by the source Single, where that function returns a SingleSource.
flatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.observable.Maybe: Returns a Completable that completes based on applying a specified function to the item emitted by the source Maybe, where that function returns a Completable.
flatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.observable.Observable: Maps each element of the upstream Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
flatMapCompletable(Function<? super T, ? extends CompletableSource>, boolean) - Method in class io.reactivex.observable.Observable: Maps each element of the upstream Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
flatMapCompletable(Function<? super T, ? extends CompletableSource>) - Method in class io.reactivex.observable.Single: Returns a Completable that completes based on applying a specified function to the item emitted by the source Single, where that function returns a Completable.
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that merges each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
flatMapIterable(Function<? super T, ? extends Iterable<? extends U>>, BiFunction<? super T, ? super U, ? extends V>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of applying a function to the pair of values from the source ObservableSource and an Iterable corresponding to that item that is generated by a selector.
flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Maps each element of the upstream Observable into MaybeSources, subscribes to them and waits until the upstream and all MaybeSources complete.
flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>, boolean) - Method in class io.reactivex.observable.Observable: Maps each element of the upstream Observable into MaybeSources, subscribes to them and waits until the upstream and all MaybeSources complete, optionally delaying all errors.
flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>>) - Method in class io.reactivex.observable.Single: Returns a Maybe that is based on applying a specified function to the item emitted by the source Single, where that function returns a MaybeSource.
flatMapObservable(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Maybe: Returns an Observable that is based on applying a specified function to the item emitted by the source Maybe, where that function returns an ObservableSource.
flatMapObservable(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Single: Returns an Observable that is based on applying a specified function to the item emitted by the source Single, where that function returns a SingleSource.
flatMapObservableSource(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Single: Returns an Observable that emits items based on applying a specified function to the item emitted by the source Single, where that function returns an ObservableSource.
flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.observable.Maybe: Returns a Single based on applying a specified function to the item emitted by the source Maybe, where that function returns a Single.
flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Maps each element of the upstream Observable into SingleSources, subscribes to them and waits until the upstream and all SingleSources complete.
flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>>, boolean) - Method in class io.reactivex.observable.Observable: Maps each element of the upstream Observable into SingleSources, subscribes to them and waits until the upstream and all SingleSources complete, optionally delaying all errors.
flatMapSingleElement(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe based on applying a specified function to the item emitted by the source Maybe, where that function returns a Single.
flattenAsObservable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.observable.Maybe: Returns an Observable that maps a success value into an Iterable and emits its items.
flattenAsObservable(Function<? super T, ? extends Iterable<? extends U>>) - Method in class io.reactivex.observable.Single: Returns an Observable that maps a success value into an Iterable and emits its items.
forEach(Consumer<? super T>) - Method in class io.reactivex.observable.Observable: Subscribes to the ObservableSource and receives notifications for each element.
forEachWhile(Predicate<? super T>) - Method in class io.reactivex.observable.Observable: Subscribes to the ObservableSource and receives notifications for each element until the onNext Predicate returns false.
forEachWhile(Predicate<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.observable.Observable: Subscribes to the ObservableSource and receives notifications for each element and error events until the onNext Predicate returns false.
forEachWhile(Predicate<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.observable.Observable: Subscribes to the ObservableSource and receives notifications for each element and the terminal events until the onNext Predicate returns false.
fromAction(Action) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that runs the given Action for each subscriber and emits either an unchecked exception or simply completes.
fromAction(Action) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
fromArray(T...) - Static method in class io.reactivex.observable.Observable: Converts an Array into an ObservableSource that emits the items in the Array.
fromCallable(Callable<?>) - Static method in class io.reactivex.observable.Completable: Returns a Completable which when subscribed, executes the callable function, ignores its normal result and emits onError or onComplete only.
fromCallable(Callable<? extends T>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that invokes passed function and emits its result for each new MaybeObserver that subscribes while considering null value from the callable as indication for valueless completion.
fromCallable(Callable<? extends T>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.
fromCallable(Callable<? extends T>) - Static method in class io.reactivex.observable.Single: Returns a Single that invokes passed function and emits its result for each new SingleObserver that subscribes.
fromCompletable(CompletableSource) - Static method in class io.reactivex.observable.Maybe: Wraps a CompletableSource into a Maybe.
fromFuture(Future<?>) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
fromFuture(Future<? extends T>) - Static method in class io.reactivex.observable.Maybe: Converts a Future into a Maybe, treating a null result as an indication of emptiness.
fromFuture(Future<? extends T>, long, TimeUnit) - Static method in class io.reactivex.observable.Maybe: Converts a Future into a Maybe, with a timeout on the Future.
fromFuture(Future<? extends T>) - Static method in class io.reactivex.observable.Observable: Converts a Future into an ObservableSource.
fromFuture(Future<? extends T>, long, TimeUnit) - Static method in class io.reactivex.observable.Observable: Converts a Future into an ObservableSource, with a timeout on the Future.
fromFuture(Future<? extends T>, long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Observable: Converts a Future into an ObservableSource, with a timeout on the Future.
fromFuture(Future<? extends T>, Scheduler) - Static method in class io.reactivex.observable.Observable: Converts a Future, operating on a specified Scheduler, into an ObservableSource.
fromFuture(Future<? extends T>) - Static method in class io.reactivex.observable.Single: Converts a Future into a Single.
fromFuture(Future<? extends T>, long, TimeUnit) - Static method in class io.reactivex.observable.Single: Converts a Future into a Single, with a timeout on the Future.
fromFuture(Future<? extends T>, long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Single: Converts a Future into a Single, with a timeout on the Future.
fromFuture(Future<? extends T>, Scheduler) - Static method in class io.reactivex.observable.Single: Converts a Future, operating on a specified Scheduler, into a Single.
fromIterable(Iterable<? extends T>) - Static method in class io.reactivex.observable.Observable: Converts an Iterable sequence into an ObservableSource that emits the items in the sequence.
fromObservable(ObservableSource<T>) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that subscribes to the given Observable, ignores all values and emits only the terminal event.
fromObservable(ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Single: Wraps a specific ObservableSource into a Single and signals its single element or error.
fromRunnable(Runnable) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that runs the given Runnable for each subscriber and emits either its exception or simply completes.
fromRunnable(Runnable) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
fromSingle(SingleSource<T>) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that when subscribed to, subscribes to the Single instance and emits a completion event if the single emits onSuccess or forwards any onError events.
fromSingle(SingleSource<T>) - Static method in class io.reactivex.observable.Maybe: Wraps a SingleSource into a Maybe.
FuseToMaybe<T> - Interface in io.reactivex.observable.extensions: Interface indicating an operator implementation can be macro-fused back to Maybe in case the operator goes from Maybe to some other reactive type and then the sequence calls for toMaybe again: Single<Integer> single = Maybe.just(1).isEmpty(); Maybe<Integer> maybe = single.toMaybe(); The Single.toMaybe() will check for this interface and call the FuseToMaybe.fuseToMaybe() to return a Maybe which could be the Maybe-specific implementation of isEmpty().
fuseToMaybe() - Method in interface io.reactivex.observable.extensions.FuseToMaybe: Returns a (direct) Maybe for the operator.
FuseToObservable<T> - Interface in io.reactivex.observable.extensions: Interface indicating a operator implementation can be macro-fused back to Observable in case the operator goes from Observable to some other reactive type and then the sequence calls for toObservable again: Single<Integer> single = Observable.range(1, 10).reduce((a, b) -> a + b); Observable<Integer> observable = single.toObservable(); The Single.toObservable() will check for this interface and call the FuseToObservable.fuseToObservable() to return an Observable which could be the Observable-specific implementation of reduce(BiFunction).
fuseToObservable() - Method in interface io.reactivex.observable.extensions.FuseToObservable: Returns a (direct) Observable for the operator.

G

generate(Consumer<Emitter<T>>) - Static method in class io.reactivex.observable.Observable: Returns a cold, synchronous and stateless generator of values.
generate(Callable<S>, BiConsumer<S, Emitter<T>>) - Static method in class io.reactivex.observable.Observable: Returns a cold, synchronous and stateful generator of values.
generate(Callable<S>, BiConsumer<S, Emitter<T>>, Consumer<? super S>) - Static method in class io.reactivex.observable.Observable: Returns a cold, synchronous and stateful generator of values.
generate(Callable<S>, BiFunction<S, Emitter<T>, S>) - Static method in class io.reactivex.observable.Observable: Returns a cold, synchronous and stateful generator of values.
generate(Callable<S>, BiFunction<S, Emitter<T>, S>, Consumer<? super S>) - Static method in class io.reactivex.observable.Observable: Returns a cold, synchronous and stateful generator of values.
getKey() - Method in class io.reactivex.observable.GroupedObservable: Returns the key that identifies the group of items emitted by this GroupedObservable.
getOnCompletableAssembly() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getOnCompletableSubscribe() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getOnConnectableObservableAssembly() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getOnMaybeAssembly() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getOnMaybeSubscribe() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getOnObservableAssembly() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getOnObservableSubscribe() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getOnSingleAssembly() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getOnSingleSubscribe() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns the current hook function.
getThrowable() - Method in class io.reactivex.observable.subjects.AsyncSubject
getThrowable() - Method in class io.reactivex.observable.subjects.BehaviorSubject
getThrowable() - Method in class io.reactivex.observable.subjects.CompletableSubject: Returns the terminal error if this CompletableSubject has been terminated with an error, null otherwise.
getThrowable() - Method in class io.reactivex.observable.subjects.MaybeSubject: Returns the terminal error if this MaybeSubject has been terminated with an error, null otherwise.
getThrowable() - Method in class io.reactivex.observable.subjects.PublishSubject
getThrowable() - Method in class io.reactivex.observable.subjects.ReplaySubject
getThrowable() - Method in class io.reactivex.observable.subjects.SingleSubject: Returns the terminal error if this SingleSubject has been terminated with an error, null otherwise.
getThrowable() - Method in class io.reactivex.observable.subjects.Subject: Returns the error that caused the Subject to terminate or null if the Subject hasn't terminated yet.
getThrowable() - Method in class io.reactivex.observable.subjects.UnicastSubject
getValue() - Method in class io.reactivex.observable.subjects.AsyncSubject: Returns a single value the Subject currently has or null if no such value exists.
getValue() - Method in class io.reactivex.observable.subjects.BehaviorSubject: Returns a single value the Subject currently has or null if no such value exists.
getValue() - Method in class io.reactivex.observable.subjects.MaybeSubject: Returns the success value if this MaybeSubject was terminated with a success value.
getValue() - Method in class io.reactivex.observable.subjects.ReplaySubject: Returns a single value the Subject currently has or null if no such value exists.
getValue() - Method in class io.reactivex.observable.subjects.SingleSubject: Returns the success value if this SingleSubject was terminated with a success value.
getValues() - Method in class io.reactivex.observable.subjects.AsyncSubject: Returns an Object array containing snapshot all values of the Subject.
getValues(T[]) - Method in class io.reactivex.observable.subjects.AsyncSubject: Returns a typed array containing a snapshot of all values of the Subject.
getValues() - Method in class io.reactivex.observable.subjects.BehaviorSubject: Returns an Object array containing snapshot all values of the Subject.
getValues(T[]) - Method in class io.reactivex.observable.subjects.BehaviorSubject: Returns a typed array containing a snapshot of all values of the Subject.
getValues() - Method in class io.reactivex.observable.subjects.ReplaySubject: Returns an Object array containing snapshot all values of the Subject.
getValues(T[]) - Method in class io.reactivex.observable.subjects.ReplaySubject: Returns a typed array containing a snapshot of all values of the Subject.
groupBy(Function<? super T, ? extends K>) - Method in class io.reactivex.observable.Observable: Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
groupBy(Function<? super T, ? extends K>, boolean) - Method in class io.reactivex.observable.Observable: Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.observable.Observable: Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, boolean) - Method in class io.reactivex.observable.Observable: Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, boolean, int) - Method in class io.reactivex.observable.Observable: Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
GroupedObservable<K,T> - Class in io.reactivex.observable: An Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().
GroupedObservable(K) - Constructor for class io.reactivex.observable.GroupedObservable: Constructs a GroupedObservable with the given key.
groupJoin(ObservableSource<? extends TRight>, Function<? super T, ? extends ObservableSource<TLeftEnd>>, Function<? super TRight, ? extends ObservableSource<TRightEnd>>, BiFunction<? super T, ? super Observable<TRight>, ? extends R>) - Method in class io.reactivex.observable.Observable: Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.

H

hasComplete() - Method in class io.reactivex.observable.subjects.AsyncSubject
hasComplete() - Method in class io.reactivex.observable.subjects.BehaviorSubject
hasComplete() - Method in class io.reactivex.observable.subjects.CompletableSubject: Returns true if this CompletableSubject has been completed.
hasComplete() - Method in class io.reactivex.observable.subjects.MaybeSubject: Returns true if this MaybeSubject has been completed.
hasComplete() - Method in class io.reactivex.observable.subjects.PublishSubject
hasComplete() - Method in class io.reactivex.observable.subjects.ReplaySubject
hasComplete() - Method in class io.reactivex.observable.subjects.Subject: Returns true if the subject has reached a terminal state through a complete event.
hasComplete() - Method in class io.reactivex.observable.subjects.UnicastSubject
hasObservers() - Method in class io.reactivex.observable.subjects.AsyncSubject
hasObservers() - Method in class io.reactivex.observable.subjects.BehaviorSubject
hasObservers() - Method in class io.reactivex.observable.subjects.CompletableSubject: Returns true if this CompletableSubject has observers.
hasObservers() - Method in class io.reactivex.observable.subjects.MaybeSubject: Returns true if this MaybeSubject has observers.
hasObservers() - Method in class io.reactivex.observable.subjects.PublishSubject
hasObservers() - Method in class io.reactivex.observable.subjects.ReplaySubject
hasObservers() - Method in class io.reactivex.observable.subjects.SingleSubject: Returns true if this SingleSubject has observers.
hasObservers() - Method in class io.reactivex.observable.subjects.Subject: Returns true if the subject has any Observers.
hasObservers() - Method in class io.reactivex.observable.subjects.UnicastSubject
hasSubscription() - Method in class io.reactivex.observable.observers.TestObserver: Returns true if this TestObserver received a subscription.
hasThrowable() - Method in class io.reactivex.observable.subjects.AsyncSubject
hasThrowable() - Method in class io.reactivex.observable.subjects.BehaviorSubject
hasThrowable() - Method in class io.reactivex.observable.subjects.CompletableSubject: Returns true if this CompletableSubject has been terminated with an error.
hasThrowable() - Method in class io.reactivex.observable.subjects.MaybeSubject: Returns true if this MaybeSubject has been terminated with an error.
hasThrowable() - Method in class io.reactivex.observable.subjects.PublishSubject
hasThrowable() - Method in class io.reactivex.observable.subjects.ReplaySubject
hasThrowable() - Method in class io.reactivex.observable.subjects.SingleSubject: Returns true if this SingleSubject has been terminated with an error.
hasThrowable() - Method in class io.reactivex.observable.subjects.Subject: Returns true if the subject has reached a terminal state through an error event.
hasThrowable() - Method in class io.reactivex.observable.subjects.UnicastSubject
HasUpstreamCompletableSource - Interface in io.reactivex.observable.extensions: Interface indicating the implementor has an upstream CompletableSource-like source available via HasUpstreamCompletableSource.source() method.
HasUpstreamMaybeSource<T> - Interface in io.reactivex.observable.extensions: Interface indicating the implementor has an upstream MaybeSource-like source available via HasUpstreamMaybeSource.source() method.
HasUpstreamObservableSource<T> - Interface in io.reactivex.observable.extensions: Interface indicating the implementor has an upstream ObservableSource-like source available via HasUpstreamObservableSource.source() method.
HasUpstreamSingleSource<T> - Interface in io.reactivex.observable.extensions: Interface indicating the implementor has an upstream SingleSource-like source available via HasUpstreamSingleSource.source() method.
hasValue() - Method in class io.reactivex.observable.subjects.AsyncSubject: Returns true if the subject has any value.
hasValue() - Method in class io.reactivex.observable.subjects.BehaviorSubject: Returns true if the subject has any value.
hasValue() - Method in class io.reactivex.observable.subjects.MaybeSubject: Returns true if this MaybeSubject was terminated with a success value.
hasValue() - Method in class io.reactivex.observable.subjects.ReplaySubject: Returns true if the subject has any value.
hasValue() - Method in class io.reactivex.observable.subjects.SingleSubject: Returns true if this SingleSubject was terminated with a success value.
hide() - Method in class io.reactivex.observable.Completable: Hides the identity of this Completable and its Disposable.
hide() - Method in class io.reactivex.observable.Maybe: Hides the identity of this Maybe and its Disposable.
hide() - Method in class io.reactivex.observable.Observable: Hides the identity of this Observable and its Disposable.
hide() - Method in class io.reactivex.observable.Single: Hides the identity of the current Single, including the Disposable that is sent to the downstream via onSubscribe().

I

ignoreElement() - Method in class io.reactivex.observable.Maybe: Ignores the item emitted by the source Maybe and only calls onComplete or onError.
ignoreElements() - Method in class io.reactivex.observable.Observable: Ignores all items emitted by the source ObservableSource and only calls onComplete or onError.
interval(long, long, TimeUnit) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter.
interval(long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter, on a specified Scheduler.
interval(long, TimeUnit) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits a sequential number every specified interval of time.
interval(long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.
intervalRange(long, long, long, long, TimeUnit) - Static method in class io.reactivex.observable.Observable: Signals a range of long values, the first after some initial delay and the rest periodically after.
intervalRange(long, long, long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Observable: Signals a range of long values, the first after some initial delay and the rest periodically after.
io.reactivex.observable - package io.reactivex.observable: Base reactive classes: Flowable, Observable, Single and Completable; base reactive consumers; other common base interfaces.
io.reactivex.observable.extensions - package io.reactivex.observable.extensions: Base interfaces and types for supporting operator-fusion.
io.reactivex.observable.observers - package io.reactivex.observable.observers: Default wrappers and implementations for Observer-based consumer classes and interfaces; utility classes for creating them from callbacks.
io.reactivex.observable.subjects - package io.reactivex.observable.subjects: Classes extending the Observable base reactive class and implementing the Observer interface at the same time (aka hot Observables).
isCancelled() - Method in class io.reactivex.observable.observers.TestObserver: Returns true if this TestObserver has been cancelled.
isDisposed() - Method in interface io.reactivex.observable.CompletableEmitter: Returns true if the downstream disposed the sequence.
isDisposed() - Method in interface io.reactivex.observable.MaybeEmitter: Returns true if the downstream cancelled the sequence.
isDisposed() - Method in interface io.reactivex.observable.ObservableEmitter: Returns true if the downstream disposed the sequence.
isDisposed() - Method in class io.reactivex.observable.observers.DisposableCompletableObserver
isDisposed() - Method in class io.reactivex.observable.observers.DisposableMaybeObserver
isDisposed() - Method in class io.reactivex.observable.observers.DisposableObserver
isDisposed() - Method in class io.reactivex.observable.observers.DisposableSingleObserver
isDisposed() - Method in class io.reactivex.observable.observers.ResourceCompletableObserver: Returns true if this ResourceObserver has been disposed/cancelled.
isDisposed() - Method in class io.reactivex.observable.observers.ResourceMaybeObserver: Returns true if this ResourceObserver has been disposed/cancelled.
isDisposed() - Method in class io.reactivex.observable.observers.ResourceObserver: Returns true if this ResourceObserver has been disposed/cancelled.
isDisposed() - Method in class io.reactivex.observable.observers.ResourceSingleObserver: Returns true if this ResourceObserver has been disposed/cancelled.
isDisposed() - Method in class io.reactivex.observable.observers.SafeObserver
isDisposed() - Method in class io.reactivex.observable.observers.SerializedObserver
isDisposed() - Method in class io.reactivex.observable.observers.TestObserver
isDisposed() - Method in interface io.reactivex.observable.SingleEmitter: Returns true if the downstream cancelled the sequence.
isEmpty() - Method in interface io.reactivex.observable.extensions.SimpleQueue: Returns true if the queue is empty.
isEmpty() - Method in class io.reactivex.observable.Maybe: Returns a Single that emits true if the source Maybe is empty, otherwise false.
isEmpty() - Method in class io.reactivex.observable.Observable: Returns an Observable that emits true if the source ObservableSource is empty, otherwise false.
isLockdown() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Returns true if the plugins were locked down.

J

join(ObservableSource<? extends TRight>, Function<? super T, ? extends ObservableSource<TLeftEnd>>, Function<? super TRight, ? extends ObservableSource<TRightEnd>>, BiFunction<? super T, ? super TRight, ? extends R>) - Method in class io.reactivex.observable.Observable: Correlates the items emitted by two ObservableSources based on overlapping durations.
just(T) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits a specified item.
just(T) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits a single item and then completes.
just(T, T) - Static method in class io.reactivex.observable.Observable: Converts two items into an ObservableSource that emits those items.
just(T, T, T) - Static method in class io.reactivex.observable.Observable: Converts three items into an ObservableSource that emits those items.
just(T, T, T, T) - Static method in class io.reactivex.observable.Observable: Converts four items into an ObservableSource that emits those items.
just(T, T, T, T, T) - Static method in class io.reactivex.observable.Observable: Converts five items into an ObservableSource that emits those items.
just(T, T, T, T, T, T) - Static method in class io.reactivex.observable.Observable: Converts six items into an ObservableSource that emits those items.
just(T, T, T, T, T, T, T) - Static method in class io.reactivex.observable.Observable: Converts seven items into an ObservableSource that emits those items.
just(T, T, T, T, T, T, T, T) - Static method in class io.reactivex.observable.Observable: Converts eight items into an ObservableSource that emits those items.
just(T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.observable.Observable: Converts nine items into an ObservableSource that emits those items.
just(T, T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.observable.Observable: Converts ten items into an ObservableSource that emits those items.
just(T) - Static method in class io.reactivex.observable.Single: Returns a Single that emits a specified item.

L

last(T) - Method in class io.reactivex.observable.Observable: Returns a Single that emits only the last item emitted by this Observable, or a default item if this Observable completes without emitting any items.
lastElement() - Method in class io.reactivex.observable.Observable: Returns a Maybe that emits the last item emitted by this Observable or completes if this Observable is empty.
lastOrError() - Method in class io.reactivex.observable.Observable: Returns a Single that emits only the last item emitted by this Observable or signals a NoSuchElementException if this Observable is empty.
lift(CompletableOperator) - Method in class io.reactivex.observable.Completable: Advanced use without safeguards: lifts a CompletableOperator transformation into the chain of Completables.
lift(MaybeOperator<? extends R, ? super T>) - Method in class io.reactivex.observable.Maybe: Lifts a function to the current Maybe and returns a new Maybe that when subscribed to will pass the values of the current Maybe through the MaybeOperator function.
lift(ObservableOperator<? extends R, ? super T>) - Method in class io.reactivex.observable.Observable: This method requires advanced knowledge about building operators; please consider other standard composition methods first; Lifts a function to the current ObservableSource and returns a new ObservableSource that when subscribed to will pass the values of the current ObservableSource through the Operator function.
lift(SingleOperator<? extends R, ? super T>) - Method in class io.reactivex.observable.Single: 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.
lockdown() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Prevents changing the plugins from then on.

M

map(Function<? super T, ? extends R>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that applies a specified function to the item emitted by the source Maybe and emits the result of this function application.
map(Function<? super T, ? extends R>) - Method in class io.reactivex.observable.Observable: Returns an Observable that applies a specified function to each item emitted by the source ObservableSource and emits the results of these function applications.
map(Function<? super T, ? extends R>) - Method in class io.reactivex.observable.Single: Returns a Single that applies a specified function to the item emitted by the source Single and emits the result of this function application.
materialize() - Method in class io.reactivex.observable.Observable: Returns an Observable that represents all of the emissions and notifications from the source ObservableSource into emissions marked with their original types within Notification objects.
Maybe<T> - Class in io.reactivex.observable: Represents a deferred computation and emission of a maybe value or exception.
Maybe() - Constructor for class io.reactivex.observable.Maybe
MaybeEmitter<T> - Interface in io.reactivex.observable: Abstraction over an RxJava MaybeObserver that allows associating a resource with it.
MaybeObserver<T> - Interface in io.reactivex.observable: Provides a mechanism for receiving push-based notifications.
MaybeOnSubscribe<T> - Interface in io.reactivex.observable: A functional interface that has a subscribe() method that receives an instance of a MaybeEmitter instance that allows pushing an event in a cancellation-safe manner.
MaybeOperator<Downstream,Upstream> - Interface in io.reactivex.observable: Interface to map/wrap a downstream observer to an upstream observer.
MaybeSource<T> - Interface in io.reactivex.observable: Represents a basic Maybe source base interface, consumable via an MaybeObserver.
MaybeSubject<T> - Class in io.reactivex.observable.subjects: Represents a hot Maybe-like source and consumer of events similar to Subjects.
MaybeTransformer<Upstream,Downstream> - Interface in io.reactivex.observable: Interface to compose Maybes.
merge(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
merge(ObservableSource<? extends CompletableSource>) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
merge(ObservableSource<? extends CompletableSource>, int) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that keeps subscriptions to a limited number of sources at once and completes only when all source Completables complete or one of them emits an error.
merge(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Merges an Iterable sequence of MaybeSource instances into a single Observable sequence, running all MaybeSources at once.
merge(ObservableSource<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Merges an Observable sequence of MaybeSource instances into a single Observable sequence, running all MaybeSources at once.
merge(ObservableSource<? extends MaybeSource<? extends T>>, int) - Static method in class io.reactivex.observable.Maybe: Merges an Observable sequence of MaybeSource instances into a single Observable sequence, running at most maxConcurrency MaybeSources at once.
merge(MaybeSource<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Flattens a MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item emitted by the nested MaybeSource, without any transformation.
merge(MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Flattens two MaybeSources into a single Observable, without any transformation.
merge(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Flattens three MaybeSources into a single Observable, without any transformation.
merge(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Flattens four MaybeSources into a single Observable, without any transformation.
merge(Iterable<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.observable.Observable: Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
merge(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation.
merge(Iterable<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.observable.Observable: Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
merge(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Flattens an ObservableSource that emits ObservableSources into a single ObservableSource that emits the items emitted by those ObservableSources, without any transformation.
merge(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.observable.Observable: Flattens an ObservableSource that emits ObservableSources into a single ObservableSource that emits the items emitted by those ObservableSources, without any transformation, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
merge(ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Flattens two ObservableSources into a single ObservableSource, without any transformation.
merge(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Flattens three ObservableSources into a single ObservableSource, without any transformation.
merge(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Flattens four ObservableSources into a single ObservableSource, without any transformation.
merge(Iterable<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.observable.Single: Merges an Iterable sequence of SingleSource instances into a single Observable sequence, running all SingleSources at once.
merge(ObservableSource<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.observable.Single: Merges an Observable sequence of SingleSource instances into a single Observable sequence, running all SingleSources at once.
merge(SingleSource<? extends SingleSource<? extends T>>) - Static method in class io.reactivex.observable.Single: Flattens a Single that emits a Single into a single Single that emits the item emitted by the nested Single, without any transformation.
merge(SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.observable.Single: Flattens two Singles into a single Observable, without any transformation.
merge(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.observable.Single: Flattens three Singles into a single Observable, without any transformation.
merge(SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>, SingleSource<? extends T>) - Static method in class io.reactivex.observable.Single: Flattens four Singles into a single Observable, without any transformation.
mergeArray(CompletableSource...) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
mergeArray(MaybeSource<? extends T>...) - Static method in class io.reactivex.observable.Maybe: Merges an array sequence of MaybeSource instances into a single Observable sequence, running all MaybeSources at once.
mergeArray(int, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
mergeArray(ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Flattens an Array of ObservableSources into one ObservableSource, without any transformation.
mergeArrayDelayError(CompletableSource...) - Static method in class io.reactivex.observable.Completable: Returns a CompletableConsumable that subscribes to all Completables in the source array and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
mergeArrayDelayError(MaybeSource<? extends T>...) - Static method in class io.reactivex.observable.Maybe: Flattens an array of MaybeSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
mergeArrayDelayError(int, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Flattens an array of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
mergeArrayDelayError(ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
mergeDelayError(Iterable<? extends CompletableSource>) - Static method in class io.reactivex.observable.Completable: Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
mergeDelayError(ObservableSource<? extends CompletableSource>) - Static method in class io.reactivex.observable.Completable: Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
mergeDelayError(ObservableSource<? extends CompletableSource>, int) - Static method in class io.reactivex.observable.Completable: Returns a Completable that subscribes to a limited number of inner Completables at once in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
mergeDelayError(Iterable<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Flattens an Iterable of MaybeSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
mergeDelayError(ObservableSource<? extends MaybeSource<? extends T>>) - Static method in class io.reactivex.observable.Maybe: Flattens an ObservableSource that emits MaybeSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
mergeDelayError(MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Flattens two MaybeSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
mergeDelayError(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Flattens three MaybeSource into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.
mergeDelayError(MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Flattens four MaybeSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.
mergeDelayError(Iterable<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
mergeDelayError(Iterable<? extends ObservableSource<? extends T>>, int, int) - Static method in class io.reactivex.observable.Observable: Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
mergeDelayError(Iterable<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.observable.Observable: Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
mergeDelayError(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
mergeDelayError(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.observable.Observable: Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
mergeDelayError(ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Flattens two ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
mergeDelayError(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Flattens three ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
mergeDelayError(ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Flattens four ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
mergeWith(CompletableSource) - Method in class io.reactivex.observable.Completable: Returns a Completable which subscribes to this and the other Completable and completes when both of them complete or one emits an error.
mergeWith(MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: Flattens this and another Maybe into a single Observable, without any transformation.
mergeWith(ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Flattens this and another ObservableSource into a single ObservableSource, without any transformation.
mergeWith(SingleSource<? extends T>) - Method in class io.reactivex.observable.Single: Flattens this and another Single into a single Observable, without any transformation.

N

never() - Static method in class io.reactivex.observable.Completable: Returns a Completable that never calls onError or onComplete.
never() - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that never sends any items or notifications to a MaybeObserver.
never() - Static method in class io.reactivex.observable.Observable: Returns an Observable that never sends any items or notifications to an Observer.
never() - Static method in class io.reactivex.observable.Single: Returns a singleton instance of a never-signalling Single (only calls onSubscribe).
NONE - Static variable in interface io.reactivex.observable.extensions.QueueFuseable: Returned by the QueueFuseable.requestFusion(int) if the upstream doesn't support the requested mode.

O

Observable<T> - Class in io.reactivex.observable: The Observable class that is designed similar to the Reactive-Streams Pattern, minus the backpressure, and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
Observable() - Constructor for class io.reactivex.observable.Observable
ObservableEmitter<T> - Interface in io.reactivex.observable: Abstraction over an RxJava Observer that allows associating a resource with it.
ObservableOnSubscribe<T> - Interface in io.reactivex.observable: A functional interface that has a subscribe() method that receives an instance of an ObservableEmitter instance that allows pushing events in a cancellation-safe manner.
ObservableOperator<Downstream,Upstream> - Interface in io.reactivex.observable: Interface to map/wrap a downstream observer to an upstream observer.
ObservableSource<T> - Interface in io.reactivex.observable: Represents a basic, non-backpressured Observable source base interface, consumable via an Observer.
ObservableTransformer<Upstream,Downstream> - Interface in io.reactivex.observable: Interface to compose Observables.
observeOn(Scheduler) - Method in class io.reactivex.observable.Completable: Returns a Completable which emits the terminal events from the thread of the specified scheduler.
observeOn(Scheduler) - Method in class io.reactivex.observable.Maybe: Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler, asynchronously.
observeOn(Scheduler) - Method in class io.reactivex.observable.Observable: Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Observable.bufferSize() "island size".
observeOn(Scheduler, boolean) - Method in class io.reactivex.observable.Observable: Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Observable.bufferSize() "island size" and optionally delays onError notifications.
observeOn(Scheduler, boolean, int) - Method in class io.reactivex.observable.Observable: Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
observeOn(Scheduler) - Method in class io.reactivex.observable.Single: Modifies a Single to emit its item (or notify of its error) on a specified Scheduler, asynchronously.
Observer<T> - Interface in io.reactivex.observable: Provides a mechanism for receiving push-based notifications.
offer(T) - Method in interface io.reactivex.observable.extensions.SimpleQueue: Atomically enqueue a single.
offer(T, T) - Method in interface io.reactivex.observable.extensions.SimpleQueue: Atomically enqueue two values.
ofType(Class) - Method in class io.reactivex.observable.Maybe: Filters the items emitted by a Maybe, only emitting its success value if that is an instance of the supplied Class.
ofType(Class) - Method in class io.reactivex.observable.Observable: Filters the items emitted by an ObservableSource, only emitting those of the specified type.
onAssembly(Maybe<T>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onAssembly(Observable<T>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onAssembly(ConnectableObservable<T>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onAssembly(Single<T>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onAssembly(Completable) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onComplete() - Method in interface io.reactivex.observable.CompletableEmitter: Signal the completion.
onComplete() - Method in interface io.reactivex.observable.CompletableObserver: Called once the deferred computation completes normally.
onComplete() - Method in interface io.reactivex.observable.MaybeEmitter: Signal the completion.
onComplete() - Method in interface io.reactivex.observable.MaybeObserver: Called once the deferred computation completes normally.
onComplete() - Method in interface io.reactivex.observable.Observer: Notifies the Observer that the Observable has finished sending push-based notifications.
onComplete() - Method in class io.reactivex.observable.observers.SafeObserver
onComplete() - Method in class io.reactivex.observable.observers.SerializedObserver
onComplete() - Method in class io.reactivex.observable.observers.TestObserver
onComplete() - Method in class io.reactivex.observable.subjects.AsyncSubject
onComplete() - Method in class io.reactivex.observable.subjects.BehaviorSubject
onComplete() - Method in class io.reactivex.observable.subjects.CompletableSubject
onComplete() - Method in class io.reactivex.observable.subjects.MaybeSubject
onComplete() - Method in class io.reactivex.observable.subjects.PublishSubject
onComplete() - Method in class io.reactivex.observable.subjects.ReplaySubject
onComplete() - Method in class io.reactivex.observable.subjects.UnicastSubject
onError(Throwable) - Method in interface io.reactivex.observable.CompletableEmitter: Signal an exception.
onError(Throwable) - Method in interface io.reactivex.observable.CompletableObserver: Called once if the deferred computation 'throws' an exception.
onError(Throwable) - Method in interface io.reactivex.observable.MaybeEmitter: Signal an exception.
onError(Throwable) - Method in interface io.reactivex.observable.MaybeObserver: Notifies the MaybeObserver that the Maybe has experienced an error condition.
onError(Throwable) - Method in interface io.reactivex.observable.Observer: Notifies the Observer that the Observable has experienced an error condition.
onError(Throwable) - Method in class io.reactivex.observable.observers.SafeObserver
onError(Throwable) - Method in class io.reactivex.observable.observers.SerializedObserver
onError(Throwable) - Method in class io.reactivex.observable.observers.TestObserver
onError(Throwable) - Method in interface io.reactivex.observable.SingleEmitter: Signal an exception.
onError(Throwable) - Method in interface io.reactivex.observable.SingleObserver: Notifies the SingleObserver that the Single has experienced an error condition.
onError(Throwable) - Method in class io.reactivex.observable.subjects.AsyncSubject
onError(Throwable) - Method in class io.reactivex.observable.subjects.BehaviorSubject
onError(Throwable) - Method in class io.reactivex.observable.subjects.CompletableSubject
onError(Throwable) - Method in class io.reactivex.observable.subjects.MaybeSubject
onError(Throwable) - Method in class io.reactivex.observable.subjects.PublishSubject
onError(Throwable) - Method in class io.reactivex.observable.subjects.ReplaySubject
onError(Throwable) - Method in class io.reactivex.observable.subjects.SingleSubject
onError(Throwable) - Method in class io.reactivex.observable.subjects.UnicastSubject
onErrorComplete() - Method in class io.reactivex.observable.Completable: Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the throwable.
onErrorComplete(Predicate<? super Throwable>) - Method in class io.reactivex.observable.Completable: Returns a Completable instance that if this Completable emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
onErrorComplete() - Method in class io.reactivex.observable.Maybe: Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete and swallow the throwable.
onErrorComplete(Predicate<? super Throwable>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe instance that if this Maybe emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
onErrorResumeNext(Function<? super Throwable, ? extends CompletableSource>) - Method in class io.reactivex.observable.Completable: Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper function that returns another Completable instance for it and resumes the execution with it.
onErrorResumeNext(MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: Instructs a Maybe to pass control to another MaybeSource rather than invoking onError if it encounters an error.
onErrorResumeNext(Function<? super Throwable, ? extends MaybeSource<? extends T>>) - Method in class io.reactivex.observable.Maybe: Instructs a Maybe to pass control to another Maybe rather than invoking onError if it encounters an error.
onErrorResumeNext(Function<? super Throwable, ? extends ObservableSource<? extends T>>) - Method in class io.reactivex.observable.Observable: Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an error.
onErrorResumeNext(ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an error.
onErrorResumeNext(Single<? extends T>) - Method in class io.reactivex.observable.Single: Instructs a Single to pass control to another Single rather than invoking SingleObserver.onError(Throwable) if it encounters an error.
onErrorResumeNext(Function<? super Throwable, ? extends SingleSource<? extends T>>) - Method in class io.reactivex.observable.Single: Instructs a Single to pass control to another Single rather than invoking SingleObserver.onError(Throwable) if it encounters an error.
onErrorReturn(Function<? super Throwable, ? extends T>) - Method in class io.reactivex.observable.Maybe: Instructs a Maybe to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
onErrorReturn(Function<? super Throwable, ? extends T>) - Method in class io.reactivex.observable.Observable: Instructs an ObservableSource to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
onErrorReturn(Function<Throwable, ? extends T>) - Method in class io.reactivex.observable.Single: Instructs a Single to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
onErrorReturnItem(T) - Method in class io.reactivex.observable.Maybe: Instructs a Maybe to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
onErrorReturnItem(T) - Method in class io.reactivex.observable.Observable: Instructs an ObservableSource to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
onErrorReturnItem(T) - Method in class io.reactivex.observable.Single: Signals the specified value as success in case the current Single signals an error.
onExceptionResumeNext(MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: Instructs a Maybe to pass control to another MaybeSource rather than invoking onError if it encounters an Exception.
onExceptionResumeNext(ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an Exception.
onNext(T) - Method in interface io.reactivex.observable.Observer: Provides the Observer with a new item to observe.
onNext(T) - Method in class io.reactivex.observable.observers.SafeObserver
onNext(T) - Method in class io.reactivex.observable.observers.SerializedObserver
onNext(T) - Method in class io.reactivex.observable.observers.TestObserver
onNext(T) - Method in class io.reactivex.observable.subjects.AsyncSubject
onNext(T) - Method in class io.reactivex.observable.subjects.BehaviorSubject
onNext(T) - Method in class io.reactivex.observable.subjects.PublishSubject
onNext(T) - Method in class io.reactivex.observable.subjects.ReplaySubject
onNext(T) - Method in class io.reactivex.observable.subjects.UnicastSubject
onStart() - Method in class io.reactivex.observable.observers.DefaultObserver: Called once the subscription has been set on this observer; override this to perform initialization.
onStart() - Method in class io.reactivex.observable.observers.DisposableCompletableObserver: Called once the single upstream Disposable is set via onSubscribe.
onStart() - Method in class io.reactivex.observable.observers.DisposableMaybeObserver: Called once the single upstream Disposable is set via onSubscribe.
onStart() - Method in class io.reactivex.observable.observers.DisposableObserver: Called once the single upstream Disposable is set via onSubscribe.
onStart() - Method in class io.reactivex.observable.observers.DisposableSingleObserver: Called once the single upstream Disposable is set via onSubscribe.
onStart() - Method in class io.reactivex.observable.observers.ResourceCompletableObserver: Called once the upstream sets a Subscription on this ResourceObserver.
onStart() - Method in class io.reactivex.observable.observers.ResourceMaybeObserver: Called once the upstream sets a Subscription on this ResourceObserver.
onStart() - Method in class io.reactivex.observable.observers.ResourceObserver: Called once the upstream sets a Subscription on this ResourceObserver.
onStart() - Method in class io.reactivex.observable.observers.ResourceSingleObserver: Called once the upstream sets a Subscription on this ResourceObserver.
onSubscribe(Disposable) - Method in interface io.reactivex.observable.CompletableObserver: Called once by the Completable to set a Disposable on this instance which then can be used to cancel the subscription at any time.
onSubscribe(Disposable) - Method in interface io.reactivex.observable.MaybeObserver: Provides the MaybeObserver with the means of cancelling (disposing) the connection (channel) with the Maybe in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
onSubscribe(Disposable) - Method in interface io.reactivex.observable.Observer: Provides the Observer with the means of cancelling (disposing) the connection (channel) with the Observable in both synchronous (from within Observer.onNext(Object)) and asynchronous manner.
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.DefaultObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.DisposableCompletableObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.DisposableMaybeObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.DisposableObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.DisposableSingleObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.ResourceCompletableObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.ResourceMaybeObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.ResourceObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.ResourceSingleObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.SafeObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.SerializedObserver
onSubscribe(Disposable) - Method in class io.reactivex.observable.observers.TestObserver
onSubscribe(Observable<T>, Observer<? super T>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onSubscribe(Single<T>, SingleObserver<? super T>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onSubscribe(Completable, CompletableObserver) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onSubscribe(Maybe<T>, MaybeObserver<? super T>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Calls the associated hook function.
onSubscribe(Disposable) - Method in interface io.reactivex.observable.SingleObserver: Provides the SingleObserver with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
onSubscribe(Disposable) - Method in class io.reactivex.observable.subjects.AsyncSubject
onSubscribe(Disposable) - Method in class io.reactivex.observable.subjects.BehaviorSubject
onSubscribe(Disposable) - Method in class io.reactivex.observable.subjects.CompletableSubject
onSubscribe(Disposable) - Method in class io.reactivex.observable.subjects.MaybeSubject
onSubscribe(Disposable) - Method in class io.reactivex.observable.subjects.PublishSubject
onSubscribe(Disposable) - Method in class io.reactivex.observable.subjects.ReplaySubject
onSubscribe(Disposable) - Method in class io.reactivex.observable.subjects.SingleSubject
onSubscribe(Disposable) - Method in class io.reactivex.observable.subjects.UnicastSubject
onSuccess(T) - Method in interface io.reactivex.observable.MaybeEmitter: Signal a success value.
onSuccess(T) - Method in interface io.reactivex.observable.MaybeObserver: Notifies the MaybeObserver with one item and that the Maybe has finished sending push-based notifications.
onSuccess(T) - Method in class io.reactivex.observable.observers.TestObserver
onSuccess(T) - Method in interface io.reactivex.observable.SingleEmitter: Signal a success value.
onSuccess(T) - Method in interface io.reactivex.observable.SingleObserver: Notifies the SingleObserver with a single item and that the Single has finished sending push-based notifications.
onSuccess(T) - Method in class io.reactivex.observable.subjects.MaybeSubject
onSuccess(T) - Method in class io.reactivex.observable.subjects.SingleSubject
onTerminateDetach() - Method in class io.reactivex.observable.Maybe: Nulls out references to the upstream producer and downstream MaybeObserver if the sequence is terminated or downstream calls dispose().
onTerminateDetach() - Method in class io.reactivex.observable.Observable: Nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose().

P

poll() - Method in interface io.reactivex.observable.extensions.SimplePlainQueue
poll() - Method in interface io.reactivex.observable.extensions.SimpleQueue: Tries to dequeue a value (non-null) or returns null if the queue is empty.
publish() - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable, which is a variety of ObservableSource that waits until its connect method is called before it begins emitting items to those Observers that have subscribed to it.
publish(Function<? super Observable<T>, ? extends ObservableSource<R>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the underlying sequence.
PublishSubject<T> - Class in io.reactivex.observable.subjects: Subject that, once an Observer has subscribed, emits all subsequently observed items to the subscriber.

Q

QueueDisposable<T> - Interface in io.reactivex.observable.extensions: An interface extending Queue and Disposable and allows negotiating the fusion mode between subsequent operators of the Observable base reactive type.
QueueFuseable<T> - Interface in io.reactivex.observable.extensions: Represents a SimpleQueue plus the means and constants for requesting a fusion mode.

R

range(int, int) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits a sequence of Integers within a specified range.
rangeLong(long, long) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits a sequence of Longs within a specified range.
reduce(BiFunction<T, T, T>) - Method in class io.reactivex.observable.Observable: Returns a Maybe that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, and emits the final result from the final call to your function as its sole item.
reduce(R, BiFunction<R, ? super T, R>) - Method in class io.reactivex.observable.Observable: Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a specified seed value, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the final result from the final call to your function as its sole item.
reduceWith(Callable<R>, BiFunction<R, ? super T, R>) - Method in class io.reactivex.observable.Observable: Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a specified seed value, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the final result from the final call to your function as its sole item.
refCount() - Method in class io.reactivex.observable.ConnectableObservable: Returns an Observable that stays connected to this ConnectableObservable as long as there is at least one subscription to this ConnectableObservable.
repeat() - Method in class io.reactivex.observable.Completable: Returns a Completable that repeatedly subscribes to this Completable until cancelled.
repeat(long) - Method in class io.reactivex.observable.Completable: Returns a Completable that subscribes repeatedly at most the given times to this Completable.
repeat() - Method in class io.reactivex.observable.Maybe: Returns an Observable that repeats the sequence of items emitted by the source Maybe indefinitely.
repeat(long) - Method in class io.reactivex.observable.Maybe: Returns an Observable that repeats the sequence of items emitted by the source Maybe at most count times.
repeat() - Method in class io.reactivex.observable.Observable: Returns an Observable that repeats the sequence of items emitted by the source ObservableSource indefinitely.
repeat(long) - Method in class io.reactivex.observable.Observable: Returns an Observable that repeats the sequence of items emitted by the source ObservableSource at most count times.
repeat() - Method in class io.reactivex.observable.Single: Repeatedly re-subscribes to the current Single and emits each success value.
repeat(long) - Method in class io.reactivex.observable.Single: Re-subscribes to the current Single at most the given number of times and emits each success value.
repeatUntil(BooleanSupplier) - Method in class io.reactivex.observable.Completable: Returns a Completable that repeatedly subscribes to this Completable so long as the given stop supplier returns false.
repeatUntil(BooleanSupplier) - Method in class io.reactivex.observable.Maybe: Returns an Observable that repeats the sequence of items emitted by the source Maybe until the provided stop function returns true.
repeatUntil(BooleanSupplier) - Method in class io.reactivex.observable.Observable: Returns an Observable that repeats the sequence of items emitted by the source ObservableSource until the provided stop function returns true.
repeatUntil(BooleanSupplier) - Method in class io.reactivex.observable.Single: Re-subscribes to the current Single until the given BooleanSupplier returns true.
repeatWhen(Function<? super Observable<Object>, ? extends ObservableSource<?>>) - Method in class io.reactivex.observable.Completable: Returns a Completable instance that repeats when the ObservableSource returned by the handler emits an item or completes when this ObservableSource emits a completed event.
repeatWhen(Function<? super Observable<Object>, ? extends ObservableSource<?>>) - Method in class io.reactivex.observable.Maybe: Returns an Observable that emits the same values as the source ObservableSource with the exception of an onComplete.
repeatWhen(Function<? super Observable<Object>, ? extends ObservableSource<?>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the same values as the source ObservableSource with the exception of an onComplete.
repeatWhen(Function<? super Observable<Object>, ? extends ObservableSource<?>>) - Method in class io.reactivex.observable.Single: Re-subscribes to the current Single if the ObservableSource returned by the handler function signals a value in response to a value signalled through the Observable the handle receives.
replay() - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable that shares a single subscription to the underlying ObservableSource that will replay all of its items and notifications to any future Observer.
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource.
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying bufferSize notifications.
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int, long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying no more than bufferSize items that were emitted within a specified time window.
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int, long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying no more than bufferSize items that were emitted within a specified time window.
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, int, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying a maximum of bufferSize items.
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within a specified time window.
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within a specified time window.
replay(Function<? super Observable<T>, ? extends ObservableSource<R>>, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource.
replay(int) - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable that shares a single subscription to the source ObservableSource that replays at most bufferSize items emitted by that ObservableSource.
replay(int, long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items that were emitted during a specified time window.
replay(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and that replays a maximum of bufferSize items that are emitted within a specified time window.
replay(int, Scheduler) - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items emitted by that ObservableSource.
replay(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window.
replay(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window.
replay(Scheduler) - Method in class io.reactivex.observable.Observable: Returns a ConnectableObservable that shares a single subscription to the source ObservableSource that will replay all of its items and notifications to any future Observer on the given Scheduler.
ReplaySubject<T> - Class in io.reactivex.observable.subjects: Replays events to Observers.
requestFusion(int) - Method in interface io.reactivex.observable.extensions.QueueFuseable: Request a fusion mode from the upstream.
reset() - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Removes all handlers and resets to default behavior.
ResourceCompletableObserver - Class in io.reactivex.observable.observers: An abstract CompletableObserver that allows asynchronous cancellation of its subscription and associated resources.
ResourceCompletableObserver() - Constructor for class io.reactivex.observable.observers.ResourceCompletableObserver
ResourceMaybeObserver<T> - Class in io.reactivex.observable.observers: An abstract MaybeObserver that allows asynchronous cancellation of its subscription and associated resources.
ResourceMaybeObserver() - Constructor for class io.reactivex.observable.observers.ResourceMaybeObserver
ResourceObserver<T> - Class in io.reactivex.observable.observers: An abstract Observer that allows asynchronous cancellation of its subscription and associated resources.
ResourceObserver() - Constructor for class io.reactivex.observable.observers.ResourceObserver
ResourceSingleObserver<T> - Class in io.reactivex.observable.observers: An abstract SingleObserver that allows asynchronous cancellation of its subscription and the associated resources.
ResourceSingleObserver() - Constructor for class io.reactivex.observable.observers.ResourceSingleObserver
retry() - Method in class io.reactivex.observable.Completable: Returns a Completable that retries this Completable as long as it emits an onError event.
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.observable.Completable: Returns a Completable that retries this Completable in case of an error as long as the predicate returns true.
retry(long) - Method in class io.reactivex.observable.Completable: Returns a Completable that when this Completable emits an error, retries at most the given number of times before giving up and emitting the last error.
retry(Predicate<? super Throwable>) - Method in class io.reactivex.observable.Completable: Returns a Completable that when this Completable emits an error, calls the given predicate with the latest exception to decide whether to resubscribe to this or not.
retry() - Method in class io.reactivex.observable.Maybe: Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls onError (infinite retry count).
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
retry(long) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls onError up to a specified number of retries.
retry(long, Predicate<? super Throwable>) - Method in class io.reactivex.observable.Maybe: Retries at most times or until the predicate returns false, whichever happens first.
retry(Predicate<? super Throwable>) - Method in class io.reactivex.observable.Maybe: Retries the current Maybe if it fails and the predicate returns true.
retry() - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError (infinite retry count).
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
retry(long) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError up to a specified number of retries.
retry(long, Predicate<? super Throwable>) - Method in class io.reactivex.observable.Observable: Retries at most times or until the predicate returns false, whichever happens first.
retry(Predicate<? super Throwable>) - Method in class io.reactivex.observable.Observable: Retries the current Observable if the predicate returns true.
retry() - Method in class io.reactivex.observable.Single: Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
retry(long) - Method in class io.reactivex.observable.Single: Repeatedly re-subscribe at most the specified times to the current Single if it fails with an onError.
retry(BiPredicate<? super Integer, ? super Throwable>) - Method in class io.reactivex.observable.Single: Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
retry(Predicate<? super Throwable>) - Method in class io.reactivex.observable.Single: Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
retryUntil(BooleanSupplier) - Method in class io.reactivex.observable.Maybe: Retries until the given stop function returns true.
retryUntil(BooleanSupplier) - Method in class io.reactivex.observable.Observable: Retries until the given stop function returns true.
retryWhen(Function<? super Observable<Throwable>, ? extends ObservableSource<?>>) - Method in class io.reactivex.observable.Completable: Returns a Completable which given an ObservableSource and when this Completable emits an error, delivers that error through an Observable and the ObservableSource should signal a value indicating a retry in response or a terminal event indicating a termination.
retryWhen(Function<? super Observable<Throwable>, ? extends ObservableSource<?>>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the same values as the source Maybe with the exception of an onError.
retryWhen(Function<? super Observable<Throwable>, ? extends ObservableSource<?>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the same values as the source ObservableSource with the exception of an onError.
retryWhen(Function<? super Observable<Throwable>, ? extends ObservableSource<?>>) - Method in class io.reactivex.observable.Single: Re-subscribes to the current Single if and when the ObservableSource returned by the handler function signals a value.
RxJavaObservablePlugins - Class in io.reactivex.observable: Utility class to inject handlers to certain standard RxJava operations.

S

SafeObserver<T> - Class in io.reactivex.observable.observers: Wraps another Subscriber and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
SafeObserver(Observer<? super T>) - Constructor for class io.reactivex.observable.observers.SafeObserver: Constructs a SafeObserver by wrapping the given actual Observer.
safeSubscribe(Observer<? super T>) - Method in class io.reactivex.observable.Observable: Subscribes to the current Observable and wraps the given Observer into a SafeObserver (if not already a SafeObserver) that deals with exceptions thrown by a misbehaving Observer (that doesn't follow the Reactive-Streams specification).
sample(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals.
sample(long, TimeUnit, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
sample(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals, where the intervals are defined on a particular Scheduler.
sample(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
sample(ObservableSource) - Method in class io.reactivex.observable.Observable: Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous emission from the sampler ObservableSource.
sample(ObservableSource, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous emission from the sampler ObservableSource and optionally emit the very last upstream item when the upstream or other ObservableSource complete.
ScalarCallable<T> - Interface in io.reactivex.observable.extensions: A marker interface indicating that a scalar, constant value is held by the implementing reactive type which can be safely extracted during assembly time can be used for optimization.
scan(BiFunction<T, T, T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
scan(R, BiFunction<R, ? super T, R>) - Method in class io.reactivex.observable.Observable: Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
scanWith(Callable<R>, BiFunction<R, ? super T, R>) - Method in class io.reactivex.observable.Observable: Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
sequenceEqual(MaybeSource<? extends T>, MaybeSource<? extends T>) - Static method in class io.reactivex.observable.Maybe: Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the same by comparing the items emitted by each MaybeSource pairwise.
sequenceEqual(MaybeSource<? extends T>, MaybeSource<? extends T>, BiPredicate<? super T, ? super T>) - Static method in class io.reactivex.observable.Maybe: Returns a Single that emits a Boolean value that indicates whether two MaybeSources are the same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified equality function.
sequenceEqual(ObservableSource<? extends T>, ObservableSource<? extends T>) - Static method in class io.reactivex.observable.Observable: Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
sequenceEqual(ObservableSource<? extends T>, ObservableSource<? extends T>, BiPredicate<? super T, ? super T>) - Static method in class io.reactivex.observable.Observable: Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
sequenceEqual(ObservableSource<? extends T>, ObservableSource<? extends T>, BiPredicate<? super T, ? super T>, int) - Static method in class io.reactivex.observable.Observable: Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
sequenceEqual(ObservableSource<? extends T>, ObservableSource<? extends T>, int) - Static method in class io.reactivex.observable.Observable: Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
serialize() - Method in class io.reactivex.observable.Observable: Forces an ObservableSource's emissions and notifications to be serialized and for it to obey the ObservableSource contract in other ways.
serialize() - Method in interface io.reactivex.observable.ObservableEmitter: Ensures that calls to onNext, onError and onComplete are properly serialized.
SerializedObserver<T> - Class in io.reactivex.observable.observers: Serializes access to the onNext, onError and onComplete methods of another Observer.
SerializedObserver(Observer<? super T>) - Constructor for class io.reactivex.observable.observers.SerializedObserver: Construct a SerializedObserver by wrapping the given actual Observer.
SerializedObserver(Observer<? super T>, boolean) - Constructor for class io.reactivex.observable.observers.SerializedObserver: Construct a SerializedObserver by wrapping the given actual Observer and optionally delaying the errors till all regular values have been emitted from the internal buffer.
setCancellable(Cancellable) - Method in interface io.reactivex.observable.CompletableEmitter: Sets a Cancellable on this emitter; any previous Disposable or Cancellation will be disposed/cancelled.
setCancellable(Cancellable) - Method in interface io.reactivex.observable.MaybeEmitter: Sets a Cancellable on this emitter; any previous Disposable or Cancellation will be unsubscribed/cancelled.
setCancellable(Cancellable) - Method in interface io.reactivex.observable.ObservableEmitter: Sets a Cancellable on this emitter; any previous Disposable or Cancellation will be unsubscribed/cancelled.
setCancellable(Cancellable) - Method in interface io.reactivex.observable.SingleEmitter: Sets a Cancellable on this emitter; any previous Disposable or Cancellation will be unsubscribed/cancelled.
setDisposable(Disposable) - Method in interface io.reactivex.observable.CompletableEmitter: Sets a Disposable on this emitter; any previous Disposable or Cancellation will be disposed/cancelled.
setDisposable(Disposable) - Method in interface io.reactivex.observable.MaybeEmitter: Sets a Disposable on this emitter; any previous Disposable or Cancellation will be unsubscribed/cancelled.
setDisposable(Disposable) - Method in interface io.reactivex.observable.ObservableEmitter: Sets a Disposable on this emitter; any previous Disposable or Cancellation will be unsubscribed/cancelled.
setDisposable(Disposable) - Method in interface io.reactivex.observable.SingleEmitter: Sets a Disposable on this emitter; any previous Disposable or Cancellation will be unsubscribed/cancelled.
setOnCompletableAssembly(Function<? super Completable, ? extends Completable>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
setOnCompletableSubscribe(BiFunction<? super Completable, ? super CompletableObserver, ? extends CompletableObserver>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
setOnConnectableObservableAssembly(Function<? super ConnectableObservable, ? extends ConnectableObservable>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
setOnMaybeAssembly(Function<? super Maybe, ? extends Maybe>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
setOnMaybeSubscribe(BiFunction<? super Maybe, MaybeObserver, ? extends MaybeObserver>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
setOnObservableAssembly(Function<? super Observable, ? extends Observable>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
setOnObservableSubscribe(BiFunction<? super Observable, ? super Observer, ? extends Observer>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
setOnSingleAssembly(Function<? super Single, ? extends Single>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
setOnSingleSubscribe(BiFunction<? super Single, ? super SingleObserver, ? extends SingleObserver>) - Static method in class io.reactivex.observable.RxJavaObservablePlugins: Sets the specific hook function.
share() - Method in class io.reactivex.observable.Observable: Returns a new ObservableSource that multicasts (shares) the original ObservableSource.
SimplePlainQueue<T> - Interface in io.reactivex.observable.extensions: Override of the SimpleQueue interface with no throws Exception on poll().
SimpleQueue<T> - Interface in io.reactivex.observable.extensions: A minimalist queue interface without the method bloat of java.util.Collection and java.util.Queue.
single(T) - Method in class io.reactivex.observable.Observable: Returns a Single that emits the single item emitted by this Observable, if this Observable emits only a single item, or a default item if the source ObservableSource emits no items.
Single<T> - Class in io.reactivex.observable: The Single class implements the Reactive Pattern for a single value response.
Single() - Constructor for class io.reactivex.observable.Single
singleElement() - Method in class io.reactivex.observable.Observable: Returns a Maybe that emits the single item emitted by this Observable if this Observable emits only a single item, otherwise if this Observable emits more than one item or no items, an IllegalArgumentException or NoSuchElementException is signalled respectively.
SingleEmitter<T> - Interface in io.reactivex.observable: Abstraction over an RxJava SingleObserver that allows associating a resource with it.
SingleObserver<T> - Interface in io.reactivex.observable: Provides a mechanism for receiving push-based notifications.
SingleOnSubscribe<T> - Interface in io.reactivex.observable: A functional interface that has a subscribe() method that receives an instance of a SingleEmitter instance that allows pushing an event in a cancellation-safe manner.
SingleOperator<Downstream,Upstream> - Interface in io.reactivex.observable: Interface to map/wrap a downstream observer to an upstream observer.
singleOrError() - Method in class io.reactivex.observable.Observable: Returns a Single that emits the single item emitted by this Observable if this Observable emits only a single item, otherwise if this Observable completes without emitting any items or emits more than one item a NoSuchElementException or IllegalArgumentException will be signalled respectively.
SingleSource<T> - Interface in io.reactivex.observable: Represents a basic Single source base interface, consumable via an SingleObserver.
SingleSubject<T> - Class in io.reactivex.observable.subjects: Represents a hot Single-like source and consumer of events similar to Subjects.
SingleTransformer<Upstream,Downstream> - Interface in io.reactivex.observable: Interface to compose Singles.
skip(long) - Method in class io.reactivex.observable.Observable: Returns an Observable that skips the first count items emitted by the source ObservableSource and emits the remainder.
skip(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that skips values emitted by the source ObservableSource before a specified time window elapses.
skip(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that skips values emitted by the source ObservableSource before a specified time window on a specified Scheduler elapses.
skipLast(int) - Method in class io.reactivex.observable.Observable: Returns an Observable that drops a specified number of items from the end of the sequence emitted by the source ObservableSource.
skipLast(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that drops items emitted by the source ObservableSource during a specified time window before the source completes.
skipLast(long, TimeUnit, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that drops items emitted by the source ObservableSource during a specified time window before the source completes.
skipLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
skipLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
skipLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
skipUntil(ObservableSource) - Method in class io.reactivex.observable.Observable: Returns an Observable that skips items emitted by the source ObservableSource until a second ObservableSource emits an item.
skipWhile(Predicate<? super T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that skips all items emitted by the source ObservableSource as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.
sorted() - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order.
sorted(Comparator<? super T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order based on a specified comparison function.
source() - Method in interface io.reactivex.observable.extensions.HasUpstreamCompletableSource: Returns the upstream source of this Completable.
source() - Method in interface io.reactivex.observable.extensions.HasUpstreamMaybeSource: Returns the upstream source of this Maybe.
source() - Method in interface io.reactivex.observable.extensions.HasUpstreamObservableSource: Returns the upstream source of this Observable.
source() - Method in interface io.reactivex.observable.extensions.HasUpstreamSingleSource: Returns the upstream source of this Single.
startWith(CompletableSource) - Method in class io.reactivex.observable.Completable: Returns a Completable which first runs the other Completable then this completable if the other completed normally.
startWith(Observable<T>) - Method in class io.reactivex.observable.Completable: Returns an Observable which first delivers the events of the other Observable then runs this CompletableConsumable.
startWith(ObservableSource<T>) - Method in class io.reactivex.observable.Completable: Returns an Observable which first delivers the events of the other ObservableSource then runs this Completable.
startWith(Iterable<? extends T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the source ObservableSource.
startWith(ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items in a specified ObservableSource before it begins to emit items emitted by the source ObservableSource.
startWith(T) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits a specified item before it begins to emit items emitted by the source ObservableSource.
startWithArray(T...) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the specified items before it begins to emit items emitted by the source ObservableSource.
Subject<T> - Class in io.reactivex.observable.subjects: Represents an Observer and an Observable at the same time, allowing multicasting events from a single source to multiple child Subscribers.
Subject() - Constructor for class io.reactivex.observable.subjects.Subject
subscribe() - Method in class io.reactivex.observable.Completable: Subscribes to this CompletableConsumable and returns a Disposable which can be used to cancel the subscription.
subscribe(CompletableObserver) - Method in class io.reactivex.observable.Completable
subscribe(Action, Consumer<? super Throwable>) - Method in class io.reactivex.observable.Completable: Subscribes to this Completable and calls back either the onError or onComplete functions.
subscribe(Action) - Method in class io.reactivex.observable.Completable: Subscribes to this Completable and calls the given Action when this Completable completes normally.
subscribe(CompletableEmitter) - Method in interface io.reactivex.observable.CompletableOnSubscribe: Called for each CompletableObserver that subscribes.
subscribe(CompletableObserver) - Method in interface io.reactivex.observable.CompletableSource: Subscribes the given CompletableObserver to this CompletableSource instance.
subscribe() - Method in class io.reactivex.observable.Maybe: Subscribes to a Maybe and ignores onSuccess and onComplete emissions.
subscribe(Consumer<? super T>) - Method in class io.reactivex.observable.Maybe: Subscribes to a Maybe and provides a callback to handle the items it emits.
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.observable.Maybe: Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.observable.Maybe: Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.
subscribe(MaybeObserver<? super T>) - Method in class io.reactivex.observable.Maybe
subscribe(MaybeEmitter<T>) - Method in interface io.reactivex.observable.MaybeOnSubscribe: Called for each MaybeObserver that subscribes.
subscribe(MaybeObserver<? super T>) - Method in interface io.reactivex.observable.MaybeSource: Subscribes the given MaybeObserver to this MaybeSource instance.
subscribe() - Method in class io.reactivex.observable.Observable: Subscribes to an ObservableSource and ignores onNext and onComplete emissions.
subscribe(Consumer<? super T>) - Method in class io.reactivex.observable.Observable: Subscribes to an ObservableSource and provides a callback to handle the items it emits.
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.observable.Observable: Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error notification it issues.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action) - Method in class io.reactivex.observable.Observable: Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or completion notification it issues.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Action, Consumer<? super Disposable>) - Method in class io.reactivex.observable.Observable: Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or completion notification it issues.
subscribe(Observer<? super T>) - Method in class io.reactivex.observable.Observable
subscribe(ObservableEmitter<T>) - Method in interface io.reactivex.observable.ObservableOnSubscribe: Called for each Observer that subscribes.
subscribe(Observer<? super T>) - Method in interface io.reactivex.observable.ObservableSource: Subscribes the given Observer to this ObservableSource instance.
subscribe() - Method in class io.reactivex.observable.Single: Subscribes to a Single but ignore its emission or notification.
subscribe(BiConsumer<? super T, ? super Throwable>) - Method in class io.reactivex.observable.Single: Subscribes to a Single and provides a composite callback to handle the item it emits or any error notification it issues.
subscribe(Consumer<? super T>) - Method in class io.reactivex.observable.Single: Subscribes to a Single and provides a callback to handle the item it emits.
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class io.reactivex.observable.Single: Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it issues.
subscribe(SingleObserver<? super T>) - Method in class io.reactivex.observable.Single
subscribe(SingleEmitter<T>) - Method in interface io.reactivex.observable.SingleOnSubscribe: Called for each SingleObserver that subscribes.
subscribe(SingleObserver<? super T>) - Method in interface io.reactivex.observable.SingleSource: Subscribes the given SingleObserver to this SingleSource instance.
subscribeActual(CompletableObserver) - Method in class io.reactivex.observable.Completable: Implement this to handle the incoming CompletableObserver and perform the business logic in your operator.
subscribeActual(MaybeObserver<? super T>) - Method in class io.reactivex.observable.Maybe: Override this method in subclasses to handle the incoming MaybeObservers.
subscribeActual(Observer<? super T>) - Method in class io.reactivex.observable.Observable: Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic.
subscribeActual(SingleObserver<? super T>) - Method in class io.reactivex.observable.Single: Override this method in subclasses to handle the incoming SingleObservers.
subscribeActual(Observer<? super T>) - Method in class io.reactivex.observable.subjects.AsyncSubject
subscribeActual(Observer<? super T>) - Method in class io.reactivex.observable.subjects.BehaviorSubject
subscribeActual(CompletableObserver) - Method in class io.reactivex.observable.subjects.CompletableSubject
subscribeActual(MaybeObserver<? super T>) - Method in class io.reactivex.observable.subjects.MaybeSubject
subscribeActual(Observer<? super T>) - Method in class io.reactivex.observable.subjects.PublishSubject
subscribeActual(Observer<? super T>) - Method in class io.reactivex.observable.subjects.ReplaySubject
subscribeActual(SingleObserver<? super T>) - Method in class io.reactivex.observable.subjects.SingleSubject
subscribeActual(Observer<? super T>) - Method in class io.reactivex.observable.subjects.UnicastSubject
subscribeOn(Scheduler) - Method in class io.reactivex.observable.Completable: Returns a Completable which subscribes the child subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of the scheduler.
subscribeOn(Scheduler) - Method in class io.reactivex.observable.Maybe: Asynchronously subscribes subscribers to this Maybe on the specified Scheduler.
subscribeOn(Scheduler) - Method in class io.reactivex.observable.Observable: Asynchronously subscribes Observers to this ObservableSource on the specified Scheduler.
subscribeOn(Scheduler) - Method in class io.reactivex.observable.Single: Asynchronously subscribes subscribers to this Single on the specified Scheduler.
subscribeWith(E) - Method in class io.reactivex.observable.Completable: Subscribes a given CompletableObserver (subclass) to this Completable and returns the given CompletableObserver as is.
subscribeWith(E) - Method in class io.reactivex.observable.Maybe: Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given MaybeObserver as is.
subscribeWith(E) - Method in class io.reactivex.observable.Observable: Subscribes a given Observer (subclass) to this Observable and returns the given Observer as is.
subscribeWith(E) - Method in class io.reactivex.observable.Single: Subscribes a given SingleObserver (subclass) to this Single and returns the given SingleObserver as is.
switchIfEmpty(MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the items emitted by the source Maybe or the items of an alternate MaybeSource if the current Maybe is empty.
switchIfEmpty(ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by the source ObservableSource or the items of an alternate ObservableSource if the source ObservableSource is empty.
switchMap(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
switchMap(Function<? super T, ? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.observable.Observable: Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
switchMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
switchMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>>, int) - Method in class io.reactivex.observable.Observable: Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
switchMapSingle(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.
switchMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>>) - Method in class io.reactivex.observable.Observable: Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources and delays any error until all SingleSources terminate.
switchOnNext(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.observable.Observable: Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources.
switchOnNext(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources.
switchOnNextDelayError(ObservableSource<? extends ObservableSource<? extends T>>) - Static method in class io.reactivex.observable.Observable: Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
switchOnNextDelayError(ObservableSource<? extends ObservableSource<? extends T>>, int) - Static method in class io.reactivex.observable.Observable: Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
SYNC - Static variable in interface io.reactivex.observable.extensions.QueueFuseable: Request a synchronous fusion mode and can be returned by QueueFuseable.requestFusion(int) for an accepted mode.

T

take(long) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits only the first count items emitted by the source ObservableSource.
take(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits those items emitted by source ObservableSource before a specified time runs out.
take(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits those items emitted by source ObservableSource before a specified time (on a specified Scheduler) runs out.
takeLast(int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits at most the last count items emitted by the source ObservableSource.
takeLast(long, long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
takeLast(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a given Scheduler.
takeLast(long, long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a given Scheduler.
takeLast(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
takeLast(long, TimeUnit, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
takeLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
takeLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
takeLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
takeUntil(MaybeSource) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the items emitted by the source Maybe until a second MaybeSource emits an item.
takeUntil(ObservableSource) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the item emitted by the source Maybe until a second ObservableSource emits an item.
takeUntil(ObservableSource) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits the items emitted by the source Observable until a second ObservableSource emits an item.
takeUntil(Predicate<? super T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items emitted by the source Observable, checks the specified predicate for each item, and then completes when the condition is satisfied.
takeUntil(CompletableSource) - Method in class io.reactivex.observable.Single: Returns a Single that emits the item emitted by the source Single until a Completable terminates.
takeUntil(ObservableSource<E>) - Method in class io.reactivex.observable.Single: Returns a Single that emits the item emitted by the source Single until an ObservableSource emits an item.
takeUntil(SingleSource<? extends E>) - Method in class io.reactivex.observable.Single: Returns a Single that emits the item emitted by the source Single until a second Single emits an item.
takeWhile(Predicate<? super T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items emitted by the source ObservableSource so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
test() - Method in class io.reactivex.observable.Completable: Creates a TestObserver and subscribes it to this Completable.
test(boolean) - Method in class io.reactivex.observable.Completable: Creates a TestObserver optionally in cancelled state, then subscribes it to this Completable.
test() - Method in class io.reactivex.observable.Maybe: Creates a TestObserver and subscribes it to this Maybe.
test(boolean) - Method in class io.reactivex.observable.Maybe: Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.
test() - Method in class io.reactivex.observable.Observable: Creates a TestObserver and subscribes it to this Observable.
test(boolean) - Method in class io.reactivex.observable.Observable: Creates a TestObserver, optionally disposes it and then subscribes it to this Observable.
test() - Method in class io.reactivex.observable.Single: Creates a TestObserver and subscribes it to this Single.
test(boolean) - Method in class io.reactivex.observable.Single: Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.
TestObserver<T> - Class in io.reactivex.observable.observers: An Observer that records events and allows making assertions about them.
TestObserver() - Constructor for class io.reactivex.observable.observers.TestObserver: Constructs a non-forwarding TestObserver.
TestObserver(Observer<? super T>) - Constructor for class io.reactivex.observable.observers.TestObserver: Constructs a forwarding TestObserver.
throttleFirst(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration.
throttleFirst(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
throttleLast(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration.
throttleLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
throttleWithTimeout(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that only emits those items emitted by the source ObservableSource that are not followed by another emitted item within a specified time window.
throttleWithTimeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that only emits those items emitted by the source ObservableSource that are not followed by another emitted item within a specified time window, where the time window is governed by a specified Scheduler.
timeInterval() - Method in class io.reactivex.observable.Observable: Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.
timeInterval(Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, where this interval is computed on a specified Scheduler.
timeInterval(TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.
timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, where this interval is computed on a specified Scheduler.
timeout(long, TimeUnit) - Method in class io.reactivex.observable.Completable: Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time.
timeout(long, TimeUnit, CompletableSource) - Method in class io.reactivex.observable.Completable: Returns a Completable that runs this Completable and switches to the other Completable in case this Completable doesn't complete within the given time.
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Completable: Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
timeout(long, TimeUnit, Scheduler, CompletableSource) - Method in class io.reactivex.observable.Completable: Returns a Completable that runs this Completable and switches to the other Completable in case this Completable doesn't complete within the given time while "waiting" on the specified scheduler.
timeout(long, TimeUnit) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item.
timeout(long, TimeUnit, MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item.
timeout(long, TimeUnit, Scheduler, MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item using a specified Scheduler.
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Maybe: Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
timeout(MaybeSource) - Method in class io.reactivex.observable.Maybe: If this Maybe source didn't signal an event before the timeoutIndicator MaybeSource signals, a TimeoutException is signalled instead.
timeout(MaybeSource, MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: If the current Maybe source didn't signal an event before the timeoutIndicator MaybeSource signals, the current Maybe is cancelled and the fallback MaybeSource subscribed to as a continuation.
timeout(ObservableSource) - Method in class io.reactivex.observable.Maybe: If this Maybe source didn't signal an event before the timeoutIndicator ObservableSource signals, a TimeoutException is signalled instead.
timeout(ObservableSource, MaybeSource<? extends T>) - Method in class io.reactivex.observable.Maybe: If the current Maybe source didn't signal an event before the timeoutIndicator ObservableSource signals, the current Maybe is cancelled and the fallback MaybeSource subscribed to as a continuation.
timeout(Function<? super T, ? extends ObservableSource<V>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, but notifies observers of a TimeoutException if an item emitted by the source ObservableSource doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
timeout(Function<? super T, ? extends ObservableSource<V>>, ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, but that switches to a fallback ObservableSource if an item emitted by the source ObservableSource doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
timeout(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item.
timeout(long, TimeUnit, ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item.
timeout(long, TimeUnit, Scheduler, ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item using a specified Scheduler.
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
timeout(ObservableSource, Function<? super T, ? extends ObservableSource<V>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, but notifies observers of a TimeoutException if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.
timeout(ObservableSource, Function<? super T, ? extends ObservableSource<V>>, ObservableSource<? extends T>) - Method in class io.reactivex.observable.Observable: Returns an Observable that mirrors the source ObservableSource, but switches to a fallback ObservableSource if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.
timeout(long, TimeUnit) - Method in class io.reactivex.observable.Single: Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Single: Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
timeout(long, TimeUnit, Scheduler, SingleSource<? extends T>) - Method in class io.reactivex.observable.Single: Runs the current Single and if it doesn't signal within the specified timeout window, it is cancelled and the other SingleSource subscribed to.
timeout(long, TimeUnit, SingleSource<? extends T>) - Method in class io.reactivex.observable.Single: Runs the current Single and if it doesn't signal within the specified timeout window, it is cancelled and the other SingleSource subscribed to.
timer(long, TimeUnit) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that fires its onComplete event after the given delay elapsed.
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance that fires its onComplete event after the given delay elapsed by using the supplied scheduler.
timer(long, TimeUnit) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits 0L after a specified delay.
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits 0L after a specified delay on a specified Scheduler.
timer(long, TimeUnit) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits 0L after a specified delay, and then completes.
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
timer(long, TimeUnit) - Static method in class io.reactivex.observable.Single: Signals success with 0L value after the given delay for each SingleObserver.
timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.observable.Single: Signals success with 0L value after the given delay for each SingleObserver.
timestamp() - Method in class io.reactivex.observable.Observable: Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object.
timestamp(Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
timestamp(TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object.
timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
to(Function<? super Completable, U>) - Method in class io.reactivex.observable.Completable: Allows fluent conversion to another type via a function callback.
to(Function<? super Maybe<T>, R>) - Method in class io.reactivex.observable.Maybe: Calls the specified converter function with the current Maybe instance during assembly time and returns its result.
to(Function<? super Observable<T>, R>) - Method in class io.reactivex.observable.Observable: Calls the specified converter function during assembly time and returns its resulting value.
to(Function<? super Single<T>, R>) - Method in class io.reactivex.observable.Single: Calls the specified converter function with the current Single instance during assembly time and returns its result.
toCompletable() - Method in class io.reactivex.observable.Single: Returns a Completable that discards result of the Single and calls onComplete when this source Single calls onSuccess.
toFuture() - Method in class io.reactivex.observable.Observable: Returns a Future representing the single value emitted by this Observable.
toFuture() - Method in class io.reactivex.observable.Single: Returns a Future representing the single value emitted by this Single.
toList() - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single item, a list composed of all the items emitted by the source ObservableSource.
toList(int) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single item, a list composed of all the items emitted by the source ObservableSource.
toList(Callable) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single item, a list composed of all the items emitted by the source ObservableSource.
toMap(Function<? super T, ? extends K>) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single HashMap containing all items emitted by the source ObservableSource, mapped by the keys returned by a specified keySelector function.
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single HashMap containing values corresponding to items emitted by the source ObservableSource, mapped by the keys returned by a specified keySelector function.
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Callable<? extends Map<K, V>>) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the source ObservableSource.
toMaybe() - Method in class io.reactivex.observable.Completable: Converts this Completable into a Maybe.
toMaybe() - Method in class io.reactivex.observable.Single: Converts this Single into a Maybe.
toMultimap(Function<? super T, ? extends K>) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the source ObservableSource keyed by a specified keySelector function.
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the source ObservableSource, keyed by a specified keySelector function.
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Callable<? extends Map<K, Collection<V>>>, Function<? super K, ? extends Collection<? super V>>) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains a custom collection of values, extracted by a specified valueSelector function from items emitted by the source ObservableSource, and keyed by the keySelector function.
toMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Callable<Map<K, Collection<V>>>) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the source ObservableSource and keyed by the keySelector function.
toObservable() - Method in class io.reactivex.observable.Completable: Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
toObservable() - Method in class io.reactivex.observable.Maybe: Converts this Maybe into an Observable instance composing cancellation through.
toObservable() - Method in class io.reactivex.observable.Single: Converts this Single into an Observable.
toSerialized() - Method in class io.reactivex.observable.subjects.Subject: Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and onComplete methods, making them thread-safe.
toSingle(Callable<? extends T>) - Method in class io.reactivex.observable.Completable: Converts this Completable into a Single which when this Completable completes normally, calls the given supplier and emits its returned value through onSuccess.
toSingle(T) - Method in class io.reactivex.observable.Maybe: Converts this Maybe into a Single instance composing cancellation through and turning an empty Maybe into a signal of NoSuchElementException.
toSingle() - Method in class io.reactivex.observable.Maybe: Converts this Maybe into a Single instance composing cancellation through and turning an empty Maybe into a signal of NoSuchElementException.
toSingleDefault(T) - Method in class io.reactivex.observable.Completable: Converts this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
toSortedList() - Method in class io.reactivex.observable.Observable: Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order.
toSortedList(Comparator<? super T>) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order based on a specified comparison function.
toSortedList(Comparator<? super T>, int) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order based on a specified comparison function.
toSortedList(int) - Method in class io.reactivex.observable.Observable: Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order.

U

UnicastSubject<T> - Class in io.reactivex.observable.subjects: Subject that allows only a single Subscriber to subscribe to it during its lifetime.
unsafeCreate(CompletableSource) - Static method in class io.reactivex.observable.Completable: Constructs a Completable instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream cancellation/dispose.
unsafeCreate(MaybeSource<T>) - Static method in class io.reactivex.observable.Maybe: Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.
unsafeCreate(ObservableSource<T>) - Static method in class io.reactivex.observable.Observable: Create an Observable by wrapping an ObservableSource which has to be implemented according to the Reactive-Streams-based Observable specification by handling cancellation correctly; no safeguards are provided by the Observable itself.
unsafeCreate(SingleSource<T>) - Static method in class io.reactivex.observable.Single: Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.
unsubscribeOn(Scheduler) - Method in class io.reactivex.observable.Completable: Returns a Completable which makes sure when a subscriber cancels the subscription, the dispose is called on the specified scheduler Scheduler: unsubscribeOn calls dispose() of the upstream on the Scheduler you specify.
unsubscribeOn(Scheduler) - Method in class io.reactivex.observable.Maybe: Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, that call is propagated up on the specified scheduler Scheduler: unsubscribeOn calls dispose() of the upstream on the Scheduler you specify.
unsubscribeOn(Scheduler) - Method in class io.reactivex.observable.Observable: Modifies the source ObservableSource so that subscribers will dispose it on a specified Scheduler.
using(Callable<R>, Function<? super R, ? extends CompletableSource>, Consumer<? super R>) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance which manages a resource along with a custom Completable instance while the subscription is active.
using(Callable<R>, Function<? super R, ? extends CompletableSource>, Consumer<? super R>, boolean) - Static method in class io.reactivex.observable.Completable: Returns a Completable instance which manages a resource along with a custom Completable instance while the subscription is active and performs eager or lazy resource disposition.
using(Callable<? extends D>, Function<? super D, ? extends MaybeSource<? extends T>>, Consumer<? super D>) - Static method in class io.reactivex.observable.Maybe: Constructs a Maybe that creates a dependent resource object which is disposed of when the upstream terminates or the downstream calls dispose().
using(Callable<? extends D>, Function<? super D, ? extends MaybeSource<? extends T>>, Consumer<? super D>, boolean) - Static method in class io.reactivex.observable.Maybe: Constructs a Maybe that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and a downstream dispose() does not occur before termination.
using(Callable<? extends D>, Function<? super D, ? extends ObservableSource<? extends T>>, Consumer<? super D>) - Static method in class io.reactivex.observable.Observable: Constructs an ObservableSource that creates a dependent resource object which is disposed of when the downstream calls dispose().
using(Callable<? extends D>, Function<? super D, ? extends ObservableSource<? extends T>>, Consumer<? super D>, boolean) - Static method in class io.reactivex.observable.Observable: Constructs an ObservableSource that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and a dispose() call does not occur before termination.
using(Callable, Function<? super U, ? extends SingleSource<? extends T>>, Consumer<? super U>) - Static method in class io.reactivex.observable.Single: Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
using(Callable, Function<? super U, ? extends SingleSource<? extends T>>, Consumer<? super U>, boolean) - Static method in class io.reactivex.observable.Single: Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).

W

window(long) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, long) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, long, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, long, TimeUnit, Scheduler, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, TimeUnit) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, TimeUnit, long) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, TimeUnit, long, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, TimeUnit, Scheduler) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, TimeUnit, Scheduler, long) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, TimeUnit, Scheduler, long, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(long, TimeUnit, Scheduler, long, boolean, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(ObservableSource) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
window(ObservableSource, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
window(ObservableSource, Function<? super U, ? extends ObservableSource<V>>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(ObservableSource, Function<? super U, ? extends ObservableSource<V>>, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(Callable<? extends ObservableSource>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
window(Callable<? extends ObservableSource>, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits windows of items it collects from the source ObservableSource.
withLatestFrom(ObservableSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.observable.Observable: Merges the specified ObservableSource into this ObservableSource sequence by using the resultSelector function only when the source ObservableSource (this instance) emits an item.
withLatestFrom(ObservableSource<T1>, ObservableSource<T2>, Function3<? super T, ? super T1, ? super T2, R>) - Method in class io.reactivex.observable.Observable: Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
withLatestFrom(ObservableSource<T1>, ObservableSource<T2>, ObservableSource<T3>, Function4<? super T, ? super T1, ? super T2, ? super T3, R>) - Method in class io.reactivex.observable.Observable: Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
withLatestFrom(ObservableSource<T1>, ObservableSource<T2>, ObservableSource<T3>, ObservableSource<T4>, Function5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R>) - Method in class io.reactivex.observable.Observable: Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
withLatestFrom(ObservableSource<?>[], Function<? super Object[], R>) - Method in class io.reactivex.observable.Observable: Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
withLatestFrom(Iterable<? extends ObservableSource<?>>, Function<? super Object[], R>) - Method in class io.reactivex.observable.Observable: Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
wrap(CompletableSource) - Static method in class io.reactivex.observable.Completable: Wraps the given CompletableSource into a Completable if not already Completable.
wrap(MaybeSource<T>) - Static method in class io.reactivex.observable.Maybe: Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.
wrap(ObservableSource<T>) - Static method in class io.reactivex.observable.Observable: Wraps an ObservableSource into an Observable if not already an Observable.
wrap(SingleSource<T>) - Static method in class io.reactivex.observable.Single: Wraps a SingleSource instance into a new Single instance if not already a Single instance.

Z

zip(Iterable<? extends MaybeSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other MaybeSources.
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other MaybeSources.
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other MaybeSources.
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other MaybeSources.
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other MaybeSources.
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, MaybeSource<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other MaybeSources.
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, MaybeSource<? extends T6>, MaybeSource<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other MaybeSources.
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, MaybeSource<? extends T6>, MaybeSource<? extends T7>, MaybeSource<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other MaybeSources.
zip(MaybeSource<? extends T1>, MaybeSource<? extends T2>, MaybeSource<? extends T3>, MaybeSource<? extends T4>, MaybeSource<? extends T5>, MaybeSource<? extends T6>, MaybeSource<? extends T7>, MaybeSource<? extends T8>, MaybeSource<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other MaybeSources.
zip(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
zip(ObservableSource<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by the n ObservableSources emitted by a specified ObservableSource.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>, boolean) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>, boolean, int) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, ObservableSource<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other ObservableSources.
zip(ObservableSource<? extends T1>, ObservableSource<? extends T2>, ObservableSource<? extends T3>, ObservableSource<? extends T4>, ObservableSource<? extends T5>, ObservableSource<? extends T6>, ObservableSource<? extends T7>, ObservableSource<? extends T8>, ObservableSource<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other ObservableSources.
zip(Iterable<? extends SingleSource<? extends T>>, Function<? super Object[], ? extends R>) - Static method in class io.reactivex.observable.Single: Waits until all SingleSource sources provided by the Iterable sequence signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, BiFunction<? super T1, ? super T2, ? extends R>) - Static method in class io.reactivex.observable.Single: Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other Singles.
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, Function3<? super T1, ? super T2, ? super T3, ? extends R>) - Static method in class io.reactivex.observable.Single: Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other Singles.
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R>) - Static method in class io.reactivex.observable.Single: Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other Singles.
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R>) - Static method in class io.reactivex.observable.Single: Returns a Single that emits the results of a specified combiner function applied to five items emitted by five other Singles.
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, SingleSource<? extends T6>, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R>) - Static method in class io.reactivex.observable.Single: Returns a Single that emits the results of a specified combiner function applied to six items emitted by six other Singles.
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, SingleSource<? extends T6>, SingleSource<? extends T7>, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R>) - Static method in class io.reactivex.observable.Single: Returns a Single that emits the results of a specified combiner function applied to seven items emitted by seven other Singles.
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, SingleSource<? extends T6>, SingleSource<? extends T7>, SingleSource<? extends T8>, Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R>) - Static method in class io.reactivex.observable.Single: Returns a Single that emits the results of a specified combiner function applied to eight items emitted by eight other Singles.
zip(SingleSource<? extends T1>, SingleSource<? extends T2>, SingleSource<? extends T3>, SingleSource<? extends T4>, SingleSource<? extends T5>, SingleSource<? extends T6>, SingleSource<? extends T7>, SingleSource<? extends T8>, SingleSource<? extends T9>, Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R>) - Static method in class io.reactivex.observable.Single: Returns a Single that emits the results of a specified combiner function applied to nine items emitted by nine other Singles.
zipArray(Function<? super Object[], ? extends R>, MaybeSource<? extends T>...) - Static method in class io.reactivex.observable.Maybe: Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other MaybeSources.
zipArray(Function<? super Object[], ? extends R>, boolean, int, ObservableSource<? extends T>...) - Static method in class io.reactivex.observable.Observable: 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 ObservableSources.
zipArray(Function<? super Object[], ? extends R>, SingleSource<? extends T>...) - Static method in class io.reactivex.observable.Single: Waits until all SingleSource sources provided via an array signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.
zipIterable(Iterable<? extends ObservableSource<? extends T>>, Function<? super Object[], ? extends R>, boolean, int) - Static method in class io.reactivex.observable.Observable: Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
zipWith(MaybeSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.observable.Maybe: Waits until this and the other MaybeSource signal a success value then applies the given BiFunction to those values and emits the BiFunction's resulting value to downstream.
zipWith(Iterable, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and a specified Iterable sequence.
zipWith(ObservableSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.
zipWith(ObservableSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>, boolean) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.
zipWith(ObservableSource<? extends U>, BiFunction<? super T, ? super U, ? extends R>, boolean, int) - Method in class io.reactivex.observable.Observable: Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.
zipWith(SingleSource, BiFunction<? super T, ? super U, ? extends R>) - Method in class io.reactivex.observable.Single: Returns a Single that emits the result of applying a specified function to the pair of items emitted by the source Single and another specified Single.

A B C D E F G H I J L M N O P Q R S T U W Z