Package | Description |
---|---|
io.reactivex |
Base reactive classes:
Flowable , Observable ,
Single , Maybe and
Completable ; base reactive consumers;
other common base interfaces. |
io.reactivex.disposables |
Default implementations for Disposable-based resource management
(Disposable container types) and utility classes to construct
Disposables from callbacks and other types.
|
io.reactivex.exceptions |
Exception handling utilities, safe subscriber exception classes,
lifecycle exception classes.
|
io.reactivex.flowables |
Classes supporting the Flowable base reactive class:
ConnectableFlowable and
GroupedFlowable . |
io.reactivex.functions |
Functional interfaces of functions and actions of arity 0 to 9 and related
utility classes.
|
io.reactivex.internal.fuseable |
Base interfaces and types for supporting operator-fusion.
|
io.reactivex.internal.operators.flowable | |
io.reactivex.internal.operators.observable | |
io.reactivex.internal.schedulers | |
io.reactivex.observables |
Classes supporting the Observable base reactive class:
ConnectableObservable and
GroupedObservable . |
io.reactivex.observers |
Default wrappers and implementations for Observer-based consumer classes and interfaces,
including disposable and resource-tracking variants and
the
TestObserver that allows unit testing
Observable -, Single -, Maybe -
and Completable -based flows. |
io.reactivex.parallel |
Contains the base type
ParallelFlowable ,
a sub-DSL for working with Flowable sequences in parallel. |
io.reactivex.plugins |
Contains the central plugin handler
RxJavaPlugins
class to hook into the lifecycle of the base reactive types and schedulers. |
io.reactivex.processors |
Classes extending the Flowable base reactive class and implementing
the Subscriber interface at the same time (aka hot Flowables).
|
io.reactivex.schedulers |
Contains notably the factory class of
Schedulers providing methods for
retrieving the standard scheduler instances, the TestScheduler for testing flows
with scheduling in a controlled manner and the class Timed that can hold
a value and a timestamp associated with it. |
io.reactivex.subjects |
Classes representing so-called hot sources, aka subjects, that implement a base reactive class and
the respective consumer type at once to allow forms of multicasting events to multiple
consumers as well as consuming another base reactive type of their kind.
|
Modifier and Type | Method and Description |
---|---|
CompletableSource |
CompletableTransformer.apply(Completable upstream)
Applies a function to the upstream Completable and returns a CompletableSource.
|
R |
CompletableConverter.apply(Completable upstream)
Applies a function to the upstream Completable and returns a converted value of type
R . |
CompletableObserver |
CompletableOperator.apply(CompletableObserver observer)
Applies a function to the child CompletableObserver and returns a new parent CompletableObserver.
|
R |
FlowableConverter.apply(Flowable<T> upstream)
Applies a function to the upstream Flowable and returns a converted value of type
R . |
org.reactivestreams.Publisher<Downstream> |
FlowableTransformer.apply(Flowable<Upstream> upstream)
Applies a function to the upstream Flowable and returns a Publisher with
optionally different element type.
|
R |
MaybeConverter.apply(Maybe<T> upstream)
Applies a function to the upstream Maybe and returns a converted value of type
R . |
MaybeSource<Downstream> |
MaybeTransformer.apply(Maybe<Upstream> upstream)
Applies a function to the upstream Maybe and returns a MaybeSource with
optionally different element type.
|
MaybeObserver<? super Upstream> |
MaybeOperator.apply(MaybeObserver<? super Downstream> observer)
Applies a function to the child MaybeObserver and returns a new parent MaybeObserver.
|
R |
ObservableConverter.apply(Observable<T> upstream)
Applies a function to the upstream Observable and returns a converted value of type
R . |
ObservableSource<Downstream> |
ObservableTransformer.apply(Observable<Upstream> upstream)
Applies a function to the upstream Observable and returns an ObservableSource with
optionally different element type.
|
Observer<? super Upstream> |
ObservableOperator.apply(Observer<? super Downstream> observer)
Applies a function to the child Observer and returns a new parent Observer.
|
R |
SingleConverter.apply(Single<T> upstream)
Applies a function to the upstream Single and returns a converted value of type
R . |
SingleSource<Downstream> |
SingleTransformer.apply(Single<Upstream> upstream)
Applies a function to the upstream Single and returns a SingleSource with
optionally different element type.
|
SingleObserver<? super Upstream> |
SingleOperator.apply(SingleObserver<? super Downstream> observer)
Applies a function to the child SingleObserver and returns a new parent SingleObserver.
|
org.reactivestreams.Subscriber<? super Upstream> |
FlowableOperator.apply(org.reactivestreams.Subscriber<? super Downstream> subscriber)
Applies a function to the child Subscriber and returns a new parent Subscriber.
|
static <T> Notification<T> |
Notification.createOnComplete()
Returns the empty and stateless shared instance of a notification representing
an onComplete signal.
|
static <T> Notification<T> |
Notification.createOnError(Throwable error)
Constructs an onError notification containing the error.
|
static <T> Notification<T> |
Notification.createOnNext(T value)
Constructs an onNext notification containing the given value.
|
abstract Scheduler.Worker |
Scheduler.createWorker()
Retrieves or creates a new
Scheduler.Worker that represents sequential execution of actions. |
Disposable |
Scheduler.Worker.schedule(Runnable run)
Schedules a Runnable for execution without any time delay.
|
abstract Disposable |
Scheduler.Worker.schedule(Runnable run,
long delay,
TimeUnit unit)
Schedules an Runnable for execution at some point in the future specified by a time delay
relative to the current time.
|
Disposable |
Scheduler.scheduleDirect(Runnable run)
Schedules the given task on this Scheduler without any time delay.
|
Disposable |
Scheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit)
Schedules the execution of the given task with the given time delay.
|
Disposable |
Scheduler.Worker.schedulePeriodically(Runnable run,
long initialDelay,
long period,
TimeUnit unit)
Schedules a periodic execution of the given task with the given initial time delay and repeat period.
|
Disposable |
Scheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit)
Schedules a periodic execution of the given task with the given initial time delay and repeat period.
|
ObservableEmitter<T> |
ObservableEmitter.serialize()
Ensures that calls to onNext, onError and onComplete are properly serialized.
|
FlowableEmitter<T> |
FlowableEmitter.serialize()
Ensures that calls to onNext, onError and onComplete are properly serialized.
|
<R> Observable<R> |
Observable.switchMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
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.
|
<R> Observable<R> |
Observable.switchMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
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.
|
<S extends Scheduler & Disposable> |
Scheduler.when(Function<Flowable<Flowable<Completable>>,Completable> combine)
Allows the use of operators for controlling the timing around when
actions scheduled on workers are actually done.
|
Modifier and Type | Method and Description |
---|---|
CompletableSource |
CompletableTransformer.apply(Completable upstream)
Applies a function to the upstream Completable and returns a CompletableSource.
|
R |
CompletableConverter.apply(Completable upstream)
Applies a function to the upstream Completable and returns a converted value of type
R . |
CompletableObserver |
CompletableOperator.apply(CompletableObserver observer)
Applies a function to the child CompletableObserver and returns a new parent CompletableObserver.
|
R |
FlowableConverter.apply(Flowable<T> upstream)
Applies a function to the upstream Flowable and returns a converted value of type
R . |
org.reactivestreams.Publisher<Downstream> |
FlowableTransformer.apply(Flowable<Upstream> upstream)
Applies a function to the upstream Flowable and returns a Publisher with
optionally different element type.
|
R |
MaybeConverter.apply(Maybe<T> upstream)
Applies a function to the upstream Maybe and returns a converted value of type
R . |
MaybeSource<Downstream> |
MaybeTransformer.apply(Maybe<Upstream> upstream)
Applies a function to the upstream Maybe and returns a MaybeSource with
optionally different element type.
|
MaybeObserver<? super Upstream> |
MaybeOperator.apply(MaybeObserver<? super Downstream> observer)
Applies a function to the child MaybeObserver and returns a new parent MaybeObserver.
|
R |
ObservableConverter.apply(Observable<T> upstream)
Applies a function to the upstream Observable and returns a converted value of type
R . |
ObservableSource<Downstream> |
ObservableTransformer.apply(Observable<Upstream> upstream)
Applies a function to the upstream Observable and returns an ObservableSource with
optionally different element type.
|
Observer<? super Upstream> |
ObservableOperator.apply(Observer<? super Downstream> observer)
Applies a function to the child Observer and returns a new parent Observer.
|
R |
SingleConverter.apply(Single<T> upstream)
Applies a function to the upstream Single and returns a converted value of type
R . |
SingleSource<Downstream> |
SingleTransformer.apply(Single<Upstream> upstream)
Applies a function to the upstream Single and returns a SingleSource with
optionally different element type.
|
SingleObserver<? super Upstream> |
SingleOperator.apply(SingleObserver<? super Downstream> observer)
Applies a function to the child SingleObserver and returns a new parent SingleObserver.
|
org.reactivestreams.Subscriber<? super Upstream> |
FlowableOperator.apply(org.reactivestreams.Subscriber<? super Downstream> subscriber)
Applies a function to the child Subscriber and returns a new parent Subscriber.
|
<R> R |
Completable.as(CompletableConverter<? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Flowable.as(FlowableConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Maybe.as(MaybeConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Observable.as(ObservableConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Single.as(SingleConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
Observable<T> |
Observable.concatWith(CompletableSource other)
Returns an
Observable that emits items from this Observable and when it completes normally, the
other CompletableSource is subscribed to and the returned Observable emits its terminal events. |
Flowable<T> |
Flowable.concatWith(CompletableSource other)
Returns a
Flowable that emits items from this Flowable and when it completes normally, the
other CompletableSource is subscribed to and the returned Flowable emits its terminal events. |
Observable<T> |
Observable.concatWith(MaybeSource<? extends T> other)
Returns an
Observable that emits the items from this Observable followed by the success item or terminal events
of the other MaybeSource . |
Flowable<T> |
Flowable.concatWith(MaybeSource<? extends T> other)
Returns a
Flowable that emits the items from this Flowable followed by the success item or terminal events
of the other MaybeSource . |
Observable<T> |
Observable.concatWith(SingleSource<? extends T> other)
Returns an
Observable that emits the items from this Observable followed by the success item or error event
of the other SingleSource . |
Flowable<T> |
Flowable.concatWith(SingleSource<? extends T> other)
Returns a
Flowable that emits the items from this Flowable followed by the success item or error event
of the other SingleSource . |
static <T> Notification<T> |
Notification.createOnError(Throwable error)
Constructs an onError notification containing the error.
|
static <T> Notification<T> |
Notification.createOnNext(T value)
Constructs an onNext notification containing the given value.
|
static <T> Maybe<T> |
Maybe.fromCallable(Callable<? extends T> callable)
Returns a
Maybe that invokes the given Callable for each individual MaybeObserver that
subscribes and emits the resulting non-null item via onSuccess while
considering a null result from the Callable as indication for valueless completion
via onComplete . |
Observable<T> |
Observable.mergeWith(CompletableSource other)
Relays the items of this Observable and completes only when the other CompletableSource completes
as well.
|
Flowable<T> |
Flowable.mergeWith(CompletableSource other)
Relays the items of this Flowable and completes only when the other CompletableSource completes
as well.
|
Observable<T> |
Observable.mergeWith(MaybeSource<? extends T> other)
Merges the sequence of items of this Observable with the success value of the other MaybeSource
or waits both to complete normally if the MaybeSource is empty.
|
Flowable<T> |
Flowable.mergeWith(MaybeSource<? extends T> other)
Merges the sequence of items of this Flowable with the success value of the other MaybeSource
or waits for both to complete normally if the MaybeSource is empty.
|
Observable<T> |
Observable.mergeWith(SingleSource<? extends T> other)
Merges the sequence of items of this Observable with the success value of the other SingleSource.
|
Flowable<T> |
Flowable.mergeWith(SingleSource<? extends T> other)
Merges the sequence of items of this Flowable with the success value of the other SingleSource.
|
long |
Scheduler.now(TimeUnit unit)
Returns the 'current time' of the Scheduler in the specified time unit.
|
long |
Scheduler.Worker.now(TimeUnit unit)
Returns the 'current time' of the Worker in the specified time unit.
|
void |
SingleObserver.onError(Throwable e)
Notifies the SingleObserver that the
Single has experienced an error condition. |
void |
SingleEmitter.onError(Throwable t)
Signal an exception.
|
void |
Observer.onError(Throwable e)
Notifies the Observer that the
Observable has experienced an error condition. |
void |
MaybeObserver.onError(Throwable e)
Notifies the MaybeObserver that the
Maybe has experienced an error condition. |
void |
MaybeEmitter.onError(Throwable t)
Signal an exception.
|
void |
Emitter.onError(Throwable error)
Signal a Throwable exception.
|
void |
CompletableObserver.onError(Throwable e)
Called once if the deferred computation 'throws' an exception.
|
void |
CompletableEmitter.onError(Throwable t)
Signal an exception.
|
void |
Observer.onNext(T t)
Provides the Observer with a new item to observe.
|
void |
Emitter.onNext(T value)
Signal a normal value.
|
void |
SingleObserver.onSubscribe(Disposable d)
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. |
void |
Observer.onSubscribe(Disposable d)
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. |
void |
MaybeObserver.onSubscribe(Disposable d)
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. |
void |
CompletableObserver.onSubscribe(Disposable d)
Called once by the Completable to set a Disposable on this instance which
then can be used to cancel the subscription at any time.
|
void |
FlowableSubscriber.onSubscribe(org.reactivestreams.Subscription s)
Implementors of this method should make sure everything that needs
to be visible in
Subscriber.onNext(Object) is established before
calling Subscription.request(long) . |
void |
SingleObserver.onSuccess(T t)
Notifies the SingleObserver with a single item and that the
Single has finished sending
push-based notifications. |
void |
SingleEmitter.onSuccess(T t)
Signal a success value.
|
void |
MaybeObserver.onSuccess(T t)
Notifies the MaybeObserver with one item and that the
Maybe has finished sending
push-based notifications. |
void |
MaybeEmitter.onSuccess(T t)
Signal a success value.
|
Disposable |
Scheduler.Worker.schedule(Runnable run)
Schedules a Runnable for execution without any time delay.
|
abstract Disposable |
Scheduler.Worker.schedule(Runnable run,
long delay,
TimeUnit unit)
Schedules an Runnable for execution at some point in the future specified by a time delay
relative to the current time.
|
abstract Disposable |
Scheduler.Worker.schedule(Runnable run,
long delay,
TimeUnit unit)
Schedules an Runnable for execution at some point in the future specified by a time delay
relative to the current time.
|
Disposable |
Scheduler.scheduleDirect(Runnable run)
Schedules the given task on this Scheduler without any time delay.
|
Disposable |
Scheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit)
Schedules the execution of the given task with the given time delay.
|
Disposable |
Scheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit)
Schedules the execution of the given task with the given time delay.
|
Disposable |
Scheduler.Worker.schedulePeriodically(Runnable run,
long initialDelay,
long period,
TimeUnit unit)
Schedules a periodic execution of the given task with the given initial time delay and repeat period.
|
Disposable |
Scheduler.Worker.schedulePeriodically(Runnable run,
long initialDelay,
long period,
TimeUnit unit)
Schedules a periodic execution of the given task with the given initial time delay and repeat period.
|
Disposable |
Scheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit)
Schedules a periodic execution of the given task with the given initial time delay and repeat period.
|
Disposable |
Scheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit)
Schedules a periodic execution of the given task with the given initial time delay and repeat period.
|
void |
CompletableOnSubscribe.subscribe(CompletableEmitter emitter)
Called for each CompletableObserver that subscribes.
|
void |
CompletableSource.subscribe(CompletableObserver co)
Subscribes the given CompletableObserver to this CompletableSource instance.
|
void |
FlowableOnSubscribe.subscribe(FlowableEmitter<T> emitter)
Called for each Subscriber that subscribes.
|
void |
MaybeOnSubscribe.subscribe(MaybeEmitter<T> emitter)
Called for each MaybeObserver that subscribes.
|
void |
MaybeSource.subscribe(MaybeObserver<? super T> observer)
Subscribes the given MaybeObserver to this MaybeSource instance.
|
void |
ObservableOnSubscribe.subscribe(ObservableEmitter<T> emitter)
Called for each Observer that subscribes.
|
void |
ObservableSource.subscribe(Observer<? super T> observer)
Subscribes the given Observer to this ObservableSource instance.
|
void |
SingleOnSubscribe.subscribe(SingleEmitter<T> emitter)
Called for each SingleObserver that subscribes.
|
void |
SingleSource.subscribe(SingleObserver<? super T> observer)
Subscribes the given SingleObserver to this SingleSource instance.
|
protected abstract void |
Single.subscribeActual(SingleObserver<? super T> observer)
Implement this method in subclasses to handle the incoming
SingleObserver s. |
Flowable<T> |
Flowable.subscribeOn(Scheduler scheduler)
Asynchronously subscribes Subscribers to this Publisher on the specified
Scheduler . |
Flowable<T> |
Flowable.subscribeOn(Scheduler scheduler,
boolean requestOn)
|
Completable |
Observable.switchMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running. |
Completable |
Flowable.switchMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running. |
Completable |
Observable.switchMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running and delaying any main or inner errors until all
of them terminate. |
Completable |
Flowable.switchMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running and delaying any main or inner errors until all
of them terminate. |
<R> Observable<R> |
Observable.switchMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available while failing immediately if this Observable or any of the
active inner MaybeSource s fail. |
<R> Flowable<R> |
Flowable.switchMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available while failing immediately if this Flowable or any of the
active inner MaybeSource s fail. |
<R> Observable<R> |
Observable.switchMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available, delaying errors from this Observable or the inner MaybeSource s until all terminate. |
<R> Flowable<R> |
Flowable.switchMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available, delaying errors from this Flowable or the inner MaybeSource s until all terminate. |
<R> Observable<R> |
Observable.switchMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
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.
|
<R> Flowable<R> |
Flowable.switchMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one
while failing immediately if this Flowable or any of the
active inner SingleSource s fail. |
<R> Observable<R> |
Observable.switchMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
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.
|
<R> Flowable<R> |
Flowable.switchMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one,
delaying errors from this Flowable or the inner SingleSource s until all terminate. |
boolean |
SingleEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
boolean |
ObservableEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
boolean |
MaybeEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
boolean |
FlowableEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
boolean |
CompletableEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
<S extends Scheduler & Disposable> |
Scheduler.when(Function<Flowable<Flowable<Completable>>,Completable> combine)
Allows the use of operators for controlling the timing around when
actions scheduled on workers are actually done.
|
Modifier and Type | Method and Description |
---|---|
static Disposable |
Disposables.disposed()
Returns a disposed Disposable instance.
|
static Disposable |
Disposables.empty()
Returns a new, non-disposed Disposable instance.
|
static Disposable |
Disposables.fromAction(Action run)
Construct a Disposable by wrapping a Action that is
executed exactly once when the Disposable is disposed.
|
static Disposable |
Disposables.fromFuture(Future<?> future)
Construct a Disposable by wrapping a Future that is
cancelled exactly once when the Disposable is disposed.
|
static Disposable |
Disposables.fromFuture(Future<?> future,
boolean allowInterrupt)
Construct a Disposable by wrapping a Future that is
cancelled exactly once when the Disposable is disposed.
|
static Disposable |
Disposables.fromRunnable(Runnable run)
Construct a Disposable by wrapping a Runnable that is
executed exactly once when the Disposable is disposed.
|
static Disposable |
Disposables.fromSubscription(org.reactivestreams.Subscription subscription)
Construct a Disposable by wrapping a Subscription that is
cancelled exactly once when the Disposable is disposed.
|
Modifier and Type | Method and Description |
---|---|
boolean |
CompositeDisposable.add(Disposable d)
Adds a disposable to this container or disposes it if the
container has been disposed.
|
boolean |
CompositeDisposable.addAll(Disposable... ds)
Atomically adds the given array of Disposables to the container or
disposes them all if the container has been disposed.
|
boolean |
CompositeDisposable.delete(Disposable d)
Removes (but does not dispose) the given disposable if it is part of this
container.
|
static Disposable |
Disposables.fromAction(Action run)
Construct a Disposable by wrapping a Action that is
executed exactly once when the Disposable is disposed.
|
static Disposable |
Disposables.fromFuture(Future<?> future)
Construct a Disposable by wrapping a Future that is
cancelled exactly once when the Disposable is disposed.
|
static Disposable |
Disposables.fromFuture(Future<?> future,
boolean allowInterrupt)
Construct a Disposable by wrapping a Future that is
cancelled exactly once when the Disposable is disposed.
|
static Disposable |
Disposables.fromRunnable(Runnable run)
Construct a Disposable by wrapping a Runnable that is
executed exactly once when the Disposable is disposed.
|
static Disposable |
Disposables.fromSubscription(org.reactivestreams.Subscription subscription)
Construct a Disposable by wrapping a Subscription that is
cancelled exactly once when the Disposable is disposed.
|
boolean |
CompositeDisposable.remove(Disposable d)
Removes and disposes the given disposable if it is part of this
container.
|
Constructor and Description |
---|
CompositeDisposable(Disposable... resources)
Creates a CompositeDisposables with the given array of initial elements.
|
CompositeDisposable(Iterable<? extends Disposable> resources)
Creates a CompositeDisposables with the given Iterable sequence of initial elements.
|
Modifier and Type | Method and Description |
---|---|
Throwable |
CompositeException.getCause() |
List<Throwable> |
CompositeException.getExceptions()
Retrieves the list of exceptions that make up the
CompositeException . |
String |
CompositeException.getMessage() |
static RuntimeException |
Exceptions.propagate(Throwable t)
Convenience method to throw a
RuntimeException and Error directly
or wrap any other exception type into a RuntimeException . |
Modifier and Type | Method and Description |
---|---|
static RuntimeException |
Exceptions.propagate(Throwable t)
Convenience method to throw a
RuntimeException and Error directly
or wrap any other exception type into a RuntimeException . |
static void |
Exceptions.throwIfFatal(Throwable t)
Throws a particular
Throwable only if it belongs to a set of "fatal" error varieties. |
Constructor and Description |
---|
CompositeException(Iterable<? extends Throwable> errors)
Constructs a CompositeException with the given array of Throwables as the
list of suppressed exceptions.
|
CompositeException(Throwable... exceptions)
Constructs a CompositeException with the given array of Throwables as the
list of suppressed exceptions.
|
OnErrorNotImplementedException(String message,
Throwable e)
Customizes the
Throwable with a custom message and wraps it before it
is signalled to the RxJavaPlugins.onError() handler as OnErrorNotImplementedException . |
OnErrorNotImplementedException(Throwable e)
Wraps the
Throwable before it
is signalled to the RxJavaPlugins.onError()
handler as OnErrorNotImplementedException . |
Modifier and Type | Method and Description |
---|---|
Flowable<T> |
ConnectableFlowable.autoConnect()
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable
when the first Subscriber subscribes.
|
Flowable<T> |
ConnectableFlowable.autoConnect(int numberOfSubscribers)
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable
when the specified number of Subscribers subscribe to it.
|
Flowable<T> |
ConnectableFlowable.autoConnect(int numberOfSubscribers,
Consumer<? super Disposable> connection)
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable
when the specified number of Subscribers subscribe to it and calls the
specified callback with the Subscription associated with the established connection.
|
Flowable<T> |
ConnectableFlowable.refCount()
Returns a
Flowable that stays connected to this ConnectableFlowable as long as there
is at least one subscription to this ConnectableFlowable . |
Modifier and Type | Method and Description |
---|---|
Flowable<T> |
ConnectableFlowable.autoConnect(int numberOfSubscribers,
Consumer<? super Disposable> connection)
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable
when the specified number of Subscribers subscribe to it and calls the
specified callback with the Subscription associated with the established connection.
|
abstract void |
ConnectableFlowable.connect(Consumer<? super Disposable> connection)
Instructs the
ConnectableFlowable to begin emitting the items from its underlying
Flowable to its Subscriber s. |
Modifier and Type | Method and Description |
---|---|
T |
IntFunction.apply(int i)
Calculates a value based on a primitive integer input.
|
R |
BiFunction.apply(T1 t1,
T2 t2)
Calculate a value based on the input values.
|
R |
Function3.apply(T1 t1,
T2 t2,
T3 t3)
Calculate a value based on the input values.
|
R |
Function4.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Calculate a value based on the input values.
|
R |
Function5.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Calculate a value based on the input values.
|
R |
Function6.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Calculate a value based on the input values.
|
R |
Function7.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
Modifier and Type | Method and Description |
---|---|
R |
Function.apply(T t)
Apply some calculation to the input value and return some other value.
|
R |
BiFunction.apply(T1 t1,
T2 t2)
Calculate a value based on the input values.
|
R |
BiFunction.apply(T1 t1,
T2 t2)
Calculate a value based on the input values.
|
R |
Function3.apply(T1 t1,
T2 t2,
T3 t3)
Calculate a value based on the input values.
|
R |
Function3.apply(T1 t1,
T2 t2,
T3 t3)
Calculate a value based on the input values.
|
R |
Function3.apply(T1 t1,
T2 t2,
T3 t3)
Calculate a value based on the input values.
|
R |
Function4.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Calculate a value based on the input values.
|
R |
Function4.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Calculate a value based on the input values.
|
R |
Function4.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Calculate a value based on the input values.
|
R |
Function4.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Calculate a value based on the input values.
|
R |
Function5.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Calculate a value based on the input values.
|
R |
Function5.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Calculate a value based on the input values.
|
R |
Function5.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Calculate a value based on the input values.
|
R |
Function5.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Calculate a value based on the input values.
|
R |
Function5.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Calculate a value based on the input values.
|
R |
Function6.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Calculate a value based on the input values.
|
R |
Function6.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Calculate a value based on the input values.
|
R |
Function6.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Calculate a value based on the input values.
|
R |
Function6.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Calculate a value based on the input values.
|
R |
Function6.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Calculate a value based on the input values.
|
R |
Function6.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Calculate a value based on the input values.
|
R |
Function7.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Calculate a value based on the input values.
|
R |
Function7.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Calculate a value based on the input values.
|
R |
Function7.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Calculate a value based on the input values.
|
R |
Function7.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Calculate a value based on the input values.
|
R |
Function7.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Calculate a value based on the input values.
|
R |
Function7.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Calculate a value based on the input values.
|
R |
Function7.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function8.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
R |
Function9.apply(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9)
Calculate a value based on the input values.
|
boolean |
Predicate.test(T t)
Test the given input value and return a boolean.
|
boolean |
BiPredicate.test(T1 t1,
T2 t2)
Test the given input values and return a boolean.
|
boolean |
BiPredicate.test(T1 t1,
T2 t2)
Test the given input values and return a boolean.
|
Modifier and Type | Method and Description |
---|---|
boolean |
SimpleQueue.offer(T value)
Atomically enqueue a single.
|
boolean |
SimpleQueue.offer(T v1,
T v2)
Atomically enqueue two values.
|
boolean |
SimpleQueue.offer(T v1,
T v2)
Atomically enqueue two values.
|
Constructor and Description |
---|
FlowableCombineLatest(Iterable<? extends org.reactivestreams.Publisher<? extends T>> iterable,
Function<? super Object[],? extends R> combiner,
int bufferSize,
boolean delayErrors) |
FlowableCombineLatest(Iterable<? extends org.reactivestreams.Publisher<? extends T>> iterable,
Function<? super Object[],? extends R> combiner,
int bufferSize,
boolean delayErrors) |
FlowableCombineLatest(org.reactivestreams.Publisher<? extends T>[] array,
Function<? super Object[],? extends R> combiner,
int bufferSize,
boolean delayErrors) |
FlowableCombineLatest(org.reactivestreams.Publisher<? extends T>[] array,
Function<? super Object[],? extends R> combiner,
int bufferSize,
boolean delayErrors) |
FlowableWithLatestFromMany(Flowable<T> source,
Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable,
Function<? super Object[],R> combiner) |
FlowableWithLatestFromMany(Flowable<T> source,
Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable,
Function<? super Object[],R> combiner) |
FlowableWithLatestFromMany(Flowable<T> source,
Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable,
Function<? super Object[],R> combiner) |
FlowableWithLatestFromMany(Flowable<T> source,
org.reactivestreams.Publisher<?>[] otherArray,
Function<? super Object[],R> combiner) |
FlowableWithLatestFromMany(Flowable<T> source,
org.reactivestreams.Publisher<?>[] otherArray,
Function<? super Object[],R> combiner) |
Constructor and Description |
---|
ObservableWithLatestFromMany(ObservableSource<T> source,
Iterable<? extends ObservableSource<?>> otherIterable,
Function<? super Object[],R> combiner) |
ObservableWithLatestFromMany(ObservableSource<T> source,
Iterable<? extends ObservableSource<?>> otherIterable,
Function<? super Object[],R> combiner) |
ObservableWithLatestFromMany(ObservableSource<T> source,
Iterable<? extends ObservableSource<?>> otherIterable,
Function<? super Object[],R> combiner) |
ObservableWithLatestFromMany(ObservableSource<T> source,
ObservableSource<?>[] otherArray,
Function<? super Object[],R> combiner) |
ObservableWithLatestFromMany(ObservableSource<T> source,
ObservableSource<?>[] otherArray,
Function<? super Object[],R> combiner) |
ObservableWithLatestFromMany(ObservableSource<T> source,
ObservableSource<?>[] otherArray,
Function<? super Object[],R> combiner) |
Modifier and Type | Method and Description |
---|---|
Scheduler.Worker |
TrampolineScheduler.createWorker() |
Scheduler.Worker |
SingleScheduler.createWorker() |
Scheduler.Worker |
SchedulerWhen.createWorker() |
Scheduler.Worker |
NewThreadScheduler.createWorker() |
Scheduler.Worker |
IoScheduler.createWorker() |
Scheduler.Worker |
ImmediateThinScheduler.createWorker() |
Scheduler.Worker |
ExecutorScheduler.createWorker() |
Scheduler.Worker |
ComputationScheduler.createWorker() |
Disposable |
NewThreadWorker.schedule(Runnable run) |
Disposable |
ExecutorScheduler.ExecutorWorker.schedule(Runnable run) |
Disposable |
NewThreadWorker.schedule(Runnable action,
long delayTime,
TimeUnit unit) |
Disposable |
ExecutorScheduler.ExecutorWorker.schedule(Runnable run,
long delay,
TimeUnit unit) |
ScheduledRunnable |
NewThreadWorker.scheduleActual(Runnable run,
long delayTime,
TimeUnit unit,
DisposableContainer parent)
Wraps the given runnable into a ScheduledRunnable and schedules it
on the underlying ScheduledExecutorService.
|
Disposable |
TrampolineScheduler.scheduleDirect(Runnable run) |
Disposable |
ImmediateThinScheduler.scheduleDirect(Runnable run) |
Disposable |
ExecutorScheduler.scheduleDirect(Runnable run) |
Disposable |
TrampolineScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
SingleScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
ImmediateThinScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
ExecutorScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
ComputationScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
SingleScheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit) |
Disposable |
ImmediateThinScheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit) |
Disposable |
ExecutorScheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit) |
Disposable |
ComputationScheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit) |
Modifier and Type | Method and Description |
---|---|
void |
SchedulerMultiWorkerSupport.createWorkers(int number,
SchedulerMultiWorkerSupport.WorkerCallback callback)
Creates the given number of
Scheduler.Worker instances
that are possibly backed by distinct threads
and calls the specified Consumer with them. |
void |
SchedulerMultiWorkerSupport.WorkerCallback.onWorker(int index,
Scheduler.Worker worker)
Called with the Worker index and instance.
|
Disposable |
NewThreadWorker.schedule(Runnable run) |
Disposable |
ExecutorScheduler.ExecutorWorker.schedule(Runnable run) |
Disposable |
NewThreadWorker.schedule(Runnable action,
long delayTime,
TimeUnit unit) |
Disposable |
NewThreadWorker.schedule(Runnable action,
long delayTime,
TimeUnit unit) |
Disposable |
ExecutorScheduler.ExecutorWorker.schedule(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
ExecutorScheduler.ExecutorWorker.schedule(Runnable run,
long delay,
TimeUnit unit) |
ScheduledRunnable |
NewThreadWorker.scheduleActual(Runnable run,
long delayTime,
TimeUnit unit,
DisposableContainer parent)
Wraps the given runnable into a ScheduledRunnable and schedules it
on the underlying ScheduledExecutorService.
|
Disposable |
TrampolineScheduler.scheduleDirect(Runnable run) |
Disposable |
ImmediateThinScheduler.scheduleDirect(Runnable run) |
Disposable |
ExecutorScheduler.scheduleDirect(Runnable run) |
Disposable |
TrampolineScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
SingleScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
ImmediateThinScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
ExecutorScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
ComputationScheduler.scheduleDirect(Runnable run,
long delay,
TimeUnit unit) |
Disposable |
SingleScheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit) |
Disposable |
ImmediateThinScheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit) |
Disposable |
ExecutorScheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit) |
Disposable |
ComputationScheduler.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit) |
Constructor and Description |
---|
ExecutorScheduler(Executor executor) |
Modifier and Type | Method and Description |
---|---|
Observable<T> |
ConnectableObservable.autoConnect()
Returns an Observable that automatically connects (at most once) to this ConnectableObservable
when the first Observer subscribes.
|
Observable<T> |
ConnectableObservable.autoConnect(int numberOfSubscribers)
Returns an Observable that automatically connects (at most once) to this ConnectableObservable
when the specified number of Observers subscribe to it.
|
Observable<T> |
ConnectableObservable.autoConnect(int numberOfSubscribers,
Consumer<? super Disposable> connection)
Returns an Observable that automatically connects (at most once) 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.
|
Observable<T> |
ConnectableObservable.refCount()
Returns an
Observable that stays connected to this ConnectableObservable as long as there
is at least one subscription to this ConnectableObservable . |
Modifier and Type | Method and Description |
---|---|
Observable<T> |
ConnectableObservable.autoConnect(int numberOfSubscribers,
Consumer<? super Disposable> connection)
Returns an Observable that automatically connects (at most once) 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.
|
abstract void |
ConnectableObservable.connect(Consumer<? super Disposable> connection)
Instructs the
ConnectableObservable to begin emitting the items from its underlying
Observable to its Observer s. |
Modifier and Type | Method and Description |
---|---|
void |
ResourceSingleObserver.add(Disposable resource)
Adds a resource to this ResourceObserver.
|
void |
ResourceObserver.add(Disposable resource)
Adds a resource to this ResourceObserver.
|
void |
ResourceMaybeObserver.add(Disposable resource)
Adds a resource to this ResourceObserver.
|
void |
ResourceCompletableObserver.add(Disposable resource)
Adds a resource to this ResourceObserver.
|
void |
SerializedObserver.onError(Throwable t) |
void |
SafeObserver.onError(Throwable t) |
void |
SerializedObserver.onNext(T t) |
void |
SafeObserver.onNext(T t) |
void |
SerializedObserver.onSubscribe(Disposable d) |
void |
SafeObserver.onSubscribe(Disposable d) |
void |
ResourceSingleObserver.onSubscribe(Disposable d) |
void |
ResourceMaybeObserver.onSubscribe(Disposable d) |
void |
ResourceCompletableObserver.onSubscribe(Disposable d) |
void |
DisposableSingleObserver.onSubscribe(Disposable d) |
void |
DisposableObserver.onSubscribe(Disposable d) |
void |
DisposableMaybeObserver.onSubscribe(Disposable d) |
void |
DisposableCompletableObserver.onSubscribe(Disposable d) |
void |
DefaultObserver.onSubscribe(Disposable d) |
Constructor and Description |
---|
SafeObserver(Observer<? super T> downstream)
Constructs a SafeObserver by wrapping the given actual Observer.
|
SerializedObserver(Observer<? super T> downstream)
Construct a SerializedObserver by wrapping the given actual Observer.
|
SerializedObserver(Observer<? super T> actual,
boolean delayError)
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.
|
Modifier and Type | Method and Description |
---|---|
R |
ParallelFlowableConverter.apply(ParallelFlowable<T> upstream)
Applies a function to the upstream ParallelFlowable and returns a converted value of type
R . |
ParallelFlowable<Downstream> |
ParallelTransformer.apply(ParallelFlowable<Upstream> upstream)
Applies a function to the upstream ParallelFlowable and returns a ParallelFlowable with
optionally different element type.
|
<R> R |
ParallelFlowable.as(ParallelFlowableConverter<T,R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<C> ParallelFlowable<C> |
ParallelFlowable.collect(Callable<? extends C> collectionSupplier,
BiConsumer<? super C,? super T> collector)
Collect the elements in each rail into a collection supplied via a collectionSupplier
and collected into with a collector action, emitting the collection at the end.
|
<U> ParallelFlowable<U> |
ParallelFlowable.compose(ParallelTransformer<T,U> composer)
Allows composing operators, in assembly time, on top of this ParallelFlowable
and returns another ParallelFlowable with composed features.
|
<R> ParallelFlowable<R> |
ParallelFlowable.concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Generates and concatenates Publishers on each 'rail', signalling errors immediately
and generating 2 publishers upfront.
|
<R> ParallelFlowable<R> |
ParallelFlowable.concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch)
Generates and concatenates Publishers on each 'rail', signalling errors immediately
and using the given prefetch amount for generating Publishers upfront.
|
<R> ParallelFlowable<R> |
ParallelFlowable.concatMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean tillTheEnd)
Generates and concatenates Publishers on each 'rail', optionally delaying errors
and generating 2 publishers upfront.
|
<R> ParallelFlowable<R> |
ParallelFlowable.concatMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch,
boolean tillTheEnd)
Generates and concatenates Publishers on each 'rail', optionally delaying errors
and using the given prefetch amount for generating Publishers upfront.
|
ParallelFlowable<T> |
ParallelFlowable.doAfterNext(Consumer<? super T> onAfterNext)
Call the specified consumer with the current element passing through any 'rail'
after it has been delivered to downstream within the rail.
|
ParallelFlowable<T> |
ParallelFlowable.doAfterTerminated(Action onAfterTerminate)
Run the specified Action when a 'rail' completes or signals an error.
|
ParallelFlowable<T> |
ParallelFlowable.doOnCancel(Action onCancel)
Run the specified Action when a 'rail' receives a cancellation.
|
ParallelFlowable<T> |
ParallelFlowable.doOnComplete(Action onComplete)
Run the specified Action when a 'rail' completes.
|
ParallelFlowable<T> |
ParallelFlowable.doOnError(Consumer<Throwable> onError)
Call the specified consumer with the exception passing through any 'rail'.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext)
Call the specified consumer with the current element passing through any 'rail'.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Call the specified consumer with the current element passing through any 'rail' and
handles errors based on the returned value by the handler function.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext,
ParallelFailureHandling errorHandler)
Call the specified consumer with the current element passing through any 'rail' and
handles errors based on the given
ParallelFailureHandling enumeration value. |
ParallelFlowable<T> |
ParallelFlowable.doOnRequest(LongConsumer onRequest)
Call the specified consumer with the request amount if any rail receives a request.
|
ParallelFlowable<T> |
ParallelFlowable.doOnSubscribe(Consumer<? super org.reactivestreams.Subscription> onSubscribe)
Call the specified callback when a 'rail' receives a Subscription from its upstream.
|
<R> ParallelFlowable<R> |
ParallelFlowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Generates and flattens Publishers on each 'rail'.
|
<R> ParallelFlowable<R> |
ParallelFlowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayError)
Generates and flattens Publishers on each 'rail', optionally delaying errors.
|
<R> ParallelFlowable<R> |
ParallelFlowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayError,
int maxConcurrency)
Generates and flattens Publishers on each 'rail', optionally delaying errors
and having a total number of simultaneous subscriptions to the inner Publishers.
|
<R> ParallelFlowable<R> |
ParallelFlowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayError,
int maxConcurrency,
int prefetch)
Generates and flattens Publishers on each 'rail', optionally delaying errors,
having a total number of simultaneous subscriptions to the inner Publishers
and using the given prefetch amount for the inner Publishers.
|
static <T> ParallelFlowable<T> |
ParallelFlowable.from(org.reactivestreams.Publisher<? extends T> source,
int parallelism,
int prefetch)
Take a Publisher and prepare to consume it on parallelism number of 'rails' ,
possibly ordered and round-robin fashion and use custom prefetch amount and queue
for dealing with the source Publisher's values.
|
static <T> ParallelFlowable<T> |
ParallelFlowable.fromArray(org.reactivestreams.Publisher<T>... publishers)
Wraps multiple Publishers into a ParallelFlowable which runs them
in parallel and unordered.
|
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper)
Maps the source values on each 'rail' to another value.
|
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Maps the source values on each 'rail' to another value and
handles errors based on the returned value by the handler function.
|
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper,
ParallelFailureHandling errorHandler)
Maps the source values on each 'rail' to another value and
handles errors based on the given
ParallelFailureHandling enumeration value. |
Flowable<T> |
ParallelFlowable.reduce(BiFunction<T,T,T> reducer)
Reduces all values within a 'rail' and across 'rails' with a reducer function into a single
sequential value.
|
<R> ParallelFlowable<R> |
ParallelFlowable.reduce(Callable<R> initialSupplier,
BiFunction<R,? super T,R> reducer)
Reduces all values within a 'rail' to a single value (with a possibly different type) via
a reducer function that is initialized on each rail from an initialSupplier value.
|
ParallelFlowable<T> |
ParallelFlowable.runOn(Scheduler scheduler)
Specifies where each 'rail' will observe its incoming values with
no work-stealing and default prefetch amount.
|
ParallelFlowable<T> |
ParallelFlowable.runOn(Scheduler scheduler,
int prefetch)
Specifies where each 'rail' will observe its incoming values with
possibly work-stealing and a given prefetch amount.
|
Flowable<T> |
ParallelFlowable.sequential(int prefetch)
Merges the values from each 'rail' in a round-robin or same-order fashion and
exposes it as a regular Publisher sequence, running with a give prefetch value
for the rails.
|
Flowable<T> |
ParallelFlowable.sequentialDelayError()
Merges the values from each 'rail' in a round-robin or same-order fashion and
exposes it as a regular Flowable sequence, running with a default prefetch value
for the rails and delaying errors from all rails till all terminate.
|
Flowable<T> |
ParallelFlowable.sequentialDelayError(int prefetch)
Merges the values from each 'rail' in a round-robin or same-order fashion and
exposes it as a regular Publisher sequence, running with a give prefetch value
for the rails and delaying errors from all rails till all terminate.
|
Flowable<T> |
ParallelFlowable.sorted(Comparator<? super T> comparator)
Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially
picks the smallest next value from the rails.
|
Flowable<T> |
ParallelFlowable.sorted(Comparator<? super T> comparator,
int capacityHint)
Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially
picks the smallest next value from the rails.
|
<U> U |
ParallelFlowable.to(Function<? super ParallelFlowable<T>,U> converter)
Perform a fluent transformation to a value via a converter function which
receives this ParallelFlowable.
|
Flowable<List<T>> |
ParallelFlowable.toSortedList(Comparator<? super T> comparator)
Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
|
Flowable<List<T>> |
ParallelFlowable.toSortedList(Comparator<? super T> comparator,
int capacityHint)
Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
|
Modifier and Type | Method and Description |
---|---|
R |
ParallelFlowableConverter.apply(ParallelFlowable<T> upstream)
Applies a function to the upstream ParallelFlowable and returns a converted value of type
R . |
ParallelFlowable<Downstream> |
ParallelTransformer.apply(ParallelFlowable<Upstream> upstream)
Applies a function to the upstream ParallelFlowable and returns a ParallelFlowable with
optionally different element type.
|
<R> R |
ParallelFlowable.as(ParallelFlowableConverter<T,R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<C> ParallelFlowable<C> |
ParallelFlowable.collect(Callable<? extends C> collectionSupplier,
BiConsumer<? super C,? super T> collector)
Collect the elements in each rail into a collection supplied via a collectionSupplier
and collected into with a collector action, emitting the collection at the end.
|
<C> ParallelFlowable<C> |
ParallelFlowable.collect(Callable<? extends C> collectionSupplier,
BiConsumer<? super C,? super T> collector)
Collect the elements in each rail into a collection supplied via a collectionSupplier
and collected into with a collector action, emitting the collection at the end.
|
<U> ParallelFlowable<U> |
ParallelFlowable.compose(ParallelTransformer<T,U> composer)
Allows composing operators, in assembly time, on top of this ParallelFlowable
and returns another ParallelFlowable with composed features.
|
<R> ParallelFlowable<R> |
ParallelFlowable.concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Generates and concatenates Publishers on each 'rail', signalling errors immediately
and generating 2 publishers upfront.
|
<R> ParallelFlowable<R> |
ParallelFlowable.concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch)
Generates and concatenates Publishers on each 'rail', signalling errors immediately
and using the given prefetch amount for generating Publishers upfront.
|
<R> ParallelFlowable<R> |
ParallelFlowable.concatMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean tillTheEnd)
Generates and concatenates Publishers on each 'rail', optionally delaying errors
and generating 2 publishers upfront.
|
<R> ParallelFlowable<R> |
ParallelFlowable.concatMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch,
boolean tillTheEnd)
Generates and concatenates Publishers on each 'rail', optionally delaying errors
and using the given prefetch amount for generating Publishers upfront.
|
ParallelFlowable<T> |
ParallelFlowable.doAfterNext(Consumer<? super T> onAfterNext)
Call the specified consumer with the current element passing through any 'rail'
after it has been delivered to downstream within the rail.
|
ParallelFlowable<T> |
ParallelFlowable.doAfterTerminated(Action onAfterTerminate)
Run the specified Action when a 'rail' completes or signals an error.
|
ParallelFlowable<T> |
ParallelFlowable.doOnCancel(Action onCancel)
Run the specified Action when a 'rail' receives a cancellation.
|
ParallelFlowable<T> |
ParallelFlowable.doOnComplete(Action onComplete)
Run the specified Action when a 'rail' completes.
|
ParallelFlowable<T> |
ParallelFlowable.doOnError(Consumer<Throwable> onError)
Call the specified consumer with the exception passing through any 'rail'.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext)
Call the specified consumer with the current element passing through any 'rail'.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Call the specified consumer with the current element passing through any 'rail' and
handles errors based on the returned value by the handler function.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Call the specified consumer with the current element passing through any 'rail' and
handles errors based on the returned value by the handler function.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext,
ParallelFailureHandling errorHandler)
Call the specified consumer with the current element passing through any 'rail' and
handles errors based on the given
ParallelFailureHandling enumeration value. |
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext,
ParallelFailureHandling errorHandler)
Call the specified consumer with the current element passing through any 'rail' and
handles errors based on the given
ParallelFailureHandling enumeration value. |
ParallelFlowable<T> |
ParallelFlowable.doOnRequest(LongConsumer onRequest)
Call the specified consumer with the request amount if any rail receives a request.
|
ParallelFlowable<T> |
ParallelFlowable.doOnSubscribe(Consumer<? super org.reactivestreams.Subscription> onSubscribe)
Call the specified callback when a 'rail' receives a Subscription from its upstream.
|
ParallelFlowable<T> |
ParallelFlowable.filter(Predicate<? super T> predicate)
Filters the source values on each 'rail'.
|
ParallelFlowable<T> |
ParallelFlowable.filter(Predicate<? super T> predicate,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Filters the source values on each 'rail' and
handles errors based on the returned value by the handler function.
|
ParallelFlowable<T> |
ParallelFlowable.filter(Predicate<? super T> predicate,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Filters the source values on each 'rail' and
handles errors based on the returned value by the handler function.
|
ParallelFlowable<T> |
ParallelFlowable.filter(Predicate<? super T> predicate,
ParallelFailureHandling errorHandler)
Filters the source values on each 'rail' and
handles errors based on the given
ParallelFailureHandling enumeration value. |
ParallelFlowable<T> |
ParallelFlowable.filter(Predicate<? super T> predicate,
ParallelFailureHandling errorHandler)
Filters the source values on each 'rail' and
handles errors based on the given
ParallelFailureHandling enumeration value. |
<R> ParallelFlowable<R> |
ParallelFlowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Generates and flattens Publishers on each 'rail'.
|
<R> ParallelFlowable<R> |
ParallelFlowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayError)
Generates and flattens Publishers on each 'rail', optionally delaying errors.
|
<R> ParallelFlowable<R> |
ParallelFlowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayError,
int maxConcurrency)
Generates and flattens Publishers on each 'rail', optionally delaying errors
and having a total number of simultaneous subscriptions to the inner Publishers.
|
<R> ParallelFlowable<R> |
ParallelFlowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayError,
int maxConcurrency,
int prefetch)
Generates and flattens Publishers on each 'rail', optionally delaying errors,
having a total number of simultaneous subscriptions to the inner Publishers
and using the given prefetch amount for the inner Publishers.
|
static <T> ParallelFlowable<T> |
ParallelFlowable.from(org.reactivestreams.Publisher<? extends T> source)
Take a Publisher and prepare to consume it on multiple 'rails' (number of CPUs)
in a round-robin fashion.
|
static <T> ParallelFlowable<T> |
ParallelFlowable.from(org.reactivestreams.Publisher<? extends T> source,
int parallelism)
Take a Publisher and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.
|
static <T> ParallelFlowable<T> |
ParallelFlowable.from(org.reactivestreams.Publisher<? extends T> source,
int parallelism,
int prefetch)
Take a Publisher and prepare to consume it on parallelism number of 'rails' ,
possibly ordered and round-robin fashion and use custom prefetch amount and queue
for dealing with the source Publisher's values.
|
static <T> ParallelFlowable<T> |
ParallelFlowable.fromArray(org.reactivestreams.Publisher<T>... publishers)
Wraps multiple Publishers into a ParallelFlowable which runs them
in parallel and unordered.
|
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper)
Maps the source values on each 'rail' to another value.
|
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Maps the source values on each 'rail' to another value and
handles errors based on the returned value by the handler function.
|
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Maps the source values on each 'rail' to another value and
handles errors based on the returned value by the handler function.
|
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper,
ParallelFailureHandling errorHandler)
Maps the source values on each 'rail' to another value and
handles errors based on the given
ParallelFailureHandling enumeration value. |
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper,
ParallelFailureHandling errorHandler)
Maps the source values on each 'rail' to another value and
handles errors based on the given
ParallelFailureHandling enumeration value. |
Flowable<T> |
ParallelFlowable.reduce(BiFunction<T,T,T> reducer)
Reduces all values within a 'rail' and across 'rails' with a reducer function into a single
sequential value.
|
<R> ParallelFlowable<R> |
ParallelFlowable.reduce(Callable<R> initialSupplier,
BiFunction<R,? super T,R> reducer)
Reduces all values within a 'rail' to a single value (with a possibly different type) via
a reducer function that is initialized on each rail from an initialSupplier value.
|
<R> ParallelFlowable<R> |
ParallelFlowable.reduce(Callable<R> initialSupplier,
BiFunction<R,? super T,R> reducer)
Reduces all values within a 'rail' to a single value (with a possibly different type) via
a reducer function that is initialized on each rail from an initialSupplier value.
|
ParallelFlowable<T> |
ParallelFlowable.runOn(Scheduler scheduler)
Specifies where each 'rail' will observe its incoming values with
no work-stealing and default prefetch amount.
|
ParallelFlowable<T> |
ParallelFlowable.runOn(Scheduler scheduler,
int prefetch)
Specifies where each 'rail' will observe its incoming values with
possibly work-stealing and a given prefetch amount.
|
Flowable<T> |
ParallelFlowable.sorted(Comparator<? super T> comparator)
Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially
picks the smallest next value from the rails.
|
Flowable<T> |
ParallelFlowable.sorted(Comparator<? super T> comparator,
int capacityHint)
Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially
picks the smallest next value from the rails.
|
abstract void |
ParallelFlowable.subscribe(org.reactivestreams.Subscriber<? super T>[] subscribers)
Subscribes an array of Subscribers to this ParallelFlowable and triggers
the execution chain for all 'rails'.
|
<U> U |
ParallelFlowable.to(Function<? super ParallelFlowable<T>,U> converter)
Perform a fluent transformation to a value via a converter function which
receives this ParallelFlowable.
|
Flowable<List<T>> |
ParallelFlowable.toSortedList(Comparator<? super T> comparator)
Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
|
Flowable<List<T>> |
ParallelFlowable.toSortedList(Comparator<? super T> comparator,
int capacityHint)
Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
|
protected boolean |
ParallelFlowable.validate(org.reactivestreams.Subscriber<?>[] subscribers)
Validates the number of subscribers and returns true if their number
matches the parallelism level of this ParallelFlowable.
|
Modifier and Type | Method and Description |
---|---|
static Scheduler |
RxJavaPlugins.createComputationScheduler(ThreadFactory threadFactory)
Create an instance of the default
Scheduler used for Schedulers.computation()
except using threadFactory for thread creation. |
static Scheduler |
RxJavaPlugins.createIoScheduler(ThreadFactory threadFactory)
Create an instance of the default
Scheduler used for Schedulers.io()
except using threadFactory for thread creation. |
static Scheduler |
RxJavaPlugins.createNewThreadScheduler(ThreadFactory threadFactory)
Create an instance of the default
Scheduler used for Schedulers.newThread()
except using threadFactory for thread creation. |
static Scheduler |
RxJavaPlugins.createSingleScheduler(ThreadFactory threadFactory)
Create an instance of the default
Scheduler used for Schedulers.single()
except using threadFactory for thread creation. |
static Scheduler |
RxJavaPlugins.initComputationScheduler(Callable<Scheduler> defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.initIoScheduler(Callable<Scheduler> defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.initNewThreadScheduler(Callable<Scheduler> defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.initSingleScheduler(Callable<Scheduler> defaultScheduler)
Calls the associated hook function.
|
static Completable |
RxJavaPlugins.onAssembly(Completable source)
Calls the associated hook function.
|
static <T> ConnectableFlowable<T> |
RxJavaPlugins.onAssembly(ConnectableFlowable<T> source)
Calls the associated hook function.
|
static <T> ConnectableObservable<T> |
RxJavaPlugins.onAssembly(ConnectableObservable<T> source)
Calls the associated hook function.
|
static <T> Flowable<T> |
RxJavaPlugins.onAssembly(Flowable<T> source)
Calls the associated hook function.
|
static <T> Maybe<T> |
RxJavaPlugins.onAssembly(Maybe<T> source)
Calls the associated hook function.
|
static <T> Observable<T> |
RxJavaPlugins.onAssembly(Observable<T> source)
Calls the associated hook function.
|
static <T> ParallelFlowable<T> |
RxJavaPlugins.onAssembly(ParallelFlowable<T> source)
Calls the associated hook function.
|
static <T> Single<T> |
RxJavaPlugins.onAssembly(Single<T> source)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.onComputationScheduler(Scheduler defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.onIoScheduler(Scheduler defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.onNewThreadScheduler(Scheduler defaultScheduler)
Calls the associated hook function.
|
static Runnable |
RxJavaPlugins.onSchedule(Runnable run)
Called when a task is scheduled.
|
static Scheduler |
RxJavaPlugins.onSingleScheduler(Scheduler defaultScheduler)
Calls the associated hook function.
|
static CompletableObserver |
RxJavaPlugins.onSubscribe(Completable source,
CompletableObserver observer)
Calls the associated hook function.
|
static <T> org.reactivestreams.Subscriber<? super T> |
RxJavaPlugins.onSubscribe(Flowable<T> source,
org.reactivestreams.Subscriber<? super T> subscriber)
Calls the associated hook function.
|
static <T> MaybeObserver<? super T> |
RxJavaPlugins.onSubscribe(Maybe<T> source,
MaybeObserver<? super T> observer)
Calls the associated hook function.
|
static <T> Observer<? super T> |
RxJavaPlugins.onSubscribe(Observable<T> source,
Observer<? super T> observer)
Calls the associated hook function.
|
static <T> SingleObserver<? super T> |
RxJavaPlugins.onSubscribe(Single<T> source,
SingleObserver<? super T> observer)
Calls the associated hook function.
|
Modifier and Type | Method and Description |
---|---|
static Scheduler |
RxJavaPlugins.createComputationScheduler(ThreadFactory threadFactory)
Create an instance of the default
Scheduler used for Schedulers.computation()
except using threadFactory for thread creation. |
static Scheduler |
RxJavaPlugins.createIoScheduler(ThreadFactory threadFactory)
Create an instance of the default
Scheduler used for Schedulers.io()
except using threadFactory for thread creation. |
static Scheduler |
RxJavaPlugins.createNewThreadScheduler(ThreadFactory threadFactory)
Create an instance of the default
Scheduler used for Schedulers.newThread()
except using threadFactory for thread creation. |
static Scheduler |
RxJavaPlugins.createSingleScheduler(ThreadFactory threadFactory)
Create an instance of the default
Scheduler used for Schedulers.single()
except using threadFactory for thread creation. |
static Scheduler |
RxJavaPlugins.initComputationScheduler(Callable<Scheduler> defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.initIoScheduler(Callable<Scheduler> defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.initNewThreadScheduler(Callable<Scheduler> defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.initSingleScheduler(Callable<Scheduler> defaultScheduler)
Calls the associated hook function.
|
static Completable |
RxJavaPlugins.onAssembly(Completable source)
Calls the associated hook function.
|
static <T> ConnectableFlowable<T> |
RxJavaPlugins.onAssembly(ConnectableFlowable<T> source)
Calls the associated hook function.
|
static <T> ConnectableObservable<T> |
RxJavaPlugins.onAssembly(ConnectableObservable<T> source)
Calls the associated hook function.
|
static <T> Flowable<T> |
RxJavaPlugins.onAssembly(Flowable<T> source)
Calls the associated hook function.
|
static <T> Maybe<T> |
RxJavaPlugins.onAssembly(Maybe<T> source)
Calls the associated hook function.
|
static <T> Observable<T> |
RxJavaPlugins.onAssembly(Observable<T> source)
Calls the associated hook function.
|
static <T> ParallelFlowable<T> |
RxJavaPlugins.onAssembly(ParallelFlowable<T> source)
Calls the associated hook function.
|
static <T> Single<T> |
RxJavaPlugins.onAssembly(Single<T> source)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.onComputationScheduler(Scheduler defaultScheduler)
Calls the associated hook function.
|
static void |
RxJavaPlugins.onError(Throwable error)
Called when an undeliverable error occurs.
|
static Scheduler |
RxJavaPlugins.onIoScheduler(Scheduler defaultScheduler)
Calls the associated hook function.
|
static Scheduler |
RxJavaPlugins.onNewThreadScheduler(Scheduler defaultScheduler)
Calls the associated hook function.
|
static Runnable |
RxJavaPlugins.onSchedule(Runnable run)
Called when a task is scheduled.
|
static Scheduler |
RxJavaPlugins.onSingleScheduler(Scheduler defaultScheduler)
Calls the associated hook function.
|
static CompletableObserver |
RxJavaPlugins.onSubscribe(Completable source,
CompletableObserver observer)
Calls the associated hook function.
|
static CompletableObserver |
RxJavaPlugins.onSubscribe(Completable source,
CompletableObserver observer)
Calls the associated hook function.
|
static <T> org.reactivestreams.Subscriber<? super T> |
RxJavaPlugins.onSubscribe(Flowable<T> source,
org.reactivestreams.Subscriber<? super T> subscriber)
Calls the associated hook function.
|
static <T> org.reactivestreams.Subscriber<? super T> |
RxJavaPlugins.onSubscribe(Flowable<T> source,
org.reactivestreams.Subscriber<? super T> subscriber)
Calls the associated hook function.
|
static <T> MaybeObserver<? super T> |
RxJavaPlugins.onSubscribe(Maybe<T> source,
MaybeObserver<? super T> observer)
Calls the associated hook function.
|
static <T> MaybeObserver<? super T> |
RxJavaPlugins.onSubscribe(Maybe<T> source,
MaybeObserver<? super T> observer)
Calls the associated hook function.
|
static <T> Observer<? super T> |
RxJavaPlugins.onSubscribe(Observable<T> source,
Observer<? super T> observer)
Calls the associated hook function.
|
static <T> Observer<? super T> |
RxJavaPlugins.onSubscribe(Observable<T> source,
Observer<? super T> observer)
Calls the associated hook function.
|
static <T> SingleObserver<? super T> |
RxJavaPlugins.onSubscribe(Single<T> source,
SingleObserver<? super T> observer)
Calls the associated hook function.
|
static <T> SingleObserver<? super T> |
RxJavaPlugins.onSubscribe(Single<T> source,
SingleObserver<? super T> observer)
Calls the associated hook function.
|
Modifier and Type | Method and Description |
---|---|
static <T> UnicastProcessor<T> |
UnicastProcessor.create()
Creates an UnicastSubject with an internal buffer capacity hint 16.
|
static <T> ReplayProcessor<T> |
ReplayProcessor.create()
Creates an unbounded ReplayProcessor.
|
static <T> PublishProcessor<T> |
PublishProcessor.create()
Constructs a PublishProcessor.
|
static <T> MulticastProcessor<T> |
MulticastProcessor.create()
Constructs a fresh instance with the default Flowable.bufferSize() prefetch
amount and no refCount-behavior.
|
static <T> BehaviorProcessor<T> |
BehaviorProcessor.create()
Creates a
BehaviorProcessor without a default item. |
static <T> AsyncProcessor<T> |
AsyncProcessor.create()
Creates a new AsyncProcessor.
|
static <T> UnicastProcessor<T> |
UnicastProcessor.create(boolean delayError)
Creates an UnicastProcessor with default internal buffer capacity hint and delay error flag.
|
static <T> MulticastProcessor<T> |
MulticastProcessor.create(boolean refCount)
Constructs a fresh instance with the default Flowable.bufferSize() prefetch
amount and the optional refCount-behavior.
|
static <T> UnicastProcessor<T> |
UnicastProcessor.create(int capacityHint)
Creates an UnicastProcessor with the given internal buffer capacity hint.
|
static <T> ReplayProcessor<T> |
ReplayProcessor.create(int capacityHint)
Creates an unbounded ReplayProcessor with the specified initial buffer capacity.
|
static <T> MulticastProcessor<T> |
MulticastProcessor.create(int bufferSize)
Constructs a fresh instance with the given prefetch amount and no refCount behavior.
|
static <T> MulticastProcessor<T> |
MulticastProcessor.create(int bufferSize,
boolean refCount)
Constructs a fresh instance with the given prefetch amount and the optional
refCount-behavior.
|
static <T> UnicastProcessor<T> |
UnicastProcessor.create(int capacityHint,
Runnable onCancelled)
Creates an UnicastProcessor with the given internal buffer capacity hint and a callback for
the case when the single Subscriber cancels its subscription.
|
static <T> UnicastProcessor<T> |
UnicastProcessor.create(int capacityHint,
Runnable onCancelled,
boolean delayError)
Creates an UnicastProcessor with the given internal buffer capacity hint, delay error flag and a callback for
the case when the single Subscriber cancels its subscription.
|
static <T> BehaviorProcessor<T> |
BehaviorProcessor.createDefault(T defaultValue)
Creates a
BehaviorProcessor that emits the last item it observed and all subsequent items to each
Subscriber that subscribes to it. |
static <T> ReplayProcessor<T> |
ReplayProcessor.createWithSize(int maxSize)
Creates a size-bounded ReplayProcessor.
|
static <T> ReplayProcessor<T> |
ReplayProcessor.createWithTime(long maxAge,
TimeUnit unit,
Scheduler scheduler)
Creates a time-bounded ReplayProcessor.
|
static <T> ReplayProcessor<T> |
ReplayProcessor.createWithTimeAndSize(long maxAge,
TimeUnit unit,
Scheduler scheduler,
int maxSize)
Creates a time- and size-bounded ReplayProcessor.
|
FlowableProcessor<T> |
FlowableProcessor.toSerialized()
Wraps this FlowableProcessor and serializes the calls to the onSubscribe, onNext, onError and
onComplete methods, making them thread-safe.
|
Modifier and Type | Method and Description |
---|---|
static Scheduler |
Schedulers.computation()
Returns a default, shared
Scheduler instance intended for computational work. |
Scheduler.Worker |
TestScheduler.createWorker() |
static Scheduler |
Schedulers.from(Executor executor)
Wraps an
Executor into a new Scheduler instance and delegates schedule()
calls to it. |
Runnable |
SchedulerRunnableIntrospection.getWrappedRunnable()
Returns the wrapped action.
|
static Scheduler |
Schedulers.io()
Returns a default, shared
Scheduler instance intended for IO-bound work. |
static Scheduler |
Schedulers.newThread()
|
static Scheduler |
Schedulers.single()
Returns a default, shared, single-thread-backed
Scheduler instance for work
requiring strongly-sequential execution on the same background thread. |
static Scheduler |
Schedulers.trampoline()
Returns a default, shared
Scheduler instance whose Scheduler.Worker
instances queue work and execute them in a FIFO manner on one of the participating threads. |
TimeUnit |
Timed.unit()
Returns the time unit of the contained time.
|
T |
Timed.value()
Returns the contained value.
|
Modifier and Type | Method and Description |
---|---|
static Scheduler |
Schedulers.from(Executor executor)
Wraps an
Executor into a new Scheduler instance and delegates schedule()
calls to it. |
long |
TestScheduler.now(TimeUnit unit) |
long |
Timed.time(TimeUnit unit)
Returns the contained time value in the time unit specified.
|
Constructor and Description |
---|
Timed(T value,
long time,
TimeUnit unit)
Constructs a Timed instance with the given value and time information.
|
Timed(T value,
long time,
TimeUnit unit)
Constructs a Timed instance with the given value and time information.
|
Modifier and Type | Method and Description |
---|---|
static CompletableSubject |
CompletableSubject.create()
Creates a fresh CompletableSubject.
|
static <T> UnicastSubject<T> |
UnicastSubject.create()
Creates an UnicastSubject with an internal buffer capacity hint 16.
|
static <T> SingleSubject<T> |
SingleSubject.create()
Creates a fresh SingleSubject.
|
static <T> ReplaySubject<T> |
ReplaySubject.create()
Creates an unbounded replay subject.
|
static <T> PublishSubject<T> |
PublishSubject.create()
Constructs a PublishSubject.
|
static <T> MaybeSubject<T> |
MaybeSubject.create()
Creates a fresh MaybeSubject.
|
static <T> BehaviorSubject<T> |
BehaviorSubject.create()
Creates a
BehaviorSubject without a default item. |
static <T> AsyncSubject<T> |
AsyncSubject.create()
Creates a new AsyncProcessor.
|
static <T> UnicastSubject<T> |
UnicastSubject.create(boolean delayError)
Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag.
|
static <T> UnicastSubject<T> |
UnicastSubject.create(int capacityHint)
Creates an UnicastSubject with the given internal buffer capacity hint.
|
static <T> ReplaySubject<T> |
ReplaySubject.create(int capacityHint)
Creates an unbounded replay subject with the specified initial buffer capacity.
|
static <T> UnicastSubject<T> |
UnicastSubject.create(int capacityHint,
Runnable onTerminate)
Creates an UnicastSubject with the given internal buffer capacity hint and a callback for
the case when the single Subscriber cancels its subscription.
|
static <T> UnicastSubject<T> |
UnicastSubject.create(int capacityHint,
Runnable onTerminate,
boolean delayError)
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.
|
static <T> BehaviorSubject<T> |
BehaviorSubject.createDefault(T defaultValue)
Creates a
BehaviorSubject that emits the last item it observed and all subsequent items to each
Observer that subscribes to it. |
static <T> ReplaySubject<T> |
ReplaySubject.createWithSize(int maxSize)
Creates a size-bounded replay subject.
|
static <T> ReplaySubject<T> |
ReplaySubject.createWithTime(long maxAge,
TimeUnit unit,
Scheduler scheduler)
Creates a time-bounded replay subject.
|
static <T> ReplaySubject<T> |
ReplaySubject.createWithTimeAndSize(long maxAge,
TimeUnit unit,
Scheduler scheduler,
int maxSize)
Creates a time- and size-bounded replay subject.
|
Subject<T> |
Subject.toSerialized()
Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and
onComplete methods, making them thread-safe.
|
Modifier and Type | Method and Description |
---|---|
void |
SingleSubject.onError(Throwable e) |
void |
SingleSubject.onSubscribe(Disposable d) |
void |
SingleSubject.onSuccess(T value) |
protected void |
SingleSubject.subscribeActual(SingleObserver<? super T> observer) |
Copyright © 2019. All rights reserved.