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.flowables |
Classes supporting the Flowable base reactive class:
ConnectableFlowable and
GroupedFlowable . |
io.reactivex.internal.disposables | |
io.reactivex.internal.fuseable |
Base interfaces and types for supporting operator-fusion.
|
io.reactivex.internal.observers | |
io.reactivex.internal.operators.completable | |
io.reactivex.internal.operators.flowable | |
io.reactivex.internal.operators.maybe | |
io.reactivex.internal.operators.mixed | |
io.reactivex.internal.operators.observable | |
io.reactivex.internal.operators.single | |
io.reactivex.internal.schedulers | |
io.reactivex.internal.subscribers | |
io.reactivex.internal.subscriptions | |
io.reactivex.internal.util | |
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.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.
|
io.reactivex.subscribers |
Default wrappers and implementations for Subscriber-based consumer classes and interfaces,
including disposable and resource-tracking variants and
the
TestSubscriber that allows unit testing
Flowable -based flows. |
Modifier and Type | Class and Description |
---|---|
static class |
Scheduler.Worker
Represents an isolated, sequential worker of a parent Scheduler for executing
Runnable tasks on
an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system). |
Modifier and Type | Method and Description |
---|---|
<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 |
---|---|
Disposable |
Observable.forEach(Consumer<? super T> onNext)
Subscribes to the
ObservableSource and receives notifications for each element. |
Disposable |
Flowable.forEach(Consumer<? super T> onNext)
Subscribes to the
Publisher and receives notifications for each element. |
Disposable |
Observable.forEachWhile(Predicate<? super T> onNext)
Subscribes to the
ObservableSource and receives notifications for each element until the
onNext Predicate returns false. |
Disposable |
Flowable.forEachWhile(Predicate<? super T> onNext)
Subscribes to the
Publisher and receives notifications for each element until the
onNext Predicate returns false. |
Disposable |
Observable.forEachWhile(Predicate<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to the
ObservableSource and receives notifications for each element and error events until the
onNext Predicate returns false. |
Disposable |
Flowable.forEachWhile(Predicate<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to the
Publisher and receives notifications for each element and error events until the
onNext Predicate returns false. |
Disposable |
Observable.forEachWhile(Predicate<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to the
ObservableSource and receives notifications for each element and the terminal events until the
onNext Predicate returns false. |
Disposable |
Flowable.forEachWhile(Predicate<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to the
Publisher and receives notifications for each element and the terminal events until the
onNext Predicate returns false. |
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.
|
Disposable |
Single.subscribe()
Subscribes to a Single but ignore its emission or notification.
|
Disposable |
Observable.subscribe()
Subscribes to an ObservableSource and ignores
onNext and onComplete emissions. |
Disposable |
Maybe.subscribe()
Subscribes to a Maybe and ignores
onSuccess and onComplete emissions. |
Disposable |
Flowable.subscribe()
Subscribes to a Publisher and ignores
onNext and onComplete emissions. |
Disposable |
Completable.subscribe()
Subscribes to this CompletableConsumable and returns a Disposable which can be used to dispose
the subscription.
|
Disposable |
Completable.subscribe(Action onComplete)
Subscribes to this Completable and calls the given Action when this Completable
completes normally.
|
Disposable |
Completable.subscribe(Action onComplete,
Consumer<? super Throwable> onError)
Subscribes to this Completable and calls back either the onError or onComplete functions.
|
Disposable |
Single.subscribe(BiConsumer<? super T,? super Throwable> onCallback)
Subscribes to a Single and provides a composite callback to handle the item it emits
or any error notification it issues.
|
Disposable |
Single.subscribe(Consumer<? super T> onSuccess)
Subscribes to a Single and provides a callback to handle the item it emits.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext)
Subscribes to an ObservableSource and provides a callback to handle the items it emits.
|
Disposable |
Maybe.subscribe(Consumer<? super T> onSuccess)
Subscribes to a Maybe and provides a callback to handle the items it emits.
|
Disposable |
Flowable.subscribe(Consumer<? super T> onNext)
Subscribes to a Publisher and provides a callback to handle the items it emits.
|
Disposable |
Single.subscribe(Consumer<? super T> onSuccess,
Consumer<? super Throwable> onError)
Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it
issues.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error
notification it issues.
|
Disposable |
Maybe.subscribe(Consumer<? super T> onSuccess,
Consumer<? super Throwable> onError)
Subscribes to a Maybe and provides callbacks to handle the items it emits and any error
notification it issues.
|
Disposable |
Flowable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to a Publisher and provides callbacks to handle the items it emits and any error
notification it issues.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Disposable |
Maybe.subscribe(Consumer<? super T> onSuccess,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Disposable |
Flowable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposable> onSubscribe)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Disposable |
Flowable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super org.reactivestreams.Subscription> onSubscribe)
Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Modifier and Type | Method and Description |
---|---|
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 |
SingleEmitter.setDisposable(Disposable d)
Sets a Disposable on this emitter; any previous Disposable
or Cancellable will be disposed/cancelled.
|
void |
ObservableEmitter.setDisposable(Disposable d)
Sets a Disposable on this emitter; any previous
Disposable
or Cancellable will be disposed/cancelled. |
void |
MaybeEmitter.setDisposable(Disposable d)
Sets a Disposable on this emitter; any previous
Disposable
or Cancellable will be disposed/cancelled. |
void |
FlowableEmitter.setDisposable(Disposable d)
Sets a Disposable on this emitter; any previous
Disposable
or Cancellable will be disposed/cancelled. |
void |
CompletableEmitter.setDisposable(Disposable d)
Sets a Disposable on this emitter; any previous
Disposable
or Cancellable will be disposed/cancelled. |
Modifier and Type | Method and Description |
---|---|
Observable<T> |
Observable.doOnLifecycle(Consumer<? super Disposable> onSubscribe,
Action onDispose)
Calls the appropriate onXXX method (shared between all Observer) for the lifecycle events of
the sequence (subscription, disposal).
|
Single<T> |
Single.doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Calls the shared consumer with the Disposable sent through the onSubscribe for each
SingleObserver that subscribes to the current Single.
|
Observable<T> |
Observable.doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Modifies the source
ObservableSource so that it invokes the given action when it is subscribed from
its subscribers. |
Maybe<T> |
Maybe.doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Calls the shared consumer with the Disposable sent through the onSubscribe for each
MaybeObserver that subscribes to the current Maybe.
|
Completable |
Completable.doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Returns a Completable instance that calls the given onSubscribe callback with the disposable
that child subscribers receive on subscription.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposable> onSubscribe)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Modifier and Type | Class and Description |
---|---|
class |
CompositeDisposable
A disposable container that can hold onto multiple other disposables and
offers O(1) add and removal complexity.
|
class |
SerialDisposable
A Disposable container that allows atomically updating/replacing the contained
Disposable with another Disposable, disposing the old one when updating plus
handling the disposition when the container itself is disposed.
|
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.
|
Disposable |
SerialDisposable.get()
Returns the currently contained Disposable or null if this container is empty.
|
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.
|
boolean |
CompositeDisposable.remove(Disposable d)
Removes and disposes the given disposable if it is part of this
container.
|
boolean |
SerialDisposable.replace(Disposable next)
Atomically: set the next disposable on this container but don't dispose the previous
one (if any) or dispose next if the container has been disposed.
|
boolean |
SerialDisposable.set(Disposable next)
Atomically: set the next disposable on this container and dispose the previous
one (if any) or dispose next if the container has been disposed.
|
Constructor and Description |
---|
CompositeDisposable(Disposable... resources)
Creates a CompositeDisposables with the given array of initial elements.
|
SerialDisposable(Disposable initialDisposable)
Constructs a SerialDisposable with the given initial Disposable instance.
|
Constructor and Description |
---|
CompositeDisposable(Iterable<? extends Disposable> resources)
Creates a CompositeDisposables with the given Iterable sequence of initial elements.
|
Modifier and Type | Method and Description |
---|---|
Disposable |
ConnectableFlowable.connect()
Instructs the
ConnectableFlowable to begin emitting the items from its underlying
Flowable to its Subscriber s. |
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 | Class and Description |
---|---|
class |
ArrayCompositeDisposable
A composite disposable with a fixed number of slots.
|
class |
CancellableDisposable
A disposable container that wraps a Cancellable instance.
|
class |
DisposableHelper
Utility methods for working with Disposables atomically.
|
class |
EmptyDisposable
Represents a stateless empty Disposable that reports being always
empty and disposed.
|
class |
ListCompositeDisposable
A disposable container that can hold onto multiple other disposables.
|
class |
SequentialDisposable
A Disposable container that allows updating/replacing a Disposable
atomically and with respect of disposing the container itself.
|
Modifier and Type | Method and Description |
---|---|
Disposable |
ArrayCompositeDisposable.replaceResource(int index,
Disposable resource)
Replaces the resource at the specified index and returns the old resource.
|
Modifier and Type | Method and Description |
---|---|
boolean |
ListCompositeDisposable.add(Disposable d) |
boolean |
DisposableContainer.add(Disposable d)
Adds a disposable to this container or disposes it if the
container has been disposed.
|
boolean |
ListCompositeDisposable.addAll(Disposable... ds) |
boolean |
ListCompositeDisposable.delete(Disposable d) |
boolean |
DisposableContainer.delete(Disposable d)
Removes (but does not dispose) the given disposable if it is part of this
container.
|
static boolean |
DisposableHelper.isDisposed(Disposable d)
Checks if the given Disposable is the common
DisposableHelper.DISPOSED enum value. |
boolean |
ListCompositeDisposable.remove(Disposable d) |
boolean |
DisposableContainer.remove(Disposable d)
Removes and disposes the given disposable if it is part of this
container.
|
static boolean |
DisposableHelper.replace(AtomicReference<Disposable> field,
Disposable d)
Atomically replaces the Disposable in the field with the given new Disposable
but does not dispose the old one.
|
boolean |
SequentialDisposable.replace(Disposable next)
Atomically: set the next disposable on this container but don't dispose the previous
one (if any) or dispose next if the container has been disposed.
|
Disposable |
ArrayCompositeDisposable.replaceResource(int index,
Disposable resource)
Replaces the resource at the specified index and returns the old resource.
|
void |
ResettableConnectable.resetIf(Disposable connection)
Reset the connectable source only if the given
Disposable connection instance
is still representing a connection established by a previous connect() connection. |
static boolean |
DisposableHelper.set(AtomicReference<Disposable> field,
Disposable d)
Atomically sets the field and disposes the old contents.
|
static boolean |
DisposableHelper.setOnce(AtomicReference<Disposable> field,
Disposable d)
Atomically sets the field to the given non-null Disposable and returns true
or returns false if the field is non-null.
|
boolean |
ArrayCompositeDisposable.setResource(int index,
Disposable resource)
Sets the resource at the specified index and disposes the old resource.
|
static boolean |
DisposableHelper.trySet(AtomicReference<Disposable> field,
Disposable d)
Atomically tries to set the given Disposable on the field if it is null or disposes it if
the field contains
DisposableHelper.DISPOSED . |
boolean |
SequentialDisposable.update(Disposable next)
Atomically: set the next disposable on this container and dispose the previous
one (if any) or dispose next if the container has been disposed.
|
static boolean |
DisposableHelper.validate(Disposable current,
Disposable next)
Verifies that current is null, next is not null, otherwise signals errors
to the RxJavaPlugins and returns false.
|
Modifier and Type | Method and Description |
---|---|
static boolean |
DisposableHelper.dispose(AtomicReference<Disposable> field)
Atomically disposes the Disposable in the field if not already disposed.
|
static boolean |
DisposableHelper.replace(AtomicReference<Disposable> field,
Disposable d)
Atomically replaces the Disposable in the field with the given new Disposable
but does not dispose the old one.
|
static boolean |
DisposableHelper.set(AtomicReference<Disposable> field,
Disposable d)
Atomically sets the field and disposes the old contents.
|
static boolean |
DisposableHelper.setOnce(AtomicReference<Disposable> field,
Disposable d)
Atomically sets the field to the given non-null Disposable and returns true
or returns false if the field is non-null.
|
static boolean |
DisposableHelper.trySet(AtomicReference<Disposable> field,
Disposable d)
Atomically tries to set the given Disposable on the field if it is null or disposes it if
the field contains
DisposableHelper.DISPOSED . |
Constructor and Description |
---|
ListCompositeDisposable(Disposable... resources) |
SequentialDisposable(Disposable initial)
Construct a SequentialDisposable with the initial Disposable provided.
|
Constructor and Description |
---|
ListCompositeDisposable(Iterable<? extends Disposable> resources) |
Modifier and Type | Interface and Description |
---|---|
interface |
QueueDisposable<T>
An interface extending Queue and Disposable and allows negotiating
the fusion mode between subsequent operators of the
Observable base reactive type. |
Modifier and Type | Class and Description |
---|---|
class |
BasicFuseableObserver<T,R>
Base class for a fuseable intermediate observer.
|
class |
BasicIntQueueDisposable<T>
An abstract QueueDisposable implementation, extending an AtomicInteger,
that defaults all unnecessary Queue methods to throw UnsupportedOperationException.
|
class |
BasicQueueDisposable<T>
An abstract QueueDisposable implementation that defaults all
unnecessary Queue methods to throw UnsupportedOperationException.
|
class |
BiConsumerSingleObserver<T> |
class |
BlockingBaseObserver<T> |
class |
BlockingFirstObserver<T>
Blocks until the upstream signals its first value or completes.
|
class |
BlockingLastObserver<T>
Blocks until the upstream signals its last value or completes.
|
class |
BlockingObserver<T> |
class |
CallbackCompletableObserver |
class |
ConsumerSingleObserver<T> |
class |
DeferredScalarDisposable<T>
Represents a fuseable container for a single value.
|
class |
DeferredScalarObserver<T,R>
A fuseable Observer that can generate 0 or 1 resulting value.
|
class |
DisposableLambdaObserver<T> |
class |
EmptyCompletableObserver |
class |
ForEachWhileObserver<T> |
class |
FutureObserver<T>
An Observer + Future that expects exactly one upstream value and provides it
via the (blocking) Future API.
|
class |
FutureSingleObserver<T>
An Observer + Future that expects exactly one upstream value and provides it
via the (blocking) Future API.
|
class |
InnerQueuedObserver<T>
Subscriber that can fuse with the upstream and calls a support interface
whenever an event is available.
|
class |
LambdaObserver<T> |
Modifier and Type | Field and Description |
---|---|
protected Disposable |
DeferredScalarObserver.upstream
The upstream disposable.
|
protected Disposable |
BasicFuseableObserver.upstream
The upstream subscription.
|
Modifier and Type | Method and Description |
---|---|
protected void |
QueueDrainObserver.fastPathEmit(U value,
boolean delayError,
Disposable dispose) |
protected void |
QueueDrainObserver.fastPathOrderedEmit(U value,
boolean delayError,
Disposable disposable)
Makes sure the fast-path emits in order.
|
void |
SubscriberCompletableObserver.onSubscribe(Disposable d) |
void |
ResumeSingleObserver.onSubscribe(Disposable d) |
void |
LambdaObserver.onSubscribe(Disposable d) |
void |
InnerQueuedObserver.onSubscribe(Disposable d) |
void |
FutureSingleObserver.onSubscribe(Disposable d) |
void |
FutureObserver.onSubscribe(Disposable d) |
void |
ForEachWhileObserver.onSubscribe(Disposable d) |
void |
EmptyCompletableObserver.onSubscribe(Disposable d) |
void |
DisposableLambdaObserver.onSubscribe(Disposable d) |
void |
DeferredScalarObserver.onSubscribe(Disposable d) |
void |
ConsumerSingleObserver.onSubscribe(Disposable d) |
void |
CallbackCompletableObserver.onSubscribe(Disposable d) |
void |
BlockingObserver.onSubscribe(Disposable d) |
void |
BlockingMultiObserver.onSubscribe(Disposable d) |
void |
BlockingBaseObserver.onSubscribe(Disposable d) |
void |
BiConsumerSingleObserver.onSubscribe(Disposable d) |
void |
BasicFuseableObserver.onSubscribe(Disposable d) |
Constructor and Description |
---|
DisposableLambdaObserver(Observer<? super T> actual,
Consumer<? super Disposable> onSubscribe,
Action onDispose) |
LambdaObserver(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposable> onSubscribe) |
ResumeSingleObserver(AtomicReference<Disposable> parent,
SingleObserver<? super T> downstream) |
Modifier and Type | Method and Description |
---|---|
void |
CompletableCache.onSubscribe(Disposable d) |
Constructor and Description |
---|
CompletablePeek(CompletableSource source,
Consumer<? super Disposable> onSubscribe,
Consumer<? super Throwable> onError,
Action onComplete,
Action onTerminate,
Action onAfterTerminate,
Action onDispose) |
Modifier and Type | Method and Description |
---|---|
void |
FlowableReplay.resetIf(Disposable connectionObject) |
Modifier and Type | Method and Description |
---|---|
void |
FlowableReplay.connect(Consumer<? super Disposable> connection) |
void |
FlowablePublish.connect(Consumer<? super Disposable> connection) |
Constructor and Description |
---|
FlowableAutoConnect(ConnectableFlowable<? extends T> source,
int numberOfSubscribers,
Consumer<? super Disposable> connection) |
Modifier and Type | Class and Description |
---|---|
class |
MaybeCallbackObserver<T>
MaybeObserver that delegates the onSuccess, onError and onComplete method calls to callbacks.
|
Modifier and Type | Method and Description |
---|---|
void |
MaybeCallbackObserver.onSubscribe(Disposable d) |
void |
MaybeCache.onSubscribe(Disposable d) |
Constructor and Description |
---|
MaybePeek(MaybeSource<T> source,
Consumer<? super Disposable> onSubscribeCall,
Consumer<? super T> onSuccessCall,
Consumer<? super Throwable> onErrorCall,
Action onCompleteCall,
Action onAfterTerminate,
Action onDispose) |
Modifier and Type | Class and Description |
---|---|
class |
MaterializeSingleObserver<T>
A consumer that implements the consumer types of Maybe, Single and Completable
and turns their signals into Notifications for a SingleObserver.
|
Modifier and Type | Method and Description |
---|---|
void |
MaterializeSingleObserver.onSubscribe(Disposable d) |
Modifier and Type | Class and Description |
---|---|
static class |
ObservableGroupBy.GroupByObserver<T,K,V> |
static class |
ObservableScalarXMap.ScalarDisposable<T>
Represents a Disposable that signals one onNext followed by an onComplete.
|
class |
ObserverResourceWrapper<T> |
Modifier and Type | Method and Description |
---|---|
void |
ObserverResourceWrapper.onSubscribe(Disposable d) |
void |
ObservableGroupBy.GroupByObserver.onSubscribe(Disposable d) |
void |
ObservableCache.onSubscribe(Disposable d) |
void |
ObservableReplay.resetIf(Disposable connectionObject) |
void |
ObserverResourceWrapper.setResource(Disposable resource) |
Modifier and Type | Method and Description |
---|---|
void |
ObservableReplay.connect(Consumer<? super Disposable> connection) |
void |
ObservablePublish.connect(Consumer<? super Disposable> connection) |
Constructor and Description |
---|
ObservableAutoConnect(ConnectableObservable<? extends T> source,
int numberOfObservers,
Consumer<? super Disposable> connection) |
ObservableDoOnLifecycle(Observable<T> upstream,
Consumer<? super Disposable> onSubscribe,
Action onDispose) |
Modifier and Type | Method and Description |
---|---|
void |
SingleCache.onSubscribe(Disposable d) |
Constructor and Description |
---|
SingleDoOnSubscribe(SingleSource<T> source,
Consumer<? super Disposable> onSubscribe) |
Modifier and Type | Class and Description |
---|---|
static class |
ExecutorScheduler.ExecutorWorker |
class |
NewThreadWorker
Base class that manages a single-threaded ScheduledExecutorService as a
worker but doesn't perform task-tracking operations.
|
class |
ScheduledDirectPeriodicTask
A Callable to be submitted to an ExecutorService that runs a Runnable
action periodically and manages completion/cancellation.
|
class |
ScheduledDirectTask
A Callable to be submitted to an ExecutorService that runs a Runnable
action and manages completion/cancellation.
|
class |
ScheduledRunnable |
class |
SchedulerWhen
Allows the use of operators for controlling the timing around when actions
scheduled on workers are actually done.
|
Modifier and Type | Method and Description |
---|---|
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) |
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 |
NewThreadWorker.scheduleDirect(Runnable run,
long delayTime,
TimeUnit unit)
Schedules the given runnable on the underlying executor directly and
returns its future wrapped into a Disposable.
|
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 |
NewThreadWorker.schedulePeriodicallyDirect(Runnable run,
long initialDelay,
long period,
TimeUnit unit)
Schedules the given runnable periodically on the underlying executor directly
and returns its future wrapped into a Disposable.
|
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 | Class and Description |
---|---|
class |
BoundedSubscriber<T> |
class |
ForEachWhileSubscriber<T> |
class |
LambdaSubscriber<T> |
class |
SubscriberResourceWrapper<T> |
Modifier and Type | Method and Description |
---|---|
protected void |
QueueDrainSubscriber.fastPathEmitMax(U value,
boolean delayError,
Disposable dispose) |
protected void |
QueueDrainSubscriber.fastPathOrderedEmitMax(U value,
boolean delayError,
Disposable dispose) |
void |
SubscriberResourceWrapper.setResource(Disposable resource) |
Modifier and Type | Class and Description |
---|---|
class |
ArrayCompositeSubscription
A composite disposable with a fixed number of slots.
|
class |
AsyncSubscription
A subscription implementation that arbitrates exactly one other Subscription and can
hold a single disposable resource.
|
Modifier and Type | Method and Description |
---|---|
boolean |
AsyncSubscription.replaceResource(Disposable r)
Replaces the currently held resource with the given new one without disposing the old.
|
boolean |
AsyncSubscription.setResource(Disposable r)
Sets a new resource and disposes the currently held resource.
|
Constructor and Description |
---|
AsyncSubscription(Disposable resource) |
Modifier and Type | Class and Description |
---|---|
class |
EmptyComponent
Singleton implementing many interfaces as empty.
|
Modifier and Type | Field and Description |
---|---|
Disposable |
ConnectConsumer.disposable |
Modifier and Type | Method and Description |
---|---|
static Disposable |
NotificationLite.getDisposable(Object o) |
Modifier and Type | Method and Description |
---|---|
void |
ConnectConsumer.accept(Disposable t) |
static void |
BlockingHelper.awaitForComplete(CountDownLatch latch,
Disposable subscription) |
static <T,U> boolean |
QueueDrainHelper.checkTerminated(boolean d,
boolean empty,
Observer<?> observer,
boolean delayError,
SimpleQueue<?> q,
Disposable disposable,
ObservableQueueDrain<T,U> qd) |
static Object |
NotificationLite.disposable(Disposable d)
Converts a Disposable into a notification value.
|
static <T,U> void |
QueueDrainHelper.drainLoop(SimplePlainQueue<T> q,
Observer<? super U> a,
boolean delayError,
Disposable dispose,
ObservableQueueDrain<T,U> qd) |
static <T,U> void |
QueueDrainHelper.drainMaxLoop(SimplePlainQueue<T> q,
org.reactivestreams.Subscriber<? super U> a,
boolean delayError,
Disposable dispose,
QueueDrain<T,U> qd)
Drain the queue but give up with an error if there aren't enough requests.
|
void |
EmptyComponent.onSubscribe(Disposable d) |
static boolean |
EndConsumerHelper.setOnce(AtomicReference<Disposable> upstream,
Disposable next,
Class<?> observer)
Atomically updates the target upstream AtomicReference from null to the non-null
next Disposable, otherwise disposes next and reports a ProtocolViolationException
if the AtomicReference doesn't contain the shared disposed indicator.
|
static boolean |
EndConsumerHelper.validate(Disposable upstream,
Disposable next,
Class<?> observer)
Ensures that the upstream Disposable is null and returns true, otherwise
disposes the next Disposable and if the upstream is not the shared
disposed instance, reports a ProtocolViolationException due to
multiple subscribe attempts.
|
Modifier and Type | Method and Description |
---|---|
static boolean |
EndConsumerHelper.setOnce(AtomicReference<Disposable> upstream,
Disposable next,
Class<?> observer)
Atomically updates the target upstream AtomicReference from null to the non-null
next Disposable, otherwise disposes next and reports a ProtocolViolationException
if the AtomicReference doesn't contain the shared disposed indicator.
|
Modifier and Type | Method and Description |
---|---|
Disposable |
ConnectableObservable.connect()
Instructs the
ConnectableObservable to begin emitting the items from its underlying
Observable to its Observer s. |
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 | Class and Description |
---|---|
class |
BaseTestConsumer<T,U extends BaseTestConsumer<T,U>>
Base class with shared infrastructure to support TestSubscriber and TestObserver.
|
class |
DisposableCompletableObserver
An abstract
CompletableObserver that allows asynchronous cancellation by implementing Disposable. |
class |
DisposableMaybeObserver<T>
An abstract
MaybeObserver that allows asynchronous cancellation by implementing Disposable. |
class |
DisposableObserver<T>
An abstract
Observer that allows asynchronous cancellation by implementing Disposable. |
class |
DisposableSingleObserver<T>
An abstract
SingleObserver that allows asynchronous cancellation by implementing Disposable. |
class |
ResourceCompletableObserver
An abstract
CompletableObserver that allows asynchronous cancellation of its subscription and associated resources. |
class |
ResourceMaybeObserver<T>
An abstract
MaybeObserver that allows asynchronous cancellation of its subscription and associated resources. |
class |
ResourceObserver<T>
An abstract
Observer that allows asynchronous cancellation of its subscription and associated resources. |
class |
ResourceSingleObserver<T>
An abstract
SingleObserver that allows asynchronous cancellation of its subscription
and the associated resources. |
class |
SafeObserver<T>
Wraps another Subscriber and ensures all onXXX methods conform the protocol
(except the requirement for serialized access).
|
class |
SerializedObserver<T>
Serializes access to the onNext, onError and onComplete methods of another Observer.
|
class |
TestObserver<T>
An Observer that records events and allows making assertions about them.
|
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 |
TestObserver.onSubscribe(Disposable d) |
void |
SerializedObserver.onSubscribe(Disposable d) |
void |
SafeObserver.onSubscribe(Disposable d) |
void |
ResourceSingleObserver.onSubscribe(Disposable d) |
void |
ResourceObserver.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) |
Modifier and Type | Method and Description |
---|---|
void |
UnicastSubject.onSubscribe(Disposable d) |
void |
SingleSubject.onSubscribe(Disposable d) |
void |
ReplaySubject.onSubscribe(Disposable d) |
void |
PublishSubject.onSubscribe(Disposable d) |
void |
MaybeSubject.onSubscribe(Disposable d) |
void |
CompletableSubject.onSubscribe(Disposable d) |
void |
BehaviorSubject.onSubscribe(Disposable d) |
void |
AsyncSubject.onSubscribe(Disposable d) |
Modifier and Type | Class and Description |
---|---|
class |
DisposableSubscriber<T>
An abstract Subscriber that allows asynchronous, external cancellation by implementing Disposable.
|
class |
ResourceSubscriber<T>
An abstract Subscriber that allows asynchronous cancellation of its
subscription and associated resources.
|
class |
TestSubscriber<T>
A subscriber that records events and allows making assertions about them.
|
Modifier and Type | Method and Description |
---|---|
void |
ResourceSubscriber.add(Disposable resource)
Adds a resource to this AsyncObserver.
|
Copyright © 2019. All rights reserved.