| AbstractMaybeWithUpstream<T,R> |
Abstract base class for intermediate Maybe operators that take an upstream MaybeSource.
|
| MaybeAmb<T> |
Signals the event of the first MaybeSource that signals.
|
| MaybeAmb.AmbMaybeObserver<T> |
|
| MaybeCache<T> |
Consumes the source once and replays its signal to any current or future MaybeObservers.
|
| MaybeCache.CacheDisposable<T> |
|
| MaybeCallbackObserver<T> |
MaybeObserver that delegates the onSuccess, onError and onComplete method calls to callbacks.
|
| MaybeConcatArray<T> |
Concatenate values of each MaybeSource provided in an array.
|
| MaybeConcatArray.ConcatMaybeObserver<T> |
|
| MaybeConcatArrayDelayError<T> |
Concatenate values of each MaybeSource provided in an array and delays
any errors till the very end.
|
| MaybeConcatArrayDelayError.ConcatMaybeObserver<T> |
|
| MaybeConcatIterable<T> |
Concatenate values of each MaybeSource provided by an Iterable.
|
| MaybeConcatIterable.ConcatMaybeObserver<T> |
|
| MaybeContains<T> |
Signals true if the source signals a value that is object-equals with the provided
value, false otherwise or for empty sources.
|
| MaybeContains.ContainsMaybeObserver |
|
| MaybeCount<T> |
Signals 1L if the source signalled an item or 0L if the source is empty.
|
| MaybeCount.CountMaybeObserver |
|
| MaybeCreate<T> |
Provides an API over MaybeObserver that serializes calls to onXXX and manages cancellation
in a safe manner.
|
| MaybeCreate.Emitter<T> |
|
| MaybeDefer<T> |
Defers the creation of the actual Maybe the incoming MaybeObserver is subscribed to.
|
| MaybeDelay<T> |
Delays all signal types by the given amount and re-emits them on the given scheduler.
|
| MaybeDelay.DelayMaybeObserver<T> |
|
| MaybeDelayOtherPublisher<T,U> |
Delay the emission of the main signal until the other signals an item or completes.
|
| MaybeDelayOtherPublisher.DelayMaybeObserver<T,U> |
|
| MaybeDelayOtherPublisher.OtherSubscriber<T> |
|
| MaybeDelaySubscriptionOtherPublisher<T,U> |
Delay the subscription to the main Maybe until the other signals an item or completes.
|
| MaybeDelaySubscriptionOtherPublisher.DelayMaybeObserver<T> |
|
| MaybeDelaySubscriptionOtherPublisher.OtherSubscriber<T> |
|
| MaybeDelayWithCompletable<T> |
|
| MaybeDelayWithCompletable.DelayWithMainObserver<T> |
|
| MaybeDelayWithCompletable.OtherObserver<T> |
|
| MaybeDematerialize<T,R> |
Maps the success value of the source to a Notification, then
maps it back to the corresponding signal type.
|
| MaybeDematerialize.DematerializeObserver<T,R> |
|
| MaybeDetach<T> |
Breaks the references between the upstream and downstream when the Maybe terminates.
|
| MaybeDetach.DetachMaybeObserver<T> |
|
| MaybeDoAfterSuccess<T> |
Calls a consumer after pushing the current item to the downstream.
|
| MaybeDoAfterSuccess.DoAfterObserver<T> |
|
| MaybeDoFinally<T> |
Execute an action after an onSuccess, onError, onComplete or a dispose event.
|
| MaybeDoFinally.DoFinallyObserver<T> |
|
| MaybeDoOnEvent<T> |
Calls a BiConsumer with the success, error values of the upstream Maybe or with two nulls if
the Maybe completed.
|
| MaybeDoOnEvent.DoOnEventMaybeObserver<T> |
|
| MaybeDoOnLifecycle<T> |
Invokes callbacks upon onSubscribe from upstream and
dispose from downstream.
|
| MaybeDoOnLifecycle.MaybeLifecycleObserver<T> |
|
| MaybeDoOnTerminate<T> |
|
| MaybeEmpty |
Signals an onComplete.
|
| MaybeEqualSingle<T> |
Compares two MaybeSources to see if they are both empty or emit the same value compared
via a BiPredicate.
|
| MaybeEqualSingle.EqualCoordinator<T> |
|
| MaybeEqualSingle.EqualObserver<T> |
|
| MaybeError<T> |
Signals a constant Throwable.
|
| MaybeErrorCallable<T> |
Signals a Throwable returned by a Supplier.
|
| MaybeFilter<T> |
Filters the upstream via a predicate, returning the success item or completing if
the predicate returns false.
|
| MaybeFilter.FilterMaybeObserver<T> |
|
| MaybeFilterSingle<T> |
Filters the upstream SingleSource via a predicate, returning the success item or completing if
the predicate returns false.
|
| MaybeFilterSingle.FilterMaybeObserver<T> |
|
| MaybeFlatMapBiSelector<T,U,R> |
Maps a source item to another MaybeSource then calls a BiFunction with the
original item and the secondary item to generate the final result.
|
| MaybeFlatMapBiSelector.FlatMapBiMainObserver<T,U,R> |
|
| MaybeFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver<T,U,R> |
|
| MaybeFlatMapCompletable<T> |
Maps the success value of the source MaybeSource into a Completable.
|
| MaybeFlatMapCompletable.FlatMapCompletableObserver<T> |
|
| MaybeFlatMapIterableFlowable<T,R> |
Maps a success value into an Iterable and streams it back as a Flowable.
|
| MaybeFlatMapIterableFlowable.FlatMapIterableObserver<T,R> |
|
| MaybeFlatMapIterableObservable<T,R> |
Maps a success value into an Iterable and streams it back as a Flowable.
|
| MaybeFlatMapIterableObservable.FlatMapIterableObserver<T,R> |
|
| MaybeFlatMapNotification<T,R> |
Maps a value into a MaybeSource and relays its signal.
|
| MaybeFlatMapNotification.FlatMapMaybeObserver<T,R> |
|
| MaybeFlatMapSingle<T,R> |
Maps the success value of the source MaybeSource into a Single.
|
| MaybeFlatMapSingle.FlatMapMaybeObserver<T,R> |
|
| MaybeFlatMapSingle.FlatMapSingleObserver<R> |
|
| MaybeFlatten<T,R> |
Maps a value into a MaybeSource and relays its signal.
|
| MaybeFlatten.FlatMapMaybeObserver<T,R> |
|
| MaybeFromAction<T> |
Executes an Action and signals its exception or completes normally.
|
| MaybeFromCallable<T> |
Executes a callable and signals its value as success or signals an exception.
|
| MaybeFromCompletable<T> |
Wrap a Completable into a Maybe.
|
| MaybeFromCompletable.FromCompletableObserver<T> |
|
| MaybeFromFuture<T> |
Waits until the source Future completes or the wait times out; treats a null
result as indication to signal onComplete instead of onSuccess.
|
| MaybeFromRunnable<T> |
Executes an Runnable and signals its exception or completes normally.
|
| MaybeFromSingle<T> |
Wrap a Single into a Maybe.
|
| MaybeFromSingle.FromSingleObserver<T> |
|
| MaybeFromSupplier<T> |
Executes a supplier and signals its value as success or signals an exception.
|
| MaybeHide<T> |
Hides the identity of the upstream Maybe and its Disposable sent through onSubscribe.
|
| MaybeHide.HideMaybeObserver<T> |
|
| MaybeIgnoreElement<T> |
Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.
|
| MaybeIgnoreElement.IgnoreMaybeObserver<T> |
|
| MaybeIgnoreElementCompletable<T> |
Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.
|
| MaybeIgnoreElementCompletable.IgnoreMaybeObserver<T> |
|
| MaybeIsEmpty<T> |
Signals true if the source Maybe signals onComplete, signals false if the source Maybe
signals onSuccess.
|
| MaybeIsEmpty.IsEmptyMaybeObserver<T> |
|
| MaybeIsEmptySingle<T> |
Signals true if the source Maybe signals onComplete, signals false if the source Maybe
signals onSuccess.
|
| MaybeIsEmptySingle.IsEmptyMaybeObserver<T> |
|
| MaybeJust<T> |
Signals a constant value.
|
| MaybeLift<T,R> |
Calls a MaybeOperator for the incoming MaybeObserver.
|
| MaybeMap<T,R> |
Maps the upstream success value into some other value.
|
| MaybeMap.MapMaybeObserver<T,R> |
|
| MaybeMaterialize<T> |
Turn the signal types of a Maybe source into a single Notification of
equal kind.
|
| MaybeMergeArray<T> |
Run all MaybeSources of an array at once and signal their values as they become available.
|
| MaybeMergeArray.ClqSimpleQueue<T> |
|
| MaybeMergeArray.MergeMaybeObserver<T> |
|
| MaybeMergeArray.MpscFillOnceSimpleQueue<T> |
|
| MaybeNever |
Doesn't signal any event other than onSubscribe.
|
| MaybeObserveOn<T> |
Signals the onSuccess, onError or onComplete events on a the specific scheduler.
|
| MaybeObserveOn.ObserveOnMaybeObserver<T> |
|
| MaybeOnErrorComplete<T> |
Emits an onComplete if the source emits an onError and the predicate returns true for
that Throwable.
|
| MaybeOnErrorComplete.OnErrorCompleteMultiObserver<T> |
|
| MaybeOnErrorNext<T> |
Subscribes to the MaybeSource returned by a function if the main source signals an onError.
|
| MaybeOnErrorNext.OnErrorNextMaybeObserver<T> |
|
| MaybeOnErrorNext.OnErrorNextMaybeObserver.NextMaybeObserver<T> |
|
| MaybeOnErrorReturn<T> |
Returns a value generated via a function if the main source signals an onError.
|
| MaybeOnErrorReturn.OnErrorReturnMaybeObserver<T> |
|
| MaybePeek<T> |
Peeks into the lifecycle of a Maybe and MaybeObserver.
|
| MaybePeek.MaybePeekObserver<T> |
|
| MaybeSubscribeOn<T> |
Subscribes to the upstream MaybeSource on the specified scheduler.
|
| MaybeSubscribeOn.SubscribeOnMaybeObserver<T> |
|
| MaybeSubscribeOn.SubscribeTask<T> |
|
| MaybeSwitchIfEmpty<T> |
Subscribes to the other source if the main source is empty.
|
| MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver<T> |
|
| MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.OtherMaybeObserver<T> |
|
| MaybeSwitchIfEmptySingle<T> |
Subscribes to the other source if the main source is empty.
|
| MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver<T> |
|
| MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.OtherSingleObserver<T> |
|
| MaybeTakeUntilMaybe<T,U> |
Relays the main source's event unless the other Maybe signals an item first or just completes
at which point the resulting Maybe is completed.
|
| MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver<T,U> |
|
| MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver.TakeUntilOtherMaybeObserver<U> |
|
| MaybeTakeUntilPublisher<T,U> |
Relays the main source's event unless the other Publisher signals an item first or just completes
at which point the resulting Maybe is completed.
|
| MaybeTakeUntilPublisher.TakeUntilMainMaybeObserver<T,U> |
|
| MaybeTakeUntilPublisher.TakeUntilMainMaybeObserver.TakeUntilOtherMaybeObserver<U> |
|
| MaybeTimeInterval<T> |
Measures the time between subscription and the success item emission
from the upstream and emits this as a Timed success value. |
| MaybeTimeInterval.TimeIntervalMaybeObserver<T> |
|
| MaybeTimeoutMaybe<T,U> |
Switches to the fallback Maybe if the other MaybeSource signals a success or completes, or
signals TimeoutException if fallback is null.
|
| MaybeTimeoutMaybe.TimeoutFallbackMaybeObserver<T> |
|
| MaybeTimeoutMaybe.TimeoutMainMaybeObserver<T,U> |
|
| MaybeTimeoutMaybe.TimeoutOtherMaybeObserver<T,U> |
|
| MaybeTimeoutPublisher<T,U> |
Switches to the fallback Maybe if the other Publisher signals a success or completes, or
signals TimeoutException if fallback is null.
|
| MaybeTimeoutPublisher.TimeoutFallbackMaybeObserver<T> |
|
| MaybeTimeoutPublisher.TimeoutMainMaybeObserver<T,U> |
|
| MaybeTimeoutPublisher.TimeoutOtherMaybeObserver<T,U> |
|
| MaybeTimer |
Signals a 0L after the specified delay.
|
| MaybeTimer.TimerDisposable |
|
| MaybeToFlowable<T> |
Wraps a MaybeSource and exposes it as a Flowable, relaying signals in a backpressure-aware manner
and composes cancellation through.
|
| MaybeToFlowable.MaybeToFlowableSubscriber<T> |
|
| MaybeToObservable<T> |
Wraps a MaybeSource and exposes it as an Observable, relaying signals in a backpressure-aware manner
and composes cancellation through.
|
| MaybeToObservable.MaybeToObservableObserver<T> |
|
| MaybeToSingle<T> |
Wraps a MaybeSource and exposes its onSuccess and onError signals and signals
NoSuchElementException for onComplete if defaultValue is null.
|
| MaybeToSingle.ToSingleMaybeSubscriber<T> |
|
| MaybeUnsafeCreate<T> |
Wraps a MaybeSource without safeguard and calls its subscribe() method for each MaybeObserver.
|
| MaybeUnsubscribeOn<T> |
Makes sure a dispose() call from downstream happens on the specified scheduler.
|
| MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver<T> |
|
| MaybeUsing<T,D> |
Creates a resource and a dependent Maybe for each incoming Observer and optionally
disposes the resource eagerly (before the terminal event is send out).
|
| MaybeUsing.UsingObserver<T,D> |
|
| MaybeZipArray<T,R> |
|
| MaybeZipArray.ZipCoordinator<T,R> |
|
| MaybeZipArray.ZipMaybeObserver<T> |
|
| MaybeZipIterable<T,R> |
|