Maybe

Runs multiple Maybe sources and signals the events of the first one that signals (cancelling the rest).

Scheduler:

amb does not operate by default on a particular Scheduler.

Runs multiple Maybe sources and signals the events of the first one that signals (cancelling the rest).

Scheduler:

ambArray does not operate by default on a particular Scheduler.

Mirrors the MaybeSource (current or provided) that first signals an event.

Scheduler:

ambWith does not operate by default on a particular Scheduler.

Waits in a blocking fashion until the current Maybe signals a success value (which is returned), defaultValue if completed or an exception (which is propagated).

Scheduler:

blockingGet does not operate by default on a particular Scheduler.

Waits in a blocking fashion until the current Maybe signals a success value (which is returned), null if completed or an exception (which is propagated).

Scheduler:

blockingGet does not operate by default on a particular Scheduler.

Returns a Maybe that subscribes to this Maybe lazily, caches its event and replays it, to all the downstream subscribers.

The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this Maybe.

Note: You sacrifice the ability to dispose the origin when you use the cache.

Scheduler:

cache does not operate by default on a particular Scheduler.

Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.

Scheduler:

cast does not operate by default on a particular Scheduler.

Transform a Maybe by applying a particular Transformer function to it.

This method operates on the Maybe itself whereas lift(MaybeOperator) operates on the Maybe's MaybeObservers.

If the operator you are creating is designed to act on the individual item emitted by a Maybe, use lift(MaybeOperator). If your operator is designed to transform the source Maybe as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose.

Scheduler:

compose does not operate by default on a particular Scheduler.

Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concat does not operate by default on a particular Scheduler.

Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concat does not operate by default on a particular Scheduler.

Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concat does not operate by default on a particular Scheduler.

Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer and expects the Publisher to honor backpressure as well. If the sources Publisher violates this, a MissingBackpressureException is signalled.

Scheduler:

concat does not operate by default on a particular Scheduler.

Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer and expects the Publisher to honor backpressure as well. If the sources Publisher violates this, a MissingBackpressureException is signalled.

Scheduler:

concat does not operate by default on a particular Scheduler.

Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concat does not operate by default on a particular Scheduler.

Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concatArray does not operate by default on a particular Scheduler.

Concatenates a variable number of MaybeSource sources and delays errors from any of them till all terminate.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

concatArrayDelayError does not operate by default on a particular Scheduler.

Concatenates a sequence of MaybeSource eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source MaybeSources. The operator buffers the value emitted by these MaybeSources and then drains them in order, each one after the previous one completes.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

This method does not operate by default on a particular Scheduler.

Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.

Backpressure:

concatDelayError fully supports backpressure.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Concatenates the Iterable sequence of MaybeSources into a single sequence by subscribing to each MaybeSource, one after the other, one at a time and delays any errors till the all inner MaybeSources terminate.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Concatenates a sequence of MaybeSources eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source MaybeSources. The operator buffers the values emitted by these MaybeSources and then drains them in order, each one after the previous one completes.

Backpressure:

Backpressure is honored towards the downstream.

Scheduler:

This method does not operate by default on a particular Scheduler.

Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source Publishers as they are observed. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

Backpressure is honored towards the downstream and the outer Publisher is expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Note that flatMap and concatMap for Maybe is the same operation.

Returns a Flowable that emits the items emitted from the current MaybeSource, then the next, one after the other, without interleaving them.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

concatWith does not operate by default on a particular Scheduler.

Returns a Single that emits a Boolean that indicates whether the source Maybe emitted a specified item.

Scheduler:

contains does not operate by default on a particular Scheduler.

Returns a Maybe that counts the total number of items emitted (0 or 1) by the source Maybe and emits this count as a 64-bit Long.

Scheduler:

count does not operate by default on a particular Scheduler.

Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.

Example:

 Maybe.<Event>create(emitter -> {
     Callback listener = new Callback() {
         @Override
         public void onEvent(Event e) {
             if (e.isNothing()) {
                 emitter.onComplete();
             } else {
                 emitter.onSuccess(e);
             }
         }

         @Override
         public void onFailure(Exception e) {
             emitter.onError(e);
         }
     };

     AutoCloseable c = api.someMethod(listener);

     emitter.setCancellable(c::close);

 });
 

Scheduler:

create does not operate by default on a particular Scheduler.

Returns a Maybe that emits the item emitted by the source Maybe or a specified default item if the source Maybe is empty.

Note that the result Maybe is semantically equivalent to a Single, since it's guaranteed to emit exactly one item or an error. See toSingle(Object) for a method with equivalent behavior which returns a Single.

Scheduler:

defaultIfEmpty does not operate by default on a particular Scheduler.

Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to be subscribed to.

Scheduler:

defer does not operate by default on a particular Scheduler.

Delays the emission of this Maybe until the given Publisher signals an item or completes.

Backpressure:

The delayIndicator is consumed in an unbounded manner but is cancelled after the first item it produces.

Scheduler:

This version of delay does not operate by default on a particular Scheduler.

Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a specified delay.

Scheduler:

This version of delay operates by default on the computation Scheduler.

Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a specified delay running on the specified Scheduler.

Scheduler:

you specify which Scheduler this operator will use

Returns a Maybe that delays the subscription to this Maybe until the other Publisher emits an element or completes normally.

Backpressure:

The Publisher source is consumed in an unbounded fashion (without applying backpressure).

Scheduler:

This method does not operate by default on a particular Scheduler.

Returns a Maybe that delays the subscription to the source Maybe by a given amount of time, both waiting and subscribing on a given Scheduler.

Scheduler:

You specify which Scheduler this operator will use

Returns a Maybe that delays the subscription to the source Maybe by a given amount of time.

Scheduler:

This version of delaySubscription operates by default on the computation Scheduler.

Calls the specified consumer with the success item after this item has been emitted to the downstream.

Note that the onAfterNext action is shared between subscriptions and as such should be thread-safe.

Scheduler:

doAfterSuccess does not operate by default on a particular Scheduler.

History: 2.0.1 - experimental

Registers an Action to be called when this Maybe invokes either onSuccess, onComplete or onError.

Scheduler:

doAfterTerminate does not operate by default on a particular Scheduler.

Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by the downstream.

In case of a race between a terminal event and a dispose call, the provided onFinally action is executed once per subscription.

Note that the onFinally action is shared between subscriptions and as such should be thread-safe.

Scheduler:

doFinally does not operate by default on a particular Scheduler.

History: 2.0.1 - experimental

Modifies the source Maybe so that it invokes an action when it calls onComplete.

Scheduler:

doOnComplete does not operate by default on a particular Scheduler.

Calls the shared Action if a MaybeObserver subscribed to the current Maybe disposes the common Disposable it received via onSubscribe.

Scheduler:

doOnDispose does not operate by default on a particular Scheduler.

Calls the shared consumer with the error sent via onError for each MaybeObserver that subscribes to the current Maybe.

Scheduler:

doOnError does not operate by default on a particular Scheduler.

Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwable) for an onError or (null, null) for an onComplete signal from this Maybe before delivering said signal to the downstream.

Exceptions thrown from the callback will override the event so the downstream receives the error instead of the original signal.

Scheduler:

doOnEvent does not operate by default on a particular Scheduler.

Calls the shared consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Maybe.

Scheduler:

doOnSubscribe does not operate by default on a particular Scheduler.

Calls the shared consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Maybe.

Scheduler:

doOnSuccess does not operate by default on a particular Scheduler.

Returns a (singleton) Maybe instance that calls onComplete immediately.

Scheduler:

empty does not operate by default on a particular Scheduler.

Returns a Maybe that invokes a subscriber's onError method when the subscriber subscribes to it.

Scheduler:

error does not operate by default on a particular Scheduler.

Returns a Maybe that invokes a MaybeObserver's onError method when the MaybeObserver subscribes to it.

Scheduler:

error does not operate by default on a particular Scheduler.

Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.

Scheduler:

filter does not operate by default on a particular Scheduler.

Returns a Maybe that emits the results of a specified function to the pair of values emitted by the source Maybe and a specified mapped MaybeSource.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that MaybeSource's signals

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Note that flatMap and concatMap for Maybe is the same operation.

Returns a Completable that completes based on applying a specified function to the item emitted by the source Maybe, where that function returns a Completable.

Scheduler:

flatMapCompletable does not operate by default on a particular Scheduler.

Returns an Observable that is based on applying a specified function to the item emitted by the source Maybe, where that function returns an ObservableSource.

Scheduler:

flatMapObservable does not operate by default on a particular Scheduler.

Returns a Flowable that emits items based on applying a specified function to the item emitted by the source Maybe, where that function returns a Publisher.

Backpressure:

The returned Flowable honors the downstream backpressure.

Scheduler:

flatMapPublisher does not operate by default on a particular Scheduler.

Returns a Single based on applying a specified function to the item emitted by the source Maybe, where that function returns a Single. When this Maybe completes a NoSuchElementException will be thrown.

Scheduler:

flatMapSingle does not operate by default on a particular Scheduler.

Returns a Maybe based on applying a specified function to the item emitted by the source Maybe, where that function returns a Single. When this Maybe just completes the resulting Maybe completes as well.

Scheduler:

flatMapSingleElement does not operate by default on a particular Scheduler.

History: 2.0.2 - experimental

Returns a Flowable that merges each item emitted by the source Maybe with the values in an Iterable corresponding to that item that is generated by a selector.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

flattenAsFlowable does not operate by default on a particular Scheduler.

Returns an Observable that maps a success value into an Iterable and emits its items.

Scheduler:

flattenAsObservable does not operate by default on a particular Scheduler.

Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.

Scheduler:

fromAction does not operate by default on a particular Scheduler.

Returns a Maybe that invokes passed function and emits its result for each new MaybeObserver that subscribes while considering null value from the callable as indication for valueless completion.

Allows you to defer execution of passed function until MaybeObserver subscribes to the Maybe. It makes passed function "lazy". Result of the function invocation will be emitted by the Maybe.

Scheduler:

fromCallable does not operate by default on a particular Scheduler.

Wraps a CompletableSource into a Maybe.

Scheduler:

fromCompletable does not operate by default on a particular Scheduler.

Converts a Future into a Maybe, treating a null result as an indication of emptiness.

You can convert any object that supports the Future interface into a Maybe that emits the return value of the get() method of that object, by passing the object into the from method.

Important note: This Maybe is blocking; you cannot dispose it.

Unlike 1.x, cancelling the Maybe won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futureMaybe.doOnDispose(() -> future.cancel(true));.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Converts a Future into a Maybe, with a timeout on the Future.

You can convert any object that supports the Future interface into a Maybe that emits the return value of the get() method of that object, by passing the object into the fromFuture method.

Unlike 1.x, cancelling the Maybe won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futureMaybe.doOnCancel(() -> future.cancel(true));.

Important note: This Maybe is blocking on the thread it gets subscribed on; you cannot dispose it.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.

Scheduler:

fromRunnable does not operate by default on a particular Scheduler.

Wraps a SingleSource into a Maybe.

Scheduler:

fromSingle does not operate by default on a particular Scheduler.

Hides the identity of this Maybe and its Disposable.

Allows preventing certain identity-based optimizations (fusion).

Scheduler:

hide does not operate by default on a particular Scheduler.

Ignores the item emitted by the source Maybe and only calls onComplete or onError.

Scheduler:

ignoreElement does not operate by default on a particular Scheduler.

Returns a Single that emits true if the source Maybe is empty, otherwise false.

Scheduler:

isEmpty does not operate by default on a particular Scheduler.

Returns a Maybe that emits a specified item.

To convert any object into a Maybe that emits that object, pass that object into the just method.

Scheduler:

just does not operate by default on a particular Scheduler.

Lifts a function to the current Maybe and returns a new Maybe that when subscribed to will pass the values of the current Maybe through the MaybeOperator function.

In other words, this allows chaining TaskExecutors together on a Maybe for acting on the values within the Maybe.

task.map(...).filter(...).lift(new OperatorA()).lift(new OperatorB(...)).subscribe()

If the operator you are creating is designed to act on the item emitted by a source Maybe, use lift. If your operator is designed to transform the source Maybe as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose(MaybeTransformer).

Scheduler:

lift does not operate by default on a particular Scheduler.

Returns a Maybe that applies a specified function to the item emitted by the source Maybe and emits the result of this function application.

Scheduler:

map does not operate by default on a particular Scheduler.

Flattens a MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item emitted by the nested MaybeSource, without any transformation.

Scheduler:

merge does not operate by default on a particular Scheduler.

Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

merge does not operate by default on a particular Scheduler.

Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

merge does not operate by default on a particular Scheduler.

Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

merge does not operate by default on a particular Scheduler.

Flattens two MaybeSources into a single Flowable, without any transformation.

You can combine items emitted by multiple MaybeSources so that they appear as a single Flowable, by using the merge method.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

merge does not operate by default on a particular Scheduler.

Flattens four MaybeSources into a single Flowable, without any transformation.

You can combine items emitted by multiple MaybeSources so that they appear as a single Flowable, by using the merge method.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

merge does not operate by default on a particular Scheduler.

Flattens three MaybeSources into a single Flowable, without any transformation.

You can combine items emitted by multiple MaybeSources so that they appear as a single Flowable, by using the merge method.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

merge does not operate by default on a particular Scheduler.

Merges an array sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeArray does not operate by default on a particular Scheduler.

Flattens an array of MaybeSources into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.

This behaves like merge(Publisher) except that if any of the merged MaybeSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.

Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeArrayDelayError does not operate by default on a particular Scheduler.

Flattens three MaybeSource into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.

This behaves like merge(MaybeSource, MaybeSource, MaybeSource) except that if any of the merged MaybeSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.

Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Flattens four MaybeSources into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.

This behaves like merge(MaybeSource, MaybeSource, MaybeSource, MaybeSource) except that if any of the merged MaybeSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.

Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Flattens an Iterable of MaybeSources into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.

This behaves like merge(Publisher) except that if any of the merged MaybeSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.

Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Flattens a Publisher that emits MaybeSources into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.

This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. The outer Publisher is consumed in unbounded mode (i.e., no backpressure is applied to it).

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Flattens two MaybeSources into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.

This behaves like merge(MaybeSource, MaybeSource) except that if any of the merged MaybeSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.

Even if both merged MaybeSources send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Flattens this and another Maybe into a single Flowable, without any transformation.

You can combine items emitted by multiple Maybes so that they appear as a single Flowable, by using the mergeWith method.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeWith does not operate by default on a particular Scheduler.

Returns a Maybe that never sends any items or notifications to a MaybeObserver.

This Maybe is useful primarily for testing purposes.

Scheduler:

never does not operate by default on a particular Scheduler.

Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler, asynchronously.

Scheduler:

you specify which Scheduler this operator will use

Filters the items emitted by a Maybe, only emitting its success value if that is an instance of the supplied Class.

Scheduler:

ofType does not operate by default on a particular Scheduler.

Returns a Maybe instance that if this Maybe emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.

Scheduler:

onErrorComplete does not operate by default on a particular Scheduler.

Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete and swallow the throwable.

Scheduler:

onErrorComplete does not operate by default on a particular Scheduler.

Instructs a Maybe to pass control to another Maybe rather than invoking onError if it encounters an error.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorResumeNext does not operate by default on a particular Scheduler.

Instructs a Maybe to pass control to another MaybeSource rather than invoking onError if it encounters an error.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorResumeNext does not operate by default on a particular Scheduler.

Instructs a Maybe to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorReturn does not operate by default on a particular Scheduler.

Instructs a Maybe to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorReturnItem does not operate by default on a particular Scheduler.

Instructs a Maybe to pass control to another MaybeSource rather than invoking onError if it encounters an Exception.

This differs from onErrorResumeNext(MaybeSource) in that this one does not handle Throwable or java.lang.Error but lets those continue through.

You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be encountered.

Scheduler:

onExceptionResumeNext does not operate by default on a particular Scheduler.

Nulls out references to the upstream producer and downstream MaybeObserver if the sequence is terminated or downstream calls dispose().

Scheduler:

onTerminateDetach does not operate by default on a particular Scheduler.

Returns a Flowable that repeats the sequence of items emitted by the source Maybe indefinitely.

Backpressure:

The operator honors downstream backpressure.

Scheduler:

repeat does not operate by default on a particular Scheduler.

Returns a Flowable that repeats the sequence of items emitted by the source Maybe at most count times.

Backpressure:

This operator honors downstream backpressure.

Scheduler:

repeat does not operate by default on a particular Scheduler.

Returns a Flowable that repeats the sequence of items emitted by the source Maybe until the provided stop function returns true.

Backpressure:

This operator honors downstream backpressure.

Scheduler:

repeatUntil does not operate by default on a particular Scheduler.

Returns a Flowable that emits the same values as the source Publisher with the exception of an onComplete. An onComplete notification from the source will result in the emission of a void item to the Publisher provided as an argument to the notificationHandler function. If that Publisher calls onComplete or onError then repeatWhen will call onComplete or onError on the child subscription. Otherwise, this Publisher will resubscribe to the source Publisher.

Backpressure:

The operator honors downstream backpressure and expects the source Publisher to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

repeatWhen does not operate by default on a particular Scheduler.

Retries at most times or until the predicate returns false, whichever happens first.

Scheduler:

retry does not operate by default on a particular Scheduler.

Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.

Scheduler:

retry does not operate by default on a particular Scheduler.

Retries the current Maybe if it fails and the predicate returns true.

Scheduler:

retry does not operate by default on a particular Scheduler.

Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls onError (infinite retry count).

If the source Maybe calls onError(Throwable), this method will resubscribe to the source Maybe rather than propagating the onError call.

Scheduler:

retry does not operate by default on a particular Scheduler.

Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls onError up to a specified number of retries.

If the source Maybe calls onError(Throwable), this method will resubscribe to the source Maybe for a maximum of count resubscriptions rather than propagating the onError call.

Scheduler:

retry does not operate by default on a particular Scheduler.

Retries until the given stop function returns true.

Scheduler:

retryUntil does not operate by default on a particular Scheduler.

Returns a Maybe that emits the same values as the source Maybe with the exception of an onError. An onError notification from the source will result in the emission of a Throwable item to the Publisher provided as an argument to the notificationHandler function. If that Publisher calls onComplete or onError then retry will call onComplete or onError on the child subscription. Otherwise, this Publisher will resubscribe to the source Publisher.

Example: This retries 3 times, each time incrementing the number of seconds it waits.

  Flowable.create((FlowableEmitter<? super String> s) -> {
      System.out.println("subscribing");
      s.onError(new RuntimeException("always fails"));
  }, BackpressureStrategy.BUFFER).retryWhen(attempts -> {
      return attempts.zipWith(Publisher.range(1, 3), (n, i) -> i).flatMap(i -> {
          System.out.println("delay retry by " + i + " second(s)");
          return Publisher.timer(i, TimeUnit.SECONDS);
      });
  }).blockingForEach(System.out::println);
 

 subscribing
 delay retry by 1 second(s)
 subscribing
 delay retry by 2 second(s)
 subscribing
 delay retry by 3 second(s)
 subscribing
  

Scheduler:

retryWhen does not operate by default on a particular Scheduler.

Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the same by comparing the items emitted by each MaybeSource pairwise.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Returns a Single that emits a Boolean value that indicates whether two MaybeSources are the same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified equality function.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Subscribes the given MaybeObserver to this MaybeSource instance.

Subscribes to a Maybe and provides a callback to handle the items it emits.

If the Maybe emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Subscribes to a Maybe and ignores onSuccess and onComplete emissions.

If the Maybe emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Asynchronously subscribes subscribers to this Maybe on the specified Scheduler.

Scheduler:

you specify which Scheduler this operator will use

Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given MaybeObserver as is.

Usage example:

 Maybe<Integer> source = Maybe.just(1);
 CompositeDisposable composite = new CompositeDisposable();

 MaybeObserver<Integer> ms = new MaybeObserver<>() {
     // ...
 };

 composite.add(source.subscribeWith(ms));
 

Scheduler:

subscribeWith does not operate by default on a particular Scheduler.

Returns a Maybe that emits the items emitted by the source Maybe or the items of an alternate MaybeSource if the current Maybe is empty.

Scheduler:

switchIfEmpty does not operate by default on a particular Scheduler.

Returns a Maybe that emits the item emitted by the source Maybe until a second Publisher emits an item.

Backpressure:

The Publisher is consumed in an unbounded fashion and is cancelled after the first item emitted.

Scheduler:

takeUntil does not operate by default on a particular Scheduler.

Returns a Maybe that emits the items emitted by the source Maybe until a second MaybeSource emits an item.

Scheduler:

takeUntil does not operate by default on a particular Scheduler.

Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.

Scheduler:

test does not operate by default on a particular Scheduler.

Creates a TestObserver and subscribes it to this Maybe.

Scheduler:

test does not operate by default on a particular Scheduler.

Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Maybe terminates and notifies MaybeObservers of a TimeoutException.

Scheduler:

This version of timeout operates by default on the computation Scheduler.

If the current Maybe source didn't signal an event before the timeoutIndicator Publisher signals, the current Maybe is cancelled and the fallback MaybeSource subscribed to as a continuation.

Backpressure:

The timeoutIndicator Publisher is consumed in an unbounded manner and is cancelled after its first item.

Scheduler:

timeout does not operate by default on a particular Scheduler.

If the current Maybe source didn't signal an event before the timeoutIndicator MaybeSource signals, the current Maybe is cancelled and the fallback MaybeSource subscribed to as a continuation.

Scheduler:

timeout does not operate by default on a particular Scheduler.

Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Maybe begins instead to mirror a fallback MaybeSource.

Scheduler:

This version of timeout operates by default on the computation Scheduler.

If this Maybe source didn't signal an event before the timeoutIndicator MaybeSource signals, a TimeoutException is signalled instead.

Scheduler:

timeout does not operate by default on a particular Scheduler.

Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Maybe begins instead to mirror a fallback MaybeSource.

Scheduler:

You specify which Scheduler this operator will use

If this Maybe source didn't signal an event before the timeoutIndicator Publisher signals, a TimeoutException is signalled instead.

Backpressure:

The timeoutIndicator Publisher is consumed in an unbounded manner and is cancelled after its first item.

Scheduler:

timeout does not operate by default on a particular Scheduler.

Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Maybe terminates and notifies MaybeObservers of a TimeoutException.

Scheduler:

You specify which Scheduler this operator will use

Returns a Maybe that emits 0L after a specified delay on a specified Scheduler.

Scheduler:

You specify which Scheduler this operator will use

Returns a Maybe that emits 0L after a specified delay.

Scheduler:

timer operates by default on the computation Scheduler.

Calls the specified converter function with the current Maybe instance during assembly time and returns its result.

Scheduler:

to does not operate by default on a particular Scheduler.

Converts this Maybe into a backpressure-aware Flowable instance composing cancellation through.

Backpressure:

The returned Flowable honors the backpressure of the downstream.

Scheduler:

toFlowable does not operate by default on a particular Scheduler.

Converts this Maybe into an Observable instance composing cancellation through.

Scheduler:

toObservable does not operate by default on a particular Scheduler.

Converts this Maybe into a Single instance composing cancellation through and turning an empty Maybe into a signal of NoSuchElementException.

Scheduler:

toSingle does not operate by default on a particular Scheduler.

Converts this Maybe into a Single instance composing cancellation through and turning an empty Maybe into a Single that emits the given value through onSuccess.

Scheduler:

toSingle does not operate by default on a particular Scheduler.

Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.

Scheduler:

unsafeCreate does not operate by default on a particular Scheduler.

Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, that call is propagated up on the specified scheduler

Scheduler:

unsubscribeOn calls dispose() of the upstream on the Scheduler you specify.

Constructs a Maybe that creates a dependent resource object which is disposed of when the upstream terminates or the downstream calls dispose().

Scheduler:

using does not operate by default on a particular Scheduler.

Constructs a Maybe that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and a downstream dispose() does not occur before termination. Otherwise resource disposal will occur on call to dispose(). Eager disposal is particularly appropriate for a synchronous Maybe that reuses resources. disposeAction will only be called once per subscription.

Scheduler:

using does not operate by default on a particular Scheduler.

Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.

Scheduler:

wrap does not operate by default on a particular Scheduler.

Returns a Maybe that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other MaybeSources.

This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.

Scheduler:

zip does not operate by default on a particular Scheduler.

Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other MaybeSources.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.

Scheduler:

zip does not operate by default on a particular Scheduler.

Returns a Maybe that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other MaybeSources.

This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.

Scheduler:

zip does not operate by default on a particular Scheduler.

Returns a Maybe that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other MaybeSources.

This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.

Scheduler:

zip does not operate by default on a particular Scheduler.

Returns a Maybe that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other MaybeSources.

This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.

Scheduler:

zip does not operate by default on a particular Scheduler.

Returns a Maybe that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other MaybeSources.

This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.

Scheduler:

zip does not operate by default on a particular Scheduler.

Returns a Maybe that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other MaybeSources.

This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.

Scheduler:

zip does not operate by default on a particular Scheduler.