From e8889d845c81b4b0953f532134cfaa516e34d3e8 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Wed, 8 Jan 2020 14:45:59 +0100 Subject: [PATCH 1/3] 3.x: Javadoc cleanup of Observable --- .../io/reactivex/rxjava3/core/Flowable.java | 62 +- .../io/reactivex/rxjava3/core/Observable.java | 4916 +++++++++-------- .../validators/JavadocCodesAndLinks.java | 7 +- .../rxjava3/validators/JavadocWording.java | 2 +- .../validators/ParamValidationNaming.java | 3 +- 5 files changed, 2505 insertions(+), 2485 deletions(-) diff --git a/src/main/java/io/reactivex/rxjava3/core/Flowable.java b/src/main/java/io/reactivex/rxjava3/core/Flowable.java index b5135bf356..eb740f161b 100644 --- a/src/main/java/io/reactivex/rxjava3/core/Flowable.java +++ b/src/main/java/io/reactivex/rxjava3/core/Flowable.java @@ -1925,7 +1925,7 @@ public static Flowable error(@NonNull Throwable throwable) { } /** - * Converts an Array into a {@link Publisher} that emits the items in the Array. + * Converts an array into a {@link Publisher} that emits the items in the array. *

* *

@@ -1939,8 +1939,8 @@ public static Flowable error(@NonNull Throwable throwable) { * @param items * the array of elements * @param - * the type of items in the Array and the type of items to be emitted by the resulting {@code Publisher} - * @return a {@code Flowable} that emits each item in the source Array + * the type of items in the array and the type of items to be emitted by the resulting {@code Publisher} + * @return a {@code Flowable} that emits each item in the source array * @see ReactiveX operators documentation: From */ @CheckReturnValue @@ -2005,11 +2005,10 @@ public static Flowable error(@NonNull Throwable throwable) { *

* *

- * You can convert any object that supports the {@code Future} interface into a {@code Publisher} that emits the - * return value of the {@link Future#get} method of that object by passing the object into the {@code from} - * method. - *

- * Important note: This {@code Publisher} is blocking on the thread it gets subscribed on; you cannot cancel it. + * The operator calls {@link Future#get()}, which is a blocking method, on the subscription thread. + * It is recommended applying {@link #subscribeOn(Scheduler)} to move this blocking wait to a + * background thread, and if the {@link Scheduler} supports it, interrupt the wait when the flow + * is disposed. *

* Also note that this operator will consume a {@link CompletionStage}-based {@code Future} subclass (such as * {@link CompletableFuture}) in a blocking manner as well. Use the {@link #fromCompletionStage(CompletionStage)} @@ -2047,15 +2046,14 @@ public static Flowable error(@NonNull Throwable throwable) { *

* *

- * You can convert any object that supports the {@code Future} interface into a {@code Publisher} that emits the - * return value of the {@link Future#get} method of that object by passing the object into the {@code fromFuture} - * method. + * The operator calls {@link Future#get(long, TimeUnit)}, which is a blocking method, on the subscription thread. + * It is recommended applying {@link #subscribeOn(Scheduler)} to move this blocking wait to a + * background thread, and if the {@link Scheduler} supports it, interrupt the wait when the flow + * is disposed. *

* Unlike 1.x, canceling the {@code Flowable} won't cancel the future. If necessary, one can use composition to achieve the * cancellation effect: {@code futurePublisher.doOnCancel(() -> future.cancel(true));}. *

- * Important note: This {@code Publisher} is blocking on the thread it gets subscribed on; you cannot cancel it. - *

* Also note that this operator will consume a {@link CompletionStage}-based {@code Future} subclass (such as * {@link CompletableFuture}) in a blocking manner as well. Use the {@link #fromCompletionStage(CompletionStage)} * operator to convert and consume such sources in a non-blocking fashion instead. @@ -3042,7 +3040,7 @@ public static Flowable merge(@NonNull Iterable * @@ -3288,7 +3286,7 @@ public static Flowable merge(@NonNull Publisher * *

@@ -4401,7 +4399,9 @@ public static Flowable unsafeCreate(@NonNull Publisher onSubscribe) { } /** - * Constructs a {@link Publisher} that creates a dependent resource object which is disposed of on cancellation. + * Constructs a {@code Flowable} that creates a dependent resource object, a {@link Publisher} with + * that resource and calls the provided {@code resourceDisposer} function if this inner source terminates or the + * downstream cancels the flow. *

* *

@@ -4435,11 +4435,9 @@ public static Flowable using( } /** - * Constructs a {@link Publisher} that creates a dependent resource object which is disposed of just before - * termination if you have set {@code disposeEagerly} to {@code true} and cancellation does not occur - * before termination. Otherwise, resource disposal will occur on cancellation. Eager disposal is - * particularly appropriate for a synchronous {@code Publisher} that reuses resources. {@code disposeAction} will - * only be called once per subscription. + * Constructs an {@code Flowable} that creates a dependent resource object, an {@link Publisher} with + * that resource and calls the provided {@code resourceDisposer} function if this inner source terminates or the + * downstream disposes the flow; doing it before these end-states have been reached if {@code eager == true}, after otherwise. *

* *

@@ -6824,7 +6822,7 @@ public final > Flowable buffer(@NonNull Pu * that return a {@link ConnectableFlowable} require an explicit call to {@link ConnectableFlowable#connect()}. *

* Note: You sacrifice the ability to cancel the origin when you use the {@code cache} - * {@code Subscriber} so be careful not to use this {@code Subscriber} on {@code Publisher}s that emit an infinite or very large number + * operator so be careful not to use this operator on {@code Publisher}s that emit an infinite or very large number * of items that will use up memory. * A possible workaround is to apply {@link #takeUntil(Publisher)} with a predicate or * another source before (and perhaps after) the application of {@code cache()}. @@ -6860,6 +6858,8 @@ public final > Flowable buffer(@NonNull Pu * @return a {@code Flowable} that, when first subscribed to, caches all of its items and notifications for the * benefit of subsequent subscribers * @see ReactiveX operators documentation: Replay + * @see #takeUntil(Predicate) + * @see #takeUntil(Publisher) */ @CheckReturnValue @BackpressureSupport(BackpressureKind.FULL) @@ -6883,7 +6883,7 @@ public final Flowable cache() { * that return a {@link ConnectableFlowable} require an explicit call to {@link ConnectableFlowable#connect()}. *

* Note: You sacrifice the ability to cancel the origin when you use the {@code cache} - * {@code Subscriber} so be careful not to use this {@code Subscriber} on {@code Publisher}s that emit an infinite or very large number + * operator so be careful not to use this operator on {@code Publisher}s that emit an infinite or very large number * of items that will use up memory. * A possible workaround is to apply {@link #takeUntil(Publisher)} with a predicate or * another source before (and perhaps after) the application of {@code cacheWithInitialCapacity()}. @@ -6923,6 +6923,8 @@ public final Flowable cache() { * @return a {@code Flowable} that, when first subscribed to, caches all of its items and notifications for the * benefit of subsequent subscribers * @see ReactiveX operators documentation: Replay + * @see #takeUntil(Predicate) + * @see #takeUntil(Publisher) */ @CheckReturnValue @BackpressureSupport(BackpressureKind.FULL) @@ -11940,13 +11942,13 @@ public final Flowable onBackpressureBuffer(int capacity, @NonNull Action onOv * by {@code overflowStrategy} if the buffer capacity is exceeded. * *

    - *
  • {@code BackpressureOverflow.Strategy.ON_OVERFLOW_ERROR} (default) will call {@code onError} dropping all undelivered items, + *
  • {@link BackpressureOverflowStrategy#ERROR} (default) will call {@code onError} dropping all undelivered items, * canceling the source, and notifying the producer with {@code onOverflow}.
    • - *
  • {@code BackpressureOverflow.Strategy.ON_OVERFLOW_DROP_LATEST} will drop any new items emitted by the producer while + *
  • {@link BackpressureOverflowStrategy#DROP_LATEST} will drop any new items emitted by the producer while * the buffer is full, without generating any {@code onError}. Each drop will, however, invoke {@code onOverflow} * to signal the overflow to the producer.
    • - *
  • {@code BackpressureOverflow.Strategy.ON_OVERFLOW_DROP_OLDEST} will drop the oldest items in the buffer in order to make - * room for newly emitted ones. Overflow will not generate an{@code onError}, but each drop will invoke + *
  • {@link BackpressureOverflowStrategy#DROP_OLDEST} will drop the oldest items in the buffer in order to make + * room for newly emitted ones. Overflow will not generate an {@code onError}, but each drop will invoke * {@code onOverflow} to signal the overflow to the producer.
    • *
* @@ -11961,8 +11963,8 @@ public final Flowable onBackpressureBuffer(int capacity, @NonNull Action onOv *
* * @param capacity number of slots available in the buffer. - * @param onOverflow action to execute if an item needs to be buffered, but there are no available slots. Null is allowed. - * @param overflowStrategy how should the {@code Publisher} react to buffer overflows. Null is not allowed. + * @param onOverflow action to execute if an item needs to be buffered, but there are no available slots, {@code null} is allowed. + * @param overflowStrategy how should the {@code Publisher} react to buffer overflows, {@code null} is not allowed. * @return the source {@code Flowable} modified to buffer items up to the given capacity * @see ReactiveX operators documentation: backpressure operators * @since 2.0 @@ -11971,7 +11973,7 @@ public final Flowable onBackpressureBuffer(int capacity, @NonNull Action onOv @NonNull @BackpressureSupport(BackpressureKind.SPECIAL) @SchedulerSupport(SchedulerSupport.NONE) - public final Flowable onBackpressureBuffer(long capacity, @NonNull Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy) { + public final Flowable onBackpressureBuffer(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy) { Objects.requireNonNull(overflowStrategy, "overflowStrategy is null"); ObjectHelper.verifyPositive(capacity, "capacity"); return RxJavaPlugins.onAssembly(new FlowableOnBackpressureBufferStrategy<>(this, capacity, onOverflow, overflowStrategy)); diff --git a/src/main/java/io/reactivex/rxjava3/core/Observable.java b/src/main/java/io/reactivex/rxjava3/core/Observable.java index 5c94b3f9e2..81c121bc3e 100644 --- a/src/main/java/io/reactivex/rxjava3/core/Observable.java +++ b/src/main/java/io/reactivex/rxjava3/core/Observable.java @@ -21,7 +21,7 @@ import io.reactivex.rxjava3.annotations.*; import io.reactivex.rxjava3.disposables.Disposable; -import io.reactivex.rxjava3.exceptions.Exceptions; +import io.reactivex.rxjava3.exceptions.*; import io.reactivex.rxjava3.functions.*; import io.reactivex.rxjava3.internal.functions.*; import io.reactivex.rxjava3.internal.fuseable.ScalarSupplier; @@ -37,14 +37,14 @@ import io.reactivex.rxjava3.schedulers.*; /** - * The Observable class is the non-backpressured, optionally multi-valued base reactive class that + * The {@code Observable} class is the non-backpressured, optionally multi-valued base reactive class that * offers factory methods, intermediate operators and the ability to consume synchronous * and/or asynchronous reactive dataflows. *

- * Many operators in the class accept {@code ObservableSource}(s), the base reactive interface + * Many operators in the class accept {@link ObservableSource}(s), the base reactive interface * for such non-backpressured flows, which {@code Observable} itself implements as well. *

- * The Observable's operators, by default, run with a buffer size of 128 elements (see {@link Flowable#bufferSize()}), + * The {@code Observable}'s operators, by default, run with a buffer size of 128 elements (see {@link Flowable#bufferSize()}), * that can be overridden globally via the system parameter {@code rx3.buffer-size}. Most operators, however, have * overloads that allow setting their internal buffer size explicitly. *

@@ -67,7 +67,7 @@ * {@code Observer.onSubscribe}. *

* Unlike the {@code Observable} of version 1.x, {@link #subscribe(Observer)} does not allow external disposal - * of a subscription and the {@code Observer} instance is expected to expose such capability. + * of a subscription and the {@link Observer} instance is expected to expose such capability. *

Example: * 


  * Disposable d = Observable.just("Hello world!")
@@ -93,14 +93,14 @@
  *
* * @param - * the type of the items emitted by the Observable + * the type of the items emitted by the {@code Observable} * @see Flowable * @see io.reactivex.rxjava3.observers.DisposableObserver */ public abstract class Observable implements ObservableSource { /** - * Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends + * Mirrors the one {@link ObservableSource} in an {@link Iterable} of several {@code ObservableSource}s that first either emits an item or sends * a termination notification. *

* @@ -111,9 +111,9 @@ public abstract class Observable implements ObservableSource { * * @param the common element type * @param sources - * an Iterable of ObservableSource sources competing to react first. A subscription to each source will - * occur in the same order as in the Iterable. - * @return an Observable that emits the same sequence as whichever of the source ObservableSources first + * an {@code Iterable} of {@code ObservableSource} sources competing to react first. A subscription to each source will + * occur in the same order as in the {@code Iterable}. + * @return an {@code Observable} that emits the same sequence as whichever of the returned {@code ObservableSource}s first * emitted an item or sent a termination notification * @see ReactiveX operators documentation: Amb */ @@ -126,7 +126,7 @@ public static Observable amb(@NonNull Iterable * @@ -137,9 +137,9 @@ public static Observable amb(@NonNull Iterable the common element type * @param sources - * an array of ObservableSource sources competing to react first. A subscription to each source will + * an array of {@code ObservableSource} sources competing to react first. A subscription to each source will * occur in the same order as in the array. - * @return an Observable that emits the same sequence as whichever of the source ObservableSources first + * @return an {@code Observable} that emits the same sequence as whichever of the returned {@code ObservableSource}s first * emitted an item or sent a termination notification * @see ReactiveX operators documentation: Amb */ @@ -173,19 +173,19 @@ public static int bufferSize() { } /** - * Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of - * the source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines a collection of source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of + * the returned {@code ObservableSource}s each time an item is received from any of the returned {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. *

* If any of the sources never produces an item but only terminates (normally or with an error), the * resulting sequence terminates immediately (normally or with all the errors accumulated till that point). * If that input source is also synchronous, other sources after it will not be subscribed to. *

- * If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting + * If the provided iterable of {@code ObservableSource}s is empty, the resulting sequence completes immediately without emitting * any items and without any calls to the combiner function. * *

@@ -200,11 +200,11 @@ public static int bufferSize() { * @param * the result type * @param sources - * the collection of source ObservableSources + * the collection of source {@code ObservableSource}s * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the returned {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the returned + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue @@ -217,19 +217,19 @@ public static Observable combineLatest( } /** - * Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of - * the source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines an {@link Iterable} of source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of + * the returned {@code ObservableSource}s each time an item is received from any of the returned {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. *

* If any of the sources never produces an item but only terminates (normally or with an error), the * resulting sequence terminates immediately (normally or with all the errors accumulated till that point). * If that input source is also synchronous, other sources after it will not be subscribed to. *

- * If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting + * If the provided {@code Iterable} of {@code ObservableSource}s is empty, the resulting sequence completes immediately without emitting * any items and without any calls to the combiner function. * *

@@ -244,13 +244,13 @@ public static Observable combineLatest( * @param * the result type * @param sources - * the collection of source ObservableSources + * the collection of source {@code ObservableSource}s * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources + * the aggregation function used to combine the items emitted by the returned {@code ObservableSource}s * @param bufferSize - * the internal buffer size and prefetch amount applied to every source Observable - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the internal buffer size and prefetch amount applied to every {@code ObservableSource} + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the returned + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue @@ -269,19 +269,19 @@ public static Observable combineLatest( } /** - * Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of - * the source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines an array of source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of + * the {@code ObservableSource}s each time an item is received from any of the returned {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. *

* If any of the sources never produces an item but only terminates (normally or with an error), the * resulting sequence terminates immediately (normally or with all the errors accumulated till that point). * If that input source is also synchronous, other sources after it will not be subscribed to. *

- * If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting + * If the provided array of {@code ObservableSource}s is empty, the resulting sequence completes immediately without emitting * any items and without any calls to the combiner function. * *

@@ -296,11 +296,11 @@ public static Observable combineLatest( * @param * the result type * @param sources - * the collection of source ObservableSources + * the collection of source {@code ObservableSource}s * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the returned + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue @@ -313,19 +313,19 @@ public static Observable combineLatestArray( } /** - * Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of - * the source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines an array of source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of + * the {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. *

* If any of the sources never produces an item but only terminates (normally or with an error), the * resulting sequence terminates immediately (normally or with all the errors accumulated till that point). * If that input source is also synchronous, other sources after it will not be subscribed to. *

- * If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting + * If the provided array of {@code ObservableSource}s is empty, the resulting sequence completes immediately without emitting * any items and without any calls to the combiner function. * *

@@ -340,13 +340,13 @@ public static Observable combineLatestArray( * @param * the result type * @param sources - * the collection of source ObservableSources + * the collection of source {@code ObservableSource}s * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s * @param bufferSize - * the internal buffer size and prefetch amount applied to every source Observable - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the internal buffer size and prefetch amount applied to every {@code ObservableSource} + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue @@ -368,8 +368,8 @@ public static Observable combineLatestArray( } /** - * Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the - * source ObservableSources each time an item is received from either of the source ObservableSources, where this + * Combines two source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of the + * {@code ObservableSource}s each time an item is received from either of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* If any of the sources never produces an item but only terminates (normally or with an error), the @@ -386,13 +386,13 @@ public static Observable combineLatestArray( * @param the element type of the second source * @param the combined output type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * the second source ObservableSource + * the second source {@code ObservableSource} * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @SuppressWarnings("unchecked") @@ -409,8 +409,8 @@ public static Observable combineLatest( } /** - * Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the - * source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines three source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of the + * {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* If any of the sources never produces an item but only terminates (normally or with an error), the @@ -428,15 +428,15 @@ public static Observable combineLatest( * @param the element type of the third source * @param the combined output type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * the second source ObservableSource + * the second source {@code ObservableSource} * @param source3 - * the third source ObservableSource + * the third source {@code ObservableSource} * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @SuppressWarnings("unchecked") @@ -455,8 +455,8 @@ public static Observable combineLatest( } /** - * Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the - * source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines four source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of the + * {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* If any of the sources never produces an item but only terminates (normally or with an error), the @@ -475,17 +475,17 @@ public static Observable combineLatest( * @param the element type of the fourth source * @param the combined output type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * the second source ObservableSource + * the second source {@code ObservableSource} * @param source3 - * the third source ObservableSource + * the third source {@code ObservableSource} * @param source4 - * the fourth source ObservableSource + * the fourth source {@code ObservableSource} * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @SuppressWarnings("unchecked") @@ -505,8 +505,8 @@ public static Observable combineLatest( } /** - * Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the - * source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines five source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of the + * {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* If any of the sources never produces an item but only terminates (normally or with an error), the @@ -526,19 +526,19 @@ public static Observable combineLatest( * @param the element type of the fifth source * @param the combined output type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * the second source ObservableSource + * the second source {@code ObservableSource} * @param source3 - * the third source ObservableSource + * the third source {@code ObservableSource} * @param source4 - * the fourth source ObservableSource + * the fourth source {@code ObservableSource} * @param source5 - * the fifth source ObservableSource + * the fifth source {@code ObservableSource} * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @SuppressWarnings("unchecked") @@ -560,8 +560,8 @@ public static Observable combineLatest( } /** - * Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the - * source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines six source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of the + * {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* If any of the sources never produces an item but only terminates (normally or with an error), the @@ -582,21 +582,21 @@ public static Observable combineLatest( * @param the element type of the sixth source * @param the combined output type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * the second source ObservableSource + * the second source {@code ObservableSource} * @param source3 - * the third source ObservableSource + * the third source {@code ObservableSource} * @param source4 - * the fourth source ObservableSource + * the fourth source {@code ObservableSource} * @param source5 - * the fifth source ObservableSource + * the fifth source {@code ObservableSource} * @param source6 - * the sixth source ObservableSource + * the sixth source {@code ObservableSource} * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @SuppressWarnings("unchecked") @@ -619,8 +619,8 @@ public static Observable combineLatest( } /** - * Combines seven source ObservableSources by emitting an item that aggregates the latest values of each of the - * source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines seven source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of the + * {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* If any of the sources never produces an item but only terminates (normally or with an error), the @@ -642,23 +642,23 @@ public static Observable combineLatest( * @param the element type of the seventh source * @param the combined output type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * the second source ObservableSource + * the second source {@code ObservableSource} * @param source3 - * the third source ObservableSource + * the third source {@code ObservableSource} * @param source4 - * the fourth source ObservableSource + * the fourth source {@code ObservableSource} * @param source5 - * the fifth source ObservableSource + * the fifth source {@code ObservableSource} * @param source6 - * the sixth source ObservableSource + * the sixth source {@code ObservableSource} * @param source7 - * the seventh source ObservableSource + * the seventh source {@code ObservableSource} * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @SuppressWarnings("unchecked") @@ -683,8 +683,8 @@ public static Observable combineLatest( } /** - * Combines eight source ObservableSources by emitting an item that aggregates the latest values of each of the - * source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines eight source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of the + * {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* If any of the sources never produces an item but only terminates (normally or with an error), the @@ -707,25 +707,25 @@ public static Observable combineLatest( * @param the element type of the eighth source * @param the combined output type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * the second source ObservableSource + * the second source {@code ObservableSource} * @param source3 - * the third source ObservableSource + * the third source {@code ObservableSource} * @param source4 - * the fourth source ObservableSource + * the fourth source {@code ObservableSource} * @param source5 - * the fifth source ObservableSource + * the fifth source {@code ObservableSource} * @param source6 - * the sixth source ObservableSource + * the sixth source {@code ObservableSource} * @param source7 - * the seventh source ObservableSource + * the seventh source {@code ObservableSource} * @param source8 - * the eighth source ObservableSource + * the eighth source {@code ObservableSource} * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @SuppressWarnings("unchecked") @@ -751,8 +751,8 @@ public static Observable combineLatest( } /** - * Combines nine source ObservableSources by emitting an item that aggregates the latest values of each of the - * source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines nine source {@link ObservableSource}s by emitting an item that aggregates the latest values of each of the + * {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* If any of the sources never produces an item but only terminates (normally or with an error), the @@ -776,27 +776,27 @@ public static Observable combineLatest( * @param the element type of the ninth source * @param the combined output type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * the second source ObservableSource + * the second source {@code ObservableSource} * @param source3 - * the third source ObservableSource + * the third source {@code ObservableSource} * @param source4 - * the fourth source ObservableSource + * the fourth source {@code ObservableSource} * @param source5 - * the fifth source ObservableSource + * the fifth source {@code ObservableSource} * @param source6 - * the sixth source ObservableSource + * the sixth source {@code ObservableSource} * @param source7 - * the seventh source ObservableSource + * the seventh source {@code ObservableSource} * @param source8 - * the eighth source ObservableSource + * the eighth source {@code ObservableSource} * @param source9 - * the ninth source ObservableSource + * the ninth source {@code ObservableSource} * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @SuppressWarnings("unchecked") @@ -824,21 +824,21 @@ public static Observable combineLates } /** - * Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of - * the source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines an array of {@link ObservableSource}s by emitting an item that aggregates the latest values of each of + * the {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function. *

* *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. *

* If any of the sources never produces an item but only terminates (normally or with an error), the * resulting sequence terminates immediately (normally or with all the errors accumulated till that point). * If that input source is also synchronous, other sources after it will not be subscribed to. *

- * If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting + * If the provided array of {@code ObservableSource}s is empty, the resulting sequence completes immediately without emitting * any items and without any calls to the combiner function. * *

@@ -851,11 +851,11 @@ public static Observable combineLates * @param * the result type * @param sources - * the collection of source ObservableSources + * the collection of source {@code ObservableSource}s * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue @@ -868,20 +868,20 @@ public static Observable combineLatestDelayError( } /** - * Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of - * the source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines an array of {@link ObservableSource}s by emitting an item that aggregates the latest values of each of + * the {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function and delays any error from the sources until - * all source ObservableSources terminate. + * all source {@code ObservableSource}s terminate. *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. *

* If any of the sources never produces an item but only terminates (normally or with an error), the * resulting sequence terminates immediately (normally or with all the errors accumulated till that point). * If that input source is also synchronous, other sources after it will not be subscribed to. *

- * If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting + * If the provided array of {@code ObservableSource}s is empty, the resulting sequence completes immediately without emitting * any items and without any calls to the combiner function. * *

@@ -896,13 +896,13 @@ public static Observable combineLatestDelayError( * @param * the result type * @param sources - * the collection of source ObservableSources + * the collection of source {@code ObservableSource}s * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s * @param bufferSize - * the internal buffer size and prefetch amount applied to every source Observable - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the internal buffer size and prefetch amount applied to every source {@code ObservableSource} + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue @@ -921,20 +921,20 @@ public static Observable combineLatestDelayError(@NonNull ObservableSo } /** - * Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of - * the source ObservableSources each time an item is received from any of the source ObservableSources, where this + * Combines an {@link Iterable} of {@link ObservableSource}s by emitting an item that aggregates the latest values of each of + * the {@code ObservableSource}s each time an item is received from any of the {@code ObservableSource}s, where this * aggregation is defined by a specified function and delays any error from the sources until - * all source ObservableSources terminate. + * all source {@code ObservableSource}s terminate. *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. *

* If any of the sources never produces an item but only terminates (normally or with an error), the * resulting sequence terminates immediately (normally or with all the errors accumulated till that point). * If that input source is also synchronous, other sources after it will not be subscribed to. *

- * If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting + * If the provided iterable of {@code ObservableSource}s is empty, the resulting sequence completes immediately without emitting * any items and without any calls to the combiner function. * *

@@ -949,11 +949,11 @@ public static Observable combineLatestDelayError(@NonNull ObservableSo * @param * the result type * @param sources - * the collection of source ObservableSources + * the {@code Iterable} of source {@code ObservableSource}s * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue @@ -965,20 +965,20 @@ public static Observable combineLatestDelayError(@NonNull Iterable * Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. *

* If any of the sources never produces an item but only terminates (normally or with an error), the * resulting sequence terminates immediately (normally or with all the errors accumulated till that point). * If that input source is also synchronous, other sources after it will not be subscribed to. *

- * If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting + * If the provided iterable of {@code ObservableSource}s is empty, the resulting sequence completes immediately without emitting * any items and without any calls to the combiner function. * *

@@ -993,13 +993,13 @@ public static Observable combineLatestDelayError(@NonNull Iterable * the result type * @param sources - * the collection of source ObservableSources + * the collection of source {@code ObservableSource}s * @param combiner - * the aggregation function used to combine the items emitted by the source ObservableSources + * the aggregation function used to combine the items emitted by the {@code ObservableSource}s * @param bufferSize - * the internal buffer size and prefetch amount applied to every source Observable - * @return an Observable that emits items that are the result of combining the items emitted by the source - * ObservableSources by means of the given aggregation function + * the internal buffer size and prefetch amount applied to every source {@code Observable} + * @return an {@code Observable} that emits items that are the result of combining the items emitted by the + * {@code ObservableSource}s by means of the given aggregation function * @see ReactiveX operators documentation: CombineLatest */ @CheckReturnValue @@ -1017,7 +1017,7 @@ public static Observable combineLatestDelayError(@NonNull Iterable * @@ -1026,8 +1026,8 @@ public static Observable combineLatestDelayError(@NonNull Iterable{@code concat} does not operate by default on a particular {@link Scheduler}. *

* @param the common value type of the sources - * @param sources the Iterable sequence of ObservableSources - * @return the new Observable instance + * @param sources the {@code Iterable} sequence of {@code ObservableSource}s + * @return the new {@code Observable} instance */ @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue @@ -1039,8 +1039,8 @@ public static Observable concat(@NonNull Iterable * *
@@ -1050,9 +1050,9 @@ public static Observable concat(@NonNull Iterable the common element base type * @param sources - * an ObservableSource that emits ObservableSources - * @return an Observable that emits items all of the items emitted by the ObservableSources emitted by - * {@code ObservableSources}, one after the other, without interleaving them + * an {@code ObservableSource} that emits {@code ObservableSource}s + * @return an {@code Observable} that emits items all of the items emitted by the {@code ObservableSource}s emitted by + * {@code ObservableSource}s, one after the other, without interleaving them * @see ReactiveX operators documentation: Concat */ @CheckReturnValue @@ -1063,8 +1063,8 @@ public static Observable concat(@NonNull ObservableSource * *
@@ -1074,11 +1074,11 @@ public static Observable concat(@NonNull ObservableSource the common element base type * @param sources - * an ObservableSource that emits ObservableSources + * an {@code ObservableSource} that emits {@code ObservableSource}s * @param prefetch - * the number of ObservableSources to prefetch from the sources sequence. - * @return an Observable that emits items all of the items emitted by the ObservableSources emitted by - * {@code ObservableSources}, one after the other, without interleaving them + * the number of {@code ObservableSource}s to prefetch from the sources sequence. + * @return an {@code Observable} that emits items all of the items emitted by the {@code ObservableSource}s emitted by + * {@code ObservableSource}s, one after the other, without interleaving them * @see ReactiveX operators documentation: Concat */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -1092,7 +1092,7 @@ public static Observable concat(@NonNull ObservableSource * @@ -1103,10 +1103,10 @@ public static Observable concat(@NonNull ObservableSource the common element base type * @param source1 - * an ObservableSource to be concatenated + * an {@code ObservableSource} to be concatenated * @param source2 - * an ObservableSource to be concatenated - * @return an Observable that emits items emitted by the two source ObservableSources, one after the other, + * an {@code ObservableSource} to be concatenated + * @return an {@code Observable} that emits items emitted by the two source {@code ObservableSource}s, one after the other, * without interleaving them * @see ReactiveX operators documentation: Concat */ @@ -1120,7 +1120,7 @@ public static Observable concat(@NonNull ObservableSource so } /** - * Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without + * Returns an {@code Observable} that emits the items emitted by three {@link ObservableSource}s, one after the other, without * interleaving them. *

* @@ -1131,12 +1131,12 @@ public static Observable concat(@NonNull ObservableSource so * * @param the common element base type * @param source1 - * an ObservableSource to be concatenated + * an {@code ObservableSource} to be concatenated * @param source2 - * an ObservableSource to be concatenated + * an {@code ObservableSource} to be concatenated * @param source3 - * an ObservableSource to be concatenated - * @return an Observable that emits items emitted by the three source ObservableSources, one after the other, + * an {@code ObservableSource} to be concatenated + * @return an {@code Observable} that emits items emitted by the three source {@code ObservableSource}s, one after the other, * without interleaving them * @see ReactiveX operators documentation: Concat */ @@ -1153,7 +1153,7 @@ public static Observable concat( } /** - * Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without + * Returns an {@code Observable} that emits the items emitted by four {@link ObservableSource}s, one after the other, without * interleaving them. *

* @@ -1164,14 +1164,14 @@ public static Observable concat( * * @param the common element base type * @param source1 - * an ObservableSource to be concatenated + * an {@code ObservableSource} to be concatenated * @param source2 - * an ObservableSource to be concatenated + * an {@code ObservableSource} to be concatenated * @param source3 - * an ObservableSource to be concatenated + * an {@code ObservableSource} to be concatenated * @param source4 - * an ObservableSource to be concatenated - * @return an Observable that emits items emitted by the four source ObservableSources, one after the other, + * an {@code ObservableSource} to be concatenated + * @return an {@code Observable} that emits items emitted by the four source {@code ObservableSource}s, one after the other, * without interleaving them * @see ReactiveX operators documentation: Concat */ @@ -1189,9 +1189,9 @@ public static Observable concat( } /** - * Concatenates a variable number of ObservableSource sources. + * Concatenates a variable number of {@link ObservableSource} sources. *

- * Note: named this way because of overload conflict with concat(ObservableSource<ObservableSource>) + * Note: named this way because of overload conflict with {@code concat(ObservableSource)} *

* *

@@ -1200,8 +1200,8 @@ public static Observable concat( *
* @param sources the array of sources * @param the common base value type - * @return the new Observable instance - * @throws NullPointerException if sources is null + * @return the new {@code Observable} instance + * @throws NullPointerException if sources is {@code null} */ @SuppressWarnings({ "unchecked", "rawtypes" }) @CheckReturnValue @@ -1219,7 +1219,7 @@ public static Observable concatArray(@NonNull ObservableSource * @@ -1229,8 +1229,8 @@ public static Observable concatArray(@NonNull ObservableSource * @param sources the array of sources * @param the common base value type - * @return the new Observable instance - * @throws NullPointerException if sources is null + * @return the new {@code Observable} instance + * @throws NullPointerException if sources is {@code null} */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -1249,20 +1249,20 @@ public static Observable concatArrayDelayError(@NonNull ObservableSource< } /** - * Concatenates an array of ObservableSources eagerly into a single stream of values. + * Concatenates an array of {@link ObservableSource}s eagerly into a single stream of values. *

* *

* Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + * {@code ObservableSource}s. The operator buffers the values emitted by these {@code ObservableSource}s and then drains them * in order, each one after the previous one completes. *

*
Scheduler:
*
This method does not operate by default on a particular {@link Scheduler}.
*
* @param the value type - * @param sources an array of ObservableSources that need to be eagerly concatenated - * @return the new ObservableSource instance with the specified concatenation behavior + * @param sources an array of {@code ObservableSource}s that need to be eagerly concatenated + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -1274,23 +1274,23 @@ public static Observable concatArrayEager(@NonNull ObservableSource * *

* Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + * {@code ObservableSource}s. The operator buffers the values emitted by these {@code ObservableSource}s and then drains them * in order, each one after the previous one completes. *

*
Scheduler:
*
This method does not operate by default on a particular {@link Scheduler}.
*
* @param the value type - * @param sources an array of ObservableSources that need to be eagerly concatenated + * @param sources an array of {@code ObservableSource}s that need to be eagerly concatenated * @param maxConcurrency the maximum number of concurrent subscriptions at a time, {@link Integer#MAX_VALUE} * is interpreted as indication to subscribe to all sources at once - * @param prefetch the number of elements to prefetch from each ObservableSource source - * @return the new ObservableSource instance with the specified concatenation behavior + * @param prefetch the number of elements to prefetch from each {@code ObservableSource} source + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @SuppressWarnings({ "rawtypes", "unchecked" }) @@ -1309,7 +1309,7 @@ public static Observable concatArrayEager(int maxConcurrency, int prefetc * *

* Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source {@code ObservableSource}s. The operator buffers the values emitted by these {@code ObservableSource}s + * {@code ObservableSource}s. The operator buffers the values emitted by these {@code ObservableSource}s * and then drains them in order, each one after the previous one completes. *

*
Scheduler:
@@ -1317,7 +1317,7 @@ public static Observable concatArrayEager(int maxConcurrency, int prefetc *
* @param the value type * @param sources an array of {@code ObservableSource}s that need to be eagerly concatenated - * @return the new Observable instance with the specified concatenation behavior + * @return the new {@code Observable} instance with the specified concatenation behavior * @since 2.2.1 - experimental */ @CheckReturnValue @@ -1335,7 +1335,7 @@ public static Observable concatArrayEagerDelayError(@NonNull ObservableSo * *

* Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source {@code ObservableSource}s. The operator buffers the values emitted by these {@code ObservableSource}s + * {@code ObservableSource}s. The operator buffers the values emitted by these {@code ObservableSource}s * and then drains them in order, each one after the previous one completes. *

*
Scheduler:
@@ -1346,7 +1346,7 @@ public static Observable concatArrayEagerDelayError(@NonNull ObservableSo * @param maxConcurrency the maximum number of concurrent subscriptions at a time, {@link Integer#MAX_VALUE} * is interpreted as indication to subscribe to all sources at once * @param prefetch the number of elements to prefetch from each {@code ObservableSource} source - * @return the new Observable instance with the specified concatenation behavior + * @return the new {@code Observable} instance with the specified concatenation behavior * @since 2.2.1 - experimental */ @SuppressWarnings({ "rawtypes", "unchecked" }) @@ -1359,8 +1359,8 @@ public static Observable concatArrayEagerDelayError(int maxConcurrency, i } /** - * Concatenates the Iterable sequence of ObservableSources into a single sequence by subscribing to each ObservableSource, - * one after the other, one at a time and delays any errors till the all inner ObservableSources terminate. + * Concatenates the {@link Iterable} sequence of {@link ObservableSource}s into a single sequence by subscribing to each {@code ObservableSource}, + * one after the other, one at a time and delays any errors till the all inner {@code ObservableSource}s terminate. *

* *

@@ -1369,8 +1369,8 @@ public static Observable concatArrayEagerDelayError(int maxConcurrency, i *
* * @param the common element base type - * @param sources the Iterable sequence of ObservableSources - * @return the new ObservableSource with the concatenating behavior + * @param sources the {@code Iterable} sequence of {@code ObservableSource}s + * @return the new {@code ObservableSource} with the concatenating behavior */ @CheckReturnValue @NonNull @@ -1381,8 +1381,8 @@ public static Observable concatDelayError(@NonNull Iterable * *
@@ -1391,8 +1391,8 @@ public static Observable concatDelayError(@NonNull Iterable * * @param the common element base type - * @param sources the ObservableSource sequence of ObservableSources - * @return the new ObservableSource with the concatenating behavior + * @param sources the {@code ObservableSource} sequence of {@code ObservableSource}s + * @return the new {@code ObservableSource} with the concatenating behavior */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -1402,8 +1402,8 @@ public static Observable concatDelayError(@NonNull ObservableSource * *
@@ -1412,11 +1412,11 @@ public static Observable concatDelayError(@NonNull ObservableSource * * @param the common element base type - * @param sources the ObservableSource sequence of ObservableSources - * @param prefetch the number of elements to prefetch from the outer ObservableSource - * @param tillTheEnd if true exceptions from the outer and all inner ObservableSources are delayed to the end - * if false, exception from the outer ObservableSource is delayed till the current ObservableSource terminates - * @return the new ObservableSource with the concatenating behavior + * @param sources the {@code ObservableSource} sequence of {@code ObservableSource}s + * @param prefetch the number of elements to prefetch from the outer {@code ObservableSource} + * @param tillTheEnd if {@code true} exceptions from the outer and all inner {@code ObservableSource}s are delayed to the end + * if {@code false}, exception from the outer {@code ObservableSource} is delayed till the active {@code ObservableSource} terminates + * @return the new {@code ObservableSource} with the concatenating behavior */ @SuppressWarnings({ "rawtypes", "unchecked" }) @CheckReturnValue @@ -1429,11 +1429,11 @@ public static Observable concatDelayError(@NonNull ObservableSource * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * emitted source ObservableSources as they are observed. The operator buffers the values emitted by these - * ObservableSources and then drains them in order, each one after the previous one completes. + * emitted source {@code ObservableSource}s as they are observed. The operator buffers the values emitted by these + * {@code ObservableSource}s and then drains them in order, each one after the previous one completes. *

* *

@@ -1441,8 +1441,8 @@ public static Observable concatDelayError(@NonNull ObservableSourceThis method does not operate by default on a particular {@link Scheduler}. *
* @param the value type - * @param sources a sequence of ObservableSources that need to be eagerly concatenated - * @return the new ObservableSource instance with the specified concatenation behavior + * @param sources a sequence of {@code ObservableSource}s that need to be eagerly concatenated + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -1453,11 +1453,11 @@ public static Observable concatEager(@NonNull ObservableSource * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * emitted source ObservableSources as they are observed. The operator buffers the values emitted by these - * ObservableSources and then drains them in order, each one after the previous one completes. + * emitted source {@code ObservableSource}s as they are observed. The operator buffers the values emitted by these + * {@code ObservableSource}s and then drains them in order, each one after the previous one completes. *

* *

@@ -1465,11 +1465,11 @@ public static Observable concatEager(@NonNull ObservableSourceThis method does not operate by default on a particular {@link Scheduler}. *
* @param the value type - * @param sources a sequence of ObservableSources that need to be eagerly concatenated - * @param maxConcurrency the maximum number of concurrently running inner ObservableSources; {@link Integer#MAX_VALUE} - * is interpreted as all inner ObservableSources can be active at the same time - * @param prefetch the number of elements to prefetch from each inner ObservableSource source - * @return the new ObservableSource instance with the specified concatenation behavior + * @param sources a sequence of {@code ObservableSource}s that need to be eagerly concatenated + * @param maxConcurrency the maximum number of concurrently running inner {@code ObservableSource}s; {@link Integer#MAX_VALUE} + * is interpreted as all inner {@code ObservableSource}s can be active at the same time + * @param prefetch the number of elements to prefetch from each inner {@code ObservableSource} source + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -1481,10 +1481,10 @@ public static Observable concatEager(@NonNull ObservableSource * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + * {@code ObservableSource}s. The operator buffers the values emitted by these {@code ObservableSource}s and then drains them * in order, each one after the previous one completes. *

* @@ -1493,8 +1493,8 @@ public static Observable concatEager(@NonNull ObservableSourceThis method does not operate by default on a particular {@link Scheduler}. *

* @param the value type - * @param sources a sequence of ObservableSources that need to be eagerly concatenated - * @return the new ObservableSource instance with the specified concatenation behavior + * @param sources a sequence of {@code ObservableSource}s that need to be eagerly concatenated + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -1505,10 +1505,10 @@ public static Observable concatEager(@NonNull Iterable * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them + * {@code ObservableSource}s. The operator buffers the values emitted by these {@code ObservableSource}s and then drains them * in order, each one after the previous one completes. *

* @@ -1517,11 +1517,11 @@ public static Observable concatEager(@NonNull IterableThis method does not operate by default on a particular {@link Scheduler}. *

* @param the value type - * @param sources a sequence of ObservableSources that need to be eagerly concatenated - * @param maxConcurrency the maximum number of concurrently running inner ObservableSources; {@link Integer#MAX_VALUE} - * is interpreted as all inner ObservableSources can be active at the same time - * @param prefetch the number of elements to prefetch from each inner ObservableSource source - * @return the new ObservableSource instance with the specified concatenation behavior + * @param sources a sequence of {@code ObservableSource}s that need to be eagerly concatenated + * @param maxConcurrency the maximum number of concurrently running inner {@code ObservableSource}s; {@link Integer#MAX_VALUE} + * is interpreted as all inner {@code ObservableSource}s can be active at the same time + * @param prefetch the number of elements to prefetch from each inner {@code ObservableSource} source + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -1533,7 +1533,7 @@ public static Observable concatEager(@NonNull Iterable * Example: * 

@@ -1563,12 +1563,12 @@ public static  Observable concatEager(@NonNull Iterable
      * 
      * 

-     * You should call the ObservableEmitter's onNext, onError and onComplete methods in a serialized fashion. The
+     * You should call the {@code ObservableEmitter}'s {@code onNext}, {@code onError} and {@code onComplete} methods in a serialized fashion. The
      * rest of its methods are thread-safe.
      * 

      *  
Scheduler:

@@ -1576,8 +1576,8 @@ public static  Observable concatEager(@NonNull Iterable
      *
      * @param  the element type
-     * @param source the emitter that is called when an Observer subscribes to the returned {@code Observable}
-     * @return the new Observable instance
+     * @param source the emitter that is called when an {@code Observer} subscribes to the returned {@code Observable}
+     * @return the new {@code Observable} instance
      * @see ObservableOnSubscribe
      * @see ObservableEmitter
      * @see Cancellable
@@ -1591,14 +1591,14 @@ public static  Observable create(@NonNull ObservableOnSubscribe source)
     }
 
     /**
-     * Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer
-     * that subscribes. That is, for each subscriber, the actual ObservableSource that subscriber observes is
+     * Returns an {@code Observable} that calls an {@link ObservableSource} factory to create an {@code ObservableSource} for each new {@link Observer}
+     * that subscribes. That is, for each subscriber, the actual {@code ObservableSource} that subscriber observes is
      * determined by the factory function.
      * 

      * 
      * 

-     * The defer Observer allows you to defer or delay emitting items from an ObservableSource until such time as an
-     * Observer subscribes to the ObservableSource. This allows an {@link Observer} to easily obtain updates or a
+     * The {@code defer} operator allows you to defer or delay emitting items from an {@code ObservableSource} until such time as an
+     * {@code Observer} subscribes to the {@code ObservableSource}. This allows an {@code Observer} to easily obtain updates or a
      * refreshed version of the sequence.
      * 

      *  
Scheduler:

@@ -1606,12 +1606,12 @@ public static  Observable create(@NonNull ObservableOnSubscribe source)
      * 

      *
      * @param supplier
-     *            the ObservableSource factory function to invoke for each {@link Observer} that subscribes to the
-     *            resulting ObservableSource
+     *            the {@code ObservableSource} factory function to invoke for each {@code Observer} that subscribes to the
+     *            resulting {@code Observable}
      * @param 
-     *            the type of the items emitted by the ObservableSource
-     * @return an Observable whose {@link Observer}s' subscriptions trigger an invocation of the given
-     *         ObservableSource factory function
+     *            the type of the items emitted by the {@code ObservableSource}
+     * @return an {@code Observable} whose {@code Observer}s' subscriptions trigger an invocation of the given
+     *         {@code ObservableSource} factory function
      * @see ReactiveX operators documentation: Defer
      */
     @CheckReturnValue
@@ -1623,7 +1623,7 @@ public static  Observable defer(@NonNull Supplier
      * 
@@ -1633,9 +1633,9 @@ public static  Observable defer(@NonNull Supplier
      *
      * @param 
-     *            the type of the items (ostensibly) emitted by the ObservableSource
-     * @return an Observable that emits no items to the {@link Observer} but immediately invokes the
-     *         {@link Observer}'s {@link Observer#onComplete() onComplete} method
+     *            the type of the items (ostensibly) emitted by the {@code Observable}
+     * @return an {@code Observable} that emits no items to the {@code Observer} but immediately invokes the
+     *         {@code Observer}'s {@link Observer#onComplete() onComplete} method
      * @see ReactiveX operators documentation: Empty
      */
     @CheckReturnValue
@@ -1647,8 +1647,8 @@ public static  Observable empty() {
     }
 
     /**
-     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the
-     * Observer subscribes to it.
+     * Returns an {@code Observable} that invokes an {@link Observer}'s {@link Observer#onError onError} method when the
+     * {@code Observer} subscribes to it.
      * 

      * 
      * 

@@ -1657,11 +1657,11 @@ public static  Observable empty() {
      * 

      *
      * @param errorSupplier
-     *            a Supplier factory to return a Throwable for each individual Observer
+     *            a {@link Supplier} factory to return a {@link Throwable} for each individual {@code Observer}
      * @param 
-     *            the type of the items (ostensibly) emitted by the ObservableSource
-     * @return an Observable that invokes the {@link Observer}'s {@link Observer#onError onError} method when
-     *         the Observer subscribes to it
+     *            the type of the items (ostensibly) emitted by the {@code Observable}
+     * @return an {@code Observable} that invokes the {@code Observer}'s {@link Observer#onError onError} method when
+     *         the {@code Observer} subscribes to it
      * @see ReactiveX operators documentation: Throw
      */
     @CheckReturnValue
@@ -1673,8 +1673,8 @@ public static  Observable error(@NonNull Supplier err
     }
 
     /**
-     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the
-     * Observer subscribes to it.
+     * Returns an {@code Observable} that invokes an {@link Observer}'s {@link Observer#onError onError} method when the
+     * {@code Observer} subscribes to it.
      * 

      * 
      * 

@@ -1683,11 +1683,11 @@ public static  Observable error(@NonNull Supplier err
      * 

      *
      * @param exception
-     *            the particular Throwable to pass to {@link Observer#onError onError}
+     *            the particular {@link Throwable} to pass to {@link Observer#onError onError}
      * @param 
-     *            the type of the items (ostensibly) emitted by the ObservableSource
-     * @return an Observable that invokes the {@link Observer}'s {@link Observer#onError onError} method when
-     *         the Observer subscribes to it
+     *            the type of the items (ostensibly) emitted by the {@code Observable}
+     * @return an {@code Observable} that invokes the {@code Observer}'s {@link Observer#onError onError} method when
+     *         the {@code Observer} subscribes to it
      * @see ReactiveX operators documentation: Throw
      */
     @CheckReturnValue
@@ -1699,7 +1699,7 @@ public static  Observable error(@NonNull Throwable exception) {
     }
 
     /**
-     * Converts an Array into an ObservableSource that emits the items in the Array.
+     * Converts an array into an {@link ObservableSource} that emits the items in the array.
      * 

      * 
      * 

@@ -1710,8 +1710,8 @@ public static  Observable error(@NonNull Throwable exception) {
      * @param items
      *            the array of elements
      * @param 
-     *            the type of items in the Array and the type of items to be emitted by the resulting ObservableSource
-     * @return an Observable that emits each item in the source Array
+     *            the type of items in the array and the type of items to be emitted by the resulting {@code Observable}
+     * @return an {@code Observable} that emits each item in the source array
      * @see ReactiveX operators documentation: From
      */
     @CheckReturnValue
@@ -1730,13 +1730,13 @@ public static  Observable fromArray(@NonNull T... items) {
     }
 
     /**
-     * Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then
+     * Returns an {@code Observable} that, when an observer subscribes to it, invokes a function you specify and then
      * emits the value returned from that function.
      * 

      * 
      * 

      * This allows you to defer the execution of the function you specify until an observer subscribes to the
-     * ObservableSource. That is to say, it makes the function "lazy."
+     * {@code Observable}. That is to say, it makes the function "lazy."
      * 

      *   
Scheduler:

      *   
{@code fromCallable} does not operate by default on a particular {@link Scheduler}.

@@ -1750,10 +1750,10 @@ public static  Observable fromArray(@NonNull T... items) {
      * 

      * @param supplier
      *         a function, the execution of which should be deferred; {@code fromCallable} will invoke this
-     *         function only when an observer subscribes to the ObservableSource that {@code fromCallable} returns
+     *         function only when an observer subscribes to the {@code Observable} that {@code fromCallable} returns
      * @param 
-     *         the type of the item emitted by the ObservableSource
-     * @return an Observable whose {@link Observer}s' subscriptions trigger an invocation of the given function
+     *         the type of the item returned by the {@code Callable} and emitted by the {@code Observable}
+     * @return an {@code Observable} whose {@link Observer}s' subscriptions trigger an invocation of the given function
      * @see #defer(Supplier)
      * @see #fromSupplier(Supplier)
      * @since 2.0
@@ -1767,29 +1767,32 @@ public static  Observable fromCallable(@NonNull Callable supp
     }
 
     /**
-     * Converts a {@link Future} into an ObservableSource.
+     * Converts a {@link Future} into an {@code Observable}.
      * 

      * 
      * 

-     * You can convert any object that supports the {@link Future} interface into an ObservableSource that emits the
-     * return value of the {@link Future#get} method of that object, by passing the object into the {@code from}
-     * method.
+     * The operator calls {@link Future#get()}, which is a blocking method, on the subscription thread.
+     * It is recommended applying {@link #subscribeOn(Scheduler)} to move this blocking wait to a
+     * background thread, and if the {@link Scheduler} supports it, interrupt the wait when the flow
+     * is disposed.
      * 

-     * Important note: This ObservableSource is blocking; you cannot dispose it.
-     * 

-     * Unlike 1.x, disposing the Observable won't cancel the future. If necessary, one can use composition to achieve the
+     * Unlike 1.x, disposing the {@code Observable} won't cancel the future. If necessary, one can use composition to achieve the
      * cancellation effect: {@code futureObservableSource.doOnDispose(() -> future.cancel(true));}.
+     * 

+     * Also note that this operator will consume a {@link CompletionStage}-based {@code Future} subclass (such as
+     * {@link CompletableFuture}) in a blocking manner as well. Use the {@link #fromCompletionStage(CompletionStage)}
+     * operator to convert and consume such sources in a non-blocking fashion instead.
      * 

      *  
Scheduler:

-     *  
{@code fromFuture} does not operate by default on a particular {@link Scheduler}.

+     *  
{@code fromFuture} does not operate by default on a particular {@code Scheduler}.

      * 

      *
      * @param future
-     *            the source {@link Future}
+     *            the source {@code Future}
      * @param 
-     *            the type of object that the {@link Future} returns, and also the type of item to be emitted by
-     *            the resulting ObservableSource
-     * @return an Observable that emits the item from the source {@link Future}
+     *            the type of object that the {@code Future} returns, and also the type of item to be emitted by
+     *            the resulting {@code Observable}
+     * @return an {@code Observable} that emits the item from the source {@code Future}
      * @see ReactiveX operators documentation: From
      */
     @CheckReturnValue
@@ -1801,33 +1804,36 @@ public static  Observable fromFuture(@NonNull Future future)
     }
 
     /**
-     * Converts a {@link Future} into an ObservableSource, with a timeout on the Future.
+     * Converts a {@link Future} into an {@code Observable}, with a timeout on the {@code Future}.
      * 

      * 
      * 

-     * You can convert any object that supports the {@link Future} interface into an ObservableSource that emits the
-     * return value of the {@link Future#get} method of that object, by passing the object into the {@code from}
-     * method.
+     * The operator calls {@link Future#get(long, TimeUnit)}, which is a blocking method, on the subscription thread.
+     * It is recommended applying {@link #subscribeOn(Scheduler)} to move this blocking wait to a
+     * background thread, and if the {@link Scheduler} supports it, interrupt the wait when the flow
+     * is disposed.
      * 

-     * Unlike 1.x, disposing the Observable won't cancel the future. If necessary, one can use composition to achieve the
+     * Unlike 1.x, disposing the {@code Observable} won't cancel the future. If necessary, one can use composition to achieve the
      * cancellation effect: {@code futureObservableSource.doOnDispose(() -> future.cancel(true));}.
      * 

-     * Important note: This ObservableSource is blocking; you cannot dispose it.
+     * Also note that this operator will consume a {@link CompletionStage}-based {@code Future} subclass (such as
+     * {@link CompletableFuture}) in a blocking manner as well. Use the {@link #fromCompletionStage(CompletionStage)}
+     * operator to convert and consume such sources in a non-blocking fashion instead.
      * 

      *  
Scheduler:

-     *  
{@code fromFuture} does not operate by default on a particular {@link Scheduler}.

+     *  
{@code fromFuture} does not operate by default on a particular {@code Scheduler}.

      * 

      *
      * @param future
-     *            the source {@link Future}
+     *            the source {@code Future}
      * @param timeout
      *            the maximum time to wait before calling {@code get}
      * @param unit
      *            the {@link TimeUnit} of the {@code timeout} argument
      * @param 
-     *            the type of object that the {@link Future} returns, and also the type of item to be emitted by
-     *            the resulting ObservableSource
-     * @return an Observable that emits the item from the source {@link Future}
+     *            the type of object that the {@code Future} returns, and also the type of item to be emitted by
+     *            the resulting {@code Observable}
+     * @return an {@code Observable} that emits the item from the source {@code Future}
      * @see ReactiveX operators documentation: From
      */
     @CheckReturnValue
@@ -1840,7 +1846,7 @@ public static  Observable fromFuture(@NonNull Future future,
     }
 
     /**
-     * Converts an {@link Iterable} sequence into an ObservableSource that emits the items in the sequence.
+     * Converts an {@link Iterable} sequence into an {@code Observable} that emits the items in the sequence.
      * 

      * 
      * 

@@ -1849,11 +1855,11 @@ public static  Observable fromFuture(@NonNull Future future,
      * 

      *
      * @param source
-     *            the source {@link Iterable} sequence
+     *            the source {@code Iterable} sequence
      * @param 
-     *            the type of items in the {@link Iterable} sequence and the type of items to be emitted by the
-     *            resulting ObservableSource
-     * @return an Observable that emits each item in the source {@link Iterable} sequence
+     *            the type of items in the {@code Iterable} sequence and the type of items to be emitted by the
+     *            resulting {@code Observable}
+     * @return an {@code Observable} that emits each item in the source {@code Iterable} sequence
      * @see ReactiveX operators documentation: From
      * @see #fromStream(Stream)
      */
@@ -1866,18 +1872,18 @@ public static  Observable fromIterable(@NonNull Iterable sour
     }
 
     /**
-     * Converts an arbitrary Reactive-Streams Publisher into an Observable.
+     * Converts an arbitrary Reactive Streams {@link Publisher} into an {@code Observable}.
      * 

      * 
      * 

-     * The {@link Publisher} must follow the
+     * The {@code Publisher} must follow the
      * Reactive-Streams specification.
      * Violating the specification may result in undefined behavior.
      * 

      * If possible, use {@link #create(ObservableOnSubscribe)} to create a
      * source-like {@code Observable} instead.
      * 

-     * Note that even though {@link Publisher} appears to be a functional interface, it
+     * Note that even though {@code Publisher} appears to be a functional interface, it
      * is not recommended to implement it through a lambda as the specification requires
      * state management that is not achievable with a stateless lambda.
      * 

@@ -1888,9 +1894,9 @@ public static  Observable fromIterable(@NonNull Iterable sour
      *  
{@code fromPublisher} does not operate by default on a particular {@link Scheduler}.

      * 

      * @param  the value type of the flow
-     * @param publisher the Publisher to convert
-     * @return the new Observable instance
-     * @throws NullPointerException if publisher is null
+     * @param publisher the {@code Publisher} to convert
+     * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code publisher} is {@code null}
      * @see #create(ObservableOnSubscribe)
      */
     @BackpressureSupport(BackpressureKind.UNBOUNDED_IN)
@@ -1903,13 +1909,13 @@ public static  Observable fromPublisher(@NonNull Publisher pu
     }
 
     /**
-     * Returns an Observable that, when an observer subscribes to it, invokes a supplier function you specify and then
+     * Returns an {@code Observable} that, when an observer subscribes to it, invokes a supplier function you specify and then
      * emits the value returned from that function.
      * 

      * 
      * 

      * This allows you to defer the execution of the function you specify until an observer subscribes to the
-     * ObservableSource. That is to say, it makes the function "lazy."
+     * {@code Observable}. That is to say, it makes the function "lazy."
      * 

      *   
Scheduler:

      *   
{@code fromSupplier} does not operate by default on a particular {@link Scheduler}.

@@ -1923,10 +1929,10 @@ public static  Observable fromPublisher(@NonNull Publisher pu
      * 

      * @param supplier
      *         a function, the execution of which should be deferred; {@code fromSupplier} will invoke this
-     *         function only when an observer subscribes to the ObservableSource that {@code fromSupplier} returns
+     *         function only when an observer subscribes to the {@code Observable} that {@code fromSupplier} returns
      * @param 
-     *         the type of the item emitted by the ObservableSource
-     * @return an Observable whose {@link Observer}s' subscriptions trigger an invocation of the given function
+     *         the type of the item emitted by the {@code Observable}
+     * @return an {@code Observable} whose {@link Observer}s' subscriptions trigger an invocation of the given function
      * @see #defer(Supplier)
      * @see #fromCallable(Callable)
      * @since 3.0.0
@@ -1954,11 +1960,11 @@ public static  Observable fromSupplier(@NonNull Supplier supp
      * 

      *
      * @param  the generated value type
-     * @param generator the Consumer called whenever a particular downstream Observer has
-     * requested a value. The callback then should call {@code onNext}, {@code onError} or
-     * {@code onComplete} to signal a value or a terminal event. Signalling multiple {@code onNext}
-     * in a call will make the operator signal {@code IllegalStateException}.
-     * @return the new Observable instance
+     * @param generator the {@link Consumer} called in a loop after a downstream {@link Observer} has
+     * subscribed. The callback then should call {@code onNext}, {@code onError} or
+     * {@code onComplete} to signal a value or a terminal event. Signaling multiple {@code onNext}
+     * in a call will make the operator signal {@link IllegalStateException}.
+     * @return the new {@code Observable} instance
      */
     @CheckReturnValue
     @NonNull
@@ -1983,14 +1989,14 @@ public static  Observable generate(@NonNull Consumer> generator
      *  
{@code generate} does not operate by default on a particular {@link Scheduler}.

      * 

      *
-     * @param  the type of the per-Observer state
+     * @param  the type of the per-{@link Observer} state
      * @param  the generated value type
-     * @param initialState the Supplier to generate the initial state for each Observer
-     * @param generator the Consumer called with the current state whenever a particular downstream Observer has
-     * requested a value. The callback then should call {@code onNext}, {@code onError} or
-     * {@code onComplete} to signal a value or a terminal event. Signalling multiple {@code onNext}
-     * in a call will make the operator signal {@code IllegalStateException}.
-     * @return the new Observable instance
+     * @param initialState the {@link Supplier} to generate the initial state for each {@code Observer}
+     * @param generator the {@link BiConsumer} called in a loop after a downstream {@code Observer} has
+     * subscribed. The callback then should call {@code onNext}, {@code onError} or
+     * {@code onComplete} to signal a value or a terminal event. Signaling multiple {@code onNext}
+     * in a call will make the operator signal {@link IllegalStateException}.
+     * @return the new {@code Observable} instance
      */
     @CheckReturnValue
     @NonNull
@@ -2014,16 +2020,16 @@ public static  Observable generate(@NonNull Supplier initialState, @
      *  
{@code generate} does not operate by default on a particular {@link Scheduler}.

      *
* - * @param the type of the per-Observer state + * @param the type of the per-{@link Observer} state * @param the generated value type - * @param initialState the Supplier to generate the initial state for each Observer - * @param generator the Consumer called with the current state whenever a particular downstream Observer has - * requested a value. The callback then should call {@code onNext}, {@code onError} or - * {@code onComplete} to signal a value or a terminal event. Signalling multiple {@code onNext} - * in a call will make the operator signal {@code IllegalStateException}. - * @param disposeState the Consumer that is called with the current state when the generator + * @param initialState the {@link Supplier} to generate the initial state for each {@code Observer} + * @param generator the {@link BiConsumer} called in a loop after a downstream {@code Observer} has + * subscribed. The callback then should call {@code onNext}, {@code onError} or + * {@code onComplete} to signal a value or a terminal event. Signaling multiple {@code onNext} + * in a call will make the operator signal {@link IllegalStateException}. + * @param disposeState the {@link Consumer} that is called with the current state when the generator * terminates the sequence or it gets disposed - * @return the new Observable instance + * @return the new {@code Observable} instance */ @CheckReturnValue @NonNull @@ -2050,15 +2056,15 @@ public static Observable generate( *
{@code generate} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the type of the per-Observer state + * @param the type of the per-{@link Observer} state * @param the generated value type - * @param initialState the Supplier to generate the initial state for each Observer - * @param generator the Function called with the current state whenever a particular downstream Observer has - * requested a value. The callback then should call {@code onNext}, {@code onError} or + * @param initialState the {@link Supplier} to generate the initial state for each {@code Observer} + * @param generator the {@link BiConsumer} called in a loop after a downstream {@code Observer} has + * subscribed. The callback then should call {@code onNext}, {@code onError} or * {@code onComplete} to signal a value or a terminal event and should return a (new) state for - * the next invocation. Signalling multiple {@code onNext} - * in a call will make the operator signal {@code IllegalStateException}. - * @return the new Observable instance + * the next invocation. Signaling multiple {@code onNext} + * in a call will make the operator signal {@link IllegalStateException}. + * @return the new {@code Observable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -2081,17 +2087,17 @@ public static Observable generate(@NonNull Supplier initialState, @ *
{@code generate} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the type of the per-Observer state + * @param the type of the per-{@link Observer} state * @param the generated value type - * @param initialState the Supplier to generate the initial state for each Observer - * @param generator the Function called with the current state whenever a particular downstream Observer has - * requested a value. The callback then should call {@code onNext}, {@code onError} or + * @param initialState the {@link Supplier} to generate the initial state for each {@code Observer} + * @param generator the {@link BiConsumer} called in a loop after a downstream {@code Observer} has + * subscribed. The callback then should call {@code onNext}, {@code onError} or * {@code onComplete} to signal a value or a terminal event and should return a (new) state for - * the next invocation. Signalling multiple {@code onNext} - * in a call will make the operator signal {@code IllegalStateException}. - * @param disposeState the Consumer that is called with the current state when the generator + * the next invocation. Signaling multiple {@code onNext} + * in a call will make the operator signal {@link IllegalStateException}. + * @param disposeState the {@link Consumer} that is called with the current state when the generator * terminates the sequence or it gets disposed - * @return the new Observable instance + * @return the new {@code Observable} instance */ @CheckReturnValue @NonNull @@ -2105,7 +2111,7 @@ public static Observable generate(@NonNull Supplier initialState, @ } /** - * Returns an Observable that emits a {@code 0L} after the {@code initialDelay} and ever increasing numbers + * Returns an {@code Observable} that emits a {@code 0L} after the {@code initialDelay} and ever increasing numbers * after each {@code period} of time thereafter. *

* @@ -2120,7 +2126,7 @@ public static Observable generate(@NonNull Supplier initialState, @ * the period of time between emissions of the subsequent numbers * @param unit * the time unit for both {@code initialDelay} and {@code period} - * @return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after + * @return an {@code Observable} that emits a 0L after the {@code initialDelay} and ever increasing numbers after * each {@code period} of time thereafter * @see ReactiveX operators documentation: Interval * @since 1.0.12 @@ -2133,13 +2139,13 @@ public static Observable interval(long initialDelay, long period, @NonNull } /** - * Returns an Observable that emits a {@code 0L} after the {@code initialDelay} and ever increasing numbers + * Returns an {@code Observable} that emits a {@code 0L} after the {@code initialDelay} and ever increasing numbers * after each {@code period} of time thereafter, on a specified {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param initialDelay @@ -2149,9 +2155,9 @@ public static Observable interval(long initialDelay, long period, @NonNull * @param unit * the time unit for both {@code initialDelay} and {@code period} * @param scheduler - * the Scheduler on which the waiting happens and items are emitted - * @return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after - * each {@code period} of time thereafter, while running on the given Scheduler + * the {@code Scheduler} on which the waiting happens and items are emitted + * @return an {@code Observable} that emits a 0L after the {@code initialDelay} and ever increasing numbers after + * each {@code period} of time thereafter, while running on the given {@code Scheduler} * @see ReactiveX operators documentation: Interval * @since 1.0.12 */ @@ -2166,7 +2172,7 @@ public static Observable interval(long initialDelay, long period, @NonNull } /** - * Returns an Observable that emits a sequential number every specified interval of time. + * Returns an {@code Observable} that emits a sequential number every specified interval of time. *

* *

@@ -2178,7 +2184,7 @@ public static Observable interval(long initialDelay, long period, @NonNull * the period size in time units (see below) * @param unit * time units to use for the interval size - * @return an Observable that emits a sequential number each time interval + * @return an {@code Observable} that emits a sequential number each time interval * @see ReactiveX operators documentation: Interval */ @CheckReturnValue @@ -2189,13 +2195,13 @@ public static Observable interval(long period, @NonNull TimeUnit unit) { } /** - * Returns an Observable that emits a sequential number every specified interval of time, on a - * specified Scheduler. + * Returns an {@code Observable} that emits a sequential number every specified interval of time, on a + * specified {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param period @@ -2203,8 +2209,8 @@ public static Observable interval(long period, @NonNull TimeUnit unit) { * @param unit * time units to use for the interval size * @param scheduler - * the Scheduler to use for scheduling the items - * @return an Observable that emits a sequential number each time interval + * the {@code Scheduler} to use for scheduling the items + * @return an {@code Observable} that emits a sequential number each time interval * @see ReactiveX operators documentation: Interval */ @CheckReturnValue @@ -2225,11 +2231,11 @@ public static Observable interval(long period, @NonNull TimeUnit unit, @No *
{@code intervalRange} by default operates on the {@link Schedulers#computation() computation} {@link Scheduler}.
*
* @param start that start value of the range - * @param count the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay. - * @param initialDelay the initial delay before signalling the first value (the start) + * @param count the number of values to emit in total, if zero, the operator emits an {@code onComplete} after the initial delay. + * @param initialDelay the initial delay before signaling the first value (the start) * @param period the period between subsequent values - * @param unit the unit of measure of the initialDelay and period amounts - * @return the new Observable instance + * @param unit the unit of measure of the {@code initialDelay} and {@code period} amounts + * @return the new {@code Observable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) @@ -2248,12 +2254,12 @@ public static Observable intervalRange(long start, long count, long initia *
you provide the {@link Scheduler}.
*
* @param start that start value of the range - * @param count the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay. - * @param initialDelay the initial delay before signalling the first value (the start) + * @param count the number of values to emit in total, if zero, the operator emits an {@code onComplete} after the initial delay. + * @param initialDelay the initial delay before signaling the first value (the start) * @param period the period between subsequent values - * @param unit the unit of measure of the initialDelay and period amounts + * @param unit the unit of measure of the {@code initialDelay} and {@code period} amounts * @param scheduler the target scheduler where the values and terminal signals will be emitted - * @return the new Observable instance + * @return the new {@code Observable} instance */ @CheckReturnValue @NonNull @@ -2278,12 +2284,12 @@ public static Observable intervalRange(long start, long count, long initia } /** - * Returns an Observable that signals the given (constant reference) item and then completes. + * Returns an {@code Observable} that signals the given (constant reference) item and then completes. *

* *

* Note that the item is taken and re-emitted as is and not computed by any means by {@code just}. Use {@link #fromCallable(Callable)} - * to generate a single item on demand (when {@code Observer}s subscribe to it). + * to generate a single item on demand (when {@link Observer}s subscribe to it). *

* See the multi-parameter overloads of {@code just} to emit more than one (constant reference) items one after the other. * Use {@link #fromArray(Object...)} to emit an arbitrary number of items that are known upfront. @@ -2298,7 +2304,7 @@ public static Observable intervalRange(long start, long count, long initia * the item to emit * @param * the type of that item - * @return an Observable that emits {@code value} as a single item and then completes + * @return an {@code Observable} that emits {@code value} as a single item and then completes * @see ReactiveX operators documentation: Just * @see #just(Object, Object) * @see #fromCallable(Callable) @@ -2314,7 +2320,7 @@ public static Observable just(@NonNull T item) { } /** - * Converts two items into an ObservableSource that emits those items. + * Converts two items into an {@code Observable} that emits those items. *

* *

@@ -2328,7 +2334,7 @@ public static Observable just(@NonNull T item) { * second item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2342,7 +2348,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2) { } /** - * Converts three items into an ObservableSource that emits those items. + * Converts three items into an {@code Observable} that emits those items. *

* *

@@ -2358,7 +2364,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2) { * third item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2373,7 +2379,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul } /** - * Converts four items into an ObservableSource that emits those items. + * Converts four items into an {@code Observable} that emits those items. *

* *

@@ -2391,7 +2397,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul * fourth item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2407,7 +2413,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul } /** - * Converts five items into an ObservableSource that emits those items. + * Converts five items into an {@code Observable} that emits those items. *

* *

@@ -2427,7 +2433,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul * fifth item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2444,7 +2450,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul } /** - * Converts six items into an ObservableSource that emits those items. + * Converts six items into an {@code Observable} that emits those items. *

* *

@@ -2466,7 +2472,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul * sixth item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2484,7 +2490,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul } /** - * Converts seven items into an ObservableSource that emits those items. + * Converts seven items into an {@code Observable} that emits those items. *

* *

@@ -2508,7 +2514,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul * seventh item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2527,7 +2533,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul } /** - * Converts eight items into an ObservableSource that emits those items. + * Converts eight items into an {@code Observable} that emits those items. *

* *

@@ -2553,7 +2559,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul * eighth item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2573,7 +2579,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul } /** - * Converts nine items into an ObservableSource that emits those items. + * Converts nine items into an {@code Observable} that emits those items. *

* *

@@ -2601,7 +2607,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul * ninth item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2622,7 +2628,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul } /** - * Converts ten items into an ObservableSource that emits those items. + * Converts ten items into an {@code Observable} that emits those items. *

* *

@@ -2652,7 +2658,7 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul * tenth item * @param * the type of these items - * @return an Observable that emits each item + * @return an {@code Observable} that emits each item * @see ReactiveX operators documentation: Just */ @CheckReturnValue @@ -2674,24 +2680,24 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul } /** - * Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the - * number of concurrent subscriptions to these ObservableSources. + * Flattens an {@link Iterable} of {@link ObservableSource}s into one {@code Observable}, without any transformation, while limiting the + * number of concurrent subscriptions to these {@code ObservableSource}s. *

* *

- * You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine the items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the returned {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeDelayError(Iterable, int, int)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -2701,13 +2707,13 @@ public static Observable just(@NonNull T item1, @NonNull T item2, @NonNul * * @param the common element base type * @param sources - * the Iterable of ObservableSources + * the {@code Iterable} of {@code ObservableSource}s * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @param bufferSize - * the number of items to prefetch from each inner ObservableSource - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the number of items to prefetch from each inner {@code ObservableSource} + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the {@code Iterable} * @throws IllegalArgumentException * if {@code maxConcurrent} is less than or equal to 0 * @see ReactiveX operators documentation: Merge @@ -2722,24 +2728,24 @@ public static Observable merge(@NonNull Iterable * *

- * You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine the items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code mergeArray} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeArrayDelayError(int, int, ObservableSource...)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -2749,13 +2755,13 @@ public static Observable merge(@NonNull Iterable the common element base type * @param sources - * the array of ObservableSources + * the array of {@code ObservableSource}s * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @param bufferSize - * the number of items to prefetch from each inner ObservableSource - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the number of items to prefetch from each inner {@code ObservableSource} + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the array * @throws IllegalArgumentException * if {@code maxConcurrent} is less than or equal to 0 * @see ReactiveX operators documentation: Merge @@ -2771,23 +2777,23 @@ public static Observable mergeArray(int maxConcurrency, int bufferSize, @ } /** - * Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation. + * Flattens an {@link Iterable} of {@link ObservableSource}s into one {@code Observable}, without any transformation. *

* *

- * You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine the items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the returned {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeDelayError(Iterable)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -2797,9 +2803,9 @@ public static Observable mergeArray(int maxConcurrency, int bufferSize, @ * * @param the common element base type * @param sources - * the Iterable of ObservableSources - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the {@code Iterable} of {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the {@code Iterable} * @see ReactiveX operators documentation: Merge * @see #mergeDelayError(Iterable) */ @@ -2812,24 +2818,24 @@ public static Observable merge(@NonNull Iterable * *

- * You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine the items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the returned {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeDelayError(Iterable, int)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -2839,11 +2845,11 @@ public static Observable merge(@NonNull Iterable the common element base type * @param sources - * the Iterable of ObservableSources + * the {@code Iterable} of {@code ObservableSource}s * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the {@code Iterable} * @throws IllegalArgumentException * if {@code maxConcurrent} is less than or equal to 0 * @see ReactiveX operators documentation: Merge @@ -2858,24 +2864,24 @@ public static Observable merge(@NonNull Iterable * *

- * You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine the items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the returned {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeDelayError(ObservableSource)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -2885,9 +2891,9 @@ public static Observable merge(@NonNull Iterable the common element base type * @param sources - * an ObservableSource that emits ObservableSources - * @return an Observable that emits items that are the result of flattening the ObservableSources emitted by the - * {@code source} ObservableSource + * an {@code ObservableSource} that emits {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of flattening the {@code ObservableSource}s emitted by the + * {@code source} {@code ObservableSource} * @see ReactiveX operators documentation: Merge * @see #mergeDelayError(ObservableSource) */ @@ -2901,25 +2907,25 @@ public static Observable merge(@NonNull ObservableSource * *

- * You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine the items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the returned {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeDelayError(ObservableSource, int)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -2929,11 +2935,11 @@ public static Observable merge(@NonNull ObservableSource the common element base type * @param sources - * an ObservableSource that emits ObservableSources + * an {@code ObservableSource} that emits {@code ObservableSource}s * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently - * @return an Observable that emits items that are the result of flattening the ObservableSources emitted by the - * {@code source} ObservableSource + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently + * @return an {@code Observable} that emits items that are the result of flattening the {@code ObservableSource}s emitted by the + * {@code source} {@code ObservableSource} * @throws IllegalArgumentException * if {@code maxConcurrent} is less than or equal to 0 * @see ReactiveX operators documentation: Merge @@ -2951,23 +2957,23 @@ public static Observable merge(@NonNull ObservableSource * *

- * You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeDelayError(ObservableSource, ObservableSource)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -2977,10 +2983,10 @@ public static Observable merge(@NonNull ObservableSource the common element base type * @param source1 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source2 - * an ObservableSource to be merged - * @return an Observable that emits all of the items emitted by the source ObservableSources + * an {@code ObservableSource} to be merged + * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s * @see ReactiveX operators documentation: Merge * @see #mergeDelayError(ObservableSource, ObservableSource) */ @@ -2995,23 +3001,23 @@ public static Observable merge(@NonNull ObservableSource sou } /** - * Flattens three ObservableSources into a single ObservableSource, without any transformation. + * Flattens three {@link ObservableSource}s into a single {@code Observable}, without any transformation. *

* *

- * You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeDelayError(ObservableSource, ObservableSource, ObservableSource)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -3021,12 +3027,12 @@ public static Observable merge(@NonNull ObservableSource sou * * @param the common element base type * @param source1 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source2 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source3 - * an ObservableSource to be merged - * @return an Observable that emits all of the items emitted by the source ObservableSources + * an {@code ObservableSource} to be merged + * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s * @see ReactiveX operators documentation: Merge * @see #mergeDelayError(ObservableSource, ObservableSource, ObservableSource) */ @@ -3044,23 +3050,23 @@ public static Observable merge( } /** - * Flattens four ObservableSources into a single ObservableSource, without any transformation. + * Flattens four {@link ObservableSource}s into a single {@code Observable}, without any transformation. *

* *

- * You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code merge} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeDelayError(ObservableSource, ObservableSource, ObservableSource, ObservableSource)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -3070,14 +3076,14 @@ public static Observable merge( * * @param the common element base type * @param source1 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source2 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source3 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source4 - * an ObservableSource to be merged - * @return an Observable that emits all of the items emitted by the source ObservableSources + * an {@code ObservableSource} to be merged + * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s * @see ReactiveX operators documentation: Merge * @see #mergeDelayError(ObservableSource, ObservableSource, ObservableSource, ObservableSource) */ @@ -3096,23 +3102,23 @@ public static Observable merge( } /** - * Flattens an Array of ObservableSources into one ObservableSource, without any transformation. + * Flattens an array of {@link ObservableSource}s into one {@code Observable}, without any transformation. *

* *

- * You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code merge} method. *

*
Scheduler:
*
{@code mergeArray} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
If any of the source {@code ObservableSource}s signal a {@code Throwable} via {@code onError}, the resulting + *
If any of the {@code ObservableSource}s signal a {@link Throwable} via {@code onError}, the resulting * {@code Observable} terminates with that {@code Throwable} and all other source {@code ObservableSource}s are disposed. * If more than one {@code ObservableSource} signals an error, the resulting {@code Observable} may terminate with the * first one's error or, depending on the concurrency of the sources, may terminate with a - * {@code CompositeException} containing two or more of the various error signals. + * {@link CompositeException} containing two or more of the various error signals. * {@code Throwable}s that didn't make into the composite will be sent (individually) to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. Similarly, {@code Throwable}s + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. Similarly, {@code Throwable}s * signaled by source(s) after the returned {@code Observable} has been disposed or terminated with a * (composite) error will be sent to the same global error handler. * Use {@link #mergeArrayDelayError(ObservableSource...)} to merge sources and terminate only when all source {@code ObservableSource}s @@ -3122,8 +3128,8 @@ public static Observable merge( * * @param the common element base type * @param sources - * the array of ObservableSources - * @return an Observable that emits all of the items emitted by the ObservableSources in the Array + * the array of {@code ObservableSource}s + * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s in the array * @see ReactiveX operators documentation: Merge * @see #mergeArrayDelayError(ObservableSource...) */ @@ -3137,18 +3143,18 @@ public static Observable mergeArray(@NonNull ObservableSource - * This behaves like {@link #merge(ObservableSource)} except that if any of the merged ObservableSources notify of an + * This behaves like {@link #merge(ObservableSource)} except that if any of the merged {@code ObservableSource}s notify of an * error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from propagating that - * error notification until all of the merged ObservableSources have finished emitting items. + * error notification until all of the merged {@code ObservableSource}s have finished emitting items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3156,9 +3162,9 @@ public static Observable mergeArray(@NonNull ObservableSource the common element base type * @param sources - * the Iterable of ObservableSources - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the {@code Iterable} of {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the {@code Iterable} * @see ReactiveX operators documentation: Merge */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -3170,18 +3176,18 @@ public static Observable mergeDelayError(@NonNull Iterable - * This behaves like {@link #merge(ObservableSource)} except that if any of the merged ObservableSources notify of an + * This behaves like {@link #merge(ObservableSource)} except that if any of the merged {@code ObservableSource}s notify of an * error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from propagating that - * error notification until all of the merged ObservableSources have finished emitting items. + * error notification until all of the merged {@code ObservableSource}s have finished emitting items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3189,13 +3195,13 @@ public static Observable mergeDelayError(@NonNull Iterable the common element base type * @param sources - * the Iterable of ObservableSources + * the {@code Iterable} of {@code ObservableSource}s * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @param bufferSize - * the number of items to prefetch from each inner ObservableSource - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the number of items to prefetch from each inner {@code ObservableSource} + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the {@code Iterable} * @see ReactiveX operators documentation: Merge */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -3207,18 +3213,18 @@ public static Observable mergeDelayError(@NonNull Iterable - * This behaves like {@link #merge(ObservableSource)} except that if any of the merged ObservableSources notify of an + * This behaves like {@link #merge(ObservableSource)} except that if any of the merged {@code ObservableSource}s notify of an * error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from propagating that - * error notification until all of the merged ObservableSources have finished emitting items. + * error notification until all of the merged {@code ObservableSource}s have finished emitting items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeArrayDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3226,13 +3232,13 @@ public static Observable mergeDelayError(@NonNull Iterable the common element base type * @param sources - * the array of ObservableSources + * the array of {@code ObservableSource}s * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @param bufferSize - * the number of items to prefetch from each inner ObservableSource - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the number of items to prefetch from each inner {@code ObservableSource} + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the array * @see ReactiveX operators documentation: Merge */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -3245,18 +3251,18 @@ public static Observable mergeArrayDelayError(int maxConcurrency, int buf } /** - * Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all - * successfully emitted items from each of the source ObservableSources without being interrupted by an error - * notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources. + * Flattens an {@link Iterable} of {@link ObservableSource}s into one {@code Observable}, in a way that allows an {@link Observer} to receive all + * successfully emitted items from each of the returned {@code ObservableSource}s without being interrupted by an error + * notification from one of them, while limiting the number of concurrent subscriptions to these {@code ObservableSource}s. *

- * This behaves like {@link #merge(ObservableSource)} except that if any of the merged ObservableSources notify of an + * This behaves like {@link #merge(ObservableSource)} except that if any of the merged {@code ObservableSource}s notify of an * error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from propagating that - * error notification until all of the merged ObservableSources have finished emitting items. + * error notification until all of the merged {@code ObservableSource}s have finished emitting items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3264,11 +3270,11 @@ public static Observable mergeArrayDelayError(int maxConcurrency, int buf * * @param the common element base type * @param sources - * the Iterable of ObservableSources + * the {@code Iterable} of {@code ObservableSource}s * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the {@code Iterable} * @see ReactiveX operators documentation: Merge */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -3280,18 +3286,18 @@ public static Observable mergeDelayError(@NonNull Iterable - * This behaves like {@link #merge(ObservableSource)} except that if any of the merged ObservableSources notify of an + * This behaves like {@link #merge(ObservableSource)} except that if any of the merged {@code ObservableSource}s notify of an * error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from propagating that - * error notification until all of the merged ObservableSources have finished emitting items. + * error notification until all of the merged {@code ObservableSource}s have finished emitting items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3299,9 +3305,9 @@ public static Observable mergeDelayError(@NonNull Iterable the common element base type * @param sources - * an ObservableSource that emits ObservableSources - * @return an Observable that emits all of the items emitted by the ObservableSources emitted by the - * {@code source} ObservableSource + * an {@code ObservableSource} that emits {@code ObservableSource}s + * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s emitted by the + * {@code source} {@code ObservableSource} * @see ReactiveX operators documentation: Merge */ @CheckReturnValue @@ -3314,19 +3320,19 @@ public static Observable mergeDelayError(@NonNull ObservableSource - * This behaves like {@link #merge(ObservableSource)} except that if any of the merged ObservableSources notify of an + * This behaves like {@link #merge(ObservableSource)} except that if any of the merged {@code ObservableSource}s notify of an * error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from propagating that - * error notification until all of the merged ObservableSources have finished emitting items. + * error notification until all of the merged {@code ObservableSource}s have finished emitting items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3334,11 +3340,11 @@ public static Observable mergeDelayError(@NonNull ObservableSource the common element base type * @param sources - * an ObservableSource that emits ObservableSources + * an {@code ObservableSource} that emits {@code ObservableSource}s * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently - * @return an Observable that emits all of the items emitted by the ObservableSources emitted by the - * {@code source} ObservableSource + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently + * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s emitted by the + * {@code source} {@code ObservableSource} * @see ReactiveX operators documentation: Merge * @since 2.0 */ @@ -3353,18 +3359,18 @@ public static Observable mergeDelayError(@NonNull ObservableSource - * This behaves like {@link #merge(ObservableSource, ObservableSource)} except that if any of the merged ObservableSources + * This behaves like {@link #merge(ObservableSource, ObservableSource)} except that if any of the merged {@code ObservableSource}s * notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from - * propagating that error notification until all of the merged ObservableSources have finished emitting items. + * propagating that error notification until all of the merged {@code ObservableSource}s have finished emitting items. *

* *

- * Even if both merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if both merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3372,10 +3378,10 @@ public static Observable mergeDelayError(@NonNull ObservableSource the common element base type * @param source1 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source2 - * an ObservableSource to be merged - * @return an Observable that emits all of the items that are emitted by the two source ObservableSources + * an {@code ObservableSource} to be merged + * @return an {@code Observable} that emits all of the items that are emitted by the two source {@code ObservableSource}s * @see ReactiveX operators documentation: Merge */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -3390,19 +3396,19 @@ public static Observable mergeDelayError( } /** - * Flattens three ObservableSources into one ObservableSource, in a way that allows an Observer to receive all - * successfully emitted items from all of the source ObservableSources without being interrupted by an error + * Flattens three {@link ObservableSource}s into one {@code Observable}, in a way that allows an {@link Observer} to receive all + * successfully emitted items from all of the {@code ObservableSource}s without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(ObservableSource, ObservableSource, ObservableSource)} except that if any of the merged - * ObservableSources notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain - * from propagating that error notification until all of the merged ObservableSources have finished emitting + * {@code ObservableSource}s notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain + * from propagating that error notification until all of the merged {@code ObservableSource}s have finished emitting * items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3410,12 +3416,12 @@ public static Observable mergeDelayError( * * @param the common element base type * @param source1 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source2 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source3 - * an ObservableSource to be merged - * @return an Observable that emits all of the items that are emitted by the source ObservableSources + * an {@code ObservableSource} to be merged + * @return an {@code Observable} that emits all of the items that are emitted by the {@code ObservableSource}s * @see ReactiveX operators documentation: Merge */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -3432,19 +3438,19 @@ public static Observable mergeDelayError( } /** - * Flattens four ObservableSources into one ObservableSource, in a way that allows an Observer to receive all - * successfully emitted items from all of the source ObservableSources without being interrupted by an error + * Flattens four {@link ObservableSource}s into one {@code Observable}, in a way that allows an {@link Observer} to receive all + * successfully emitted items from all of the {@code ObservableSource}s without being interrupted by an error * notification from one of them. *

* This behaves like {@link #merge(ObservableSource, ObservableSource, ObservableSource, ObservableSource)} except that if any of - * the merged ObservableSources notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} - * will refrain from propagating that error notification until all of the merged ObservableSources have finished + * the merged {@code ObservableSource}s notify of an error via {@link Observer#onError onError}, {@code mergeDelayError} + * will refrain from propagating that error notification until all of the merged {@code ObservableSource}s have finished * emitting items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3452,14 +3458,14 @@ public static Observable mergeDelayError( * * @param the common element base type * @param source1 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source2 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source3 - * an ObservableSource to be merged + * an {@code ObservableSource} to be merged * @param source4 - * an ObservableSource to be merged - * @return an Observable that emits all of the items that are emitted by the source ObservableSources + * an {@code ObservableSource} to be merged + * @return an {@code Observable} that emits all of the items that are emitted by the {@code ObservableSource}s * @see ReactiveX operators documentation: Merge */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -3477,18 +3483,18 @@ public static Observable mergeDelayError( } /** - * Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all - * successfully emitted items from each of the source ObservableSources without being interrupted by an error + * Flattens an array of {@link ObservableSource}s into one {@code Observable}, in a way that allows an {@link Observer} to receive all + * successfully emitted items from each of the {@code ObservableSource}s without being interrupted by an error * notification from one of them. *

- * This behaves like {@link #merge(ObservableSource)} except that if any of the merged ObservableSources notify of an + * This behaves like {@link #merge(ObservableSource)} except that if any of the merged {@code ObservableSource}s notify of an * error via {@link Observer#onError onError}, {@code mergeDelayError} will refrain from propagating that - * error notification until all of the merged ObservableSources have finished emitting items. + * error notification until all of the merged {@code ObservableSource}s have finished emitting items. *

* *

- * Even if multiple merged ObservableSources send {@code onError} notifications, {@code mergeDelayError} will only - * invoke the {@code onError} method of its Observers once. + * Even if multiple merged {@code ObservableSource}s send {@code onError} notifications, {@code mergeDelayError} will only + * invoke the {@code onError} method of its {@code Observer}s once. *

*
Scheduler:
*
{@code mergeArrayDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3496,9 +3502,9 @@ public static Observable mergeDelayError( * * @param the common element base type * @param sources - * the Iterable of ObservableSources - * @return an Observable that emits items that are the result of flattening the items emitted by the - * ObservableSources in the Iterable + * the array of {@code ObservableSource}s + * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the + * {@code ObservableSource}s in the array * @see ReactiveX operators documentation: Merge */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -3511,19 +3517,19 @@ public static Observable mergeArrayDelayError(@NonNull ObservableSource * *

- * This ObservableSource is useful primarily for testing purposes. + * This {@code Observable} is useful primarily for testing purposes. *

*
Scheduler:
*
{@code never} does not operate by default on a particular {@link Scheduler}.
*
* * @param - * the type of items (not) emitted by the ObservableSource - * @return an Observable that never emits any items or sends any notifications to an {@link Observer} + * the type of items (not) emitted by the {@code Observable} + * @return an {@code Observable} that never emits any items or sends any notifications to an {@code Observer} * @see ReactiveX operators documentation: Never */ @CheckReturnValue @@ -3535,7 +3541,7 @@ public static Observable never() { } /** - * Returns an Observable that emits a sequence of Integers within a specified range. + * Returns an {@code Observable} that emits a sequence of {@link Integer}s within a specified range. *

* *

@@ -3544,10 +3550,10 @@ public static Observable never() { *
* * @param start - * the value of the first Integer in the sequence + * the value of the first {@code Integer} in the sequence * @param count - * the number of sequential Integers to generate - * @return an Observable that emits a range of sequential Integers + * the number of sequential {@code Integer}s to generate + * @return an {@code Observable} that emits a range of sequential {@code Integer}s * @throws IllegalArgumentException * if {@code count} is less than zero, or if {@code start} + {@code count} − 1 exceeds * {@link Integer#MAX_VALUE} @@ -3573,7 +3579,7 @@ public static Observable range(int start, int count) { } /** - * Returns an Observable that emits a sequence of Longs within a specified range. + * Returns an {@code Observable} that emits a sequence of {@link Long}s within a specified range. *

* *

@@ -3582,10 +3588,10 @@ public static Observable range(int start, int count) { *
* * @param start - * the value of the first Long in the sequence + * the value of the first {@code Long} in the sequence * @param count - * the number of sequential Longs to generate - * @return an Observable that emits a range of sequential Longs + * the number of sequential {@code Long}s to generate + * @return an {@code Observable} that emits a range of sequential {@code Long}s * @throws IllegalArgumentException * if {@code count} is less than zero, or if {@code start} + {@code count} − 1 exceeds * {@link Long#MAX_VALUE} @@ -3616,8 +3622,8 @@ public static Observable rangeLong(long start, long count) { } /** - * Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the - * same by comparing the items emitted by each ObservableSource pairwise. + * Returns a {@link Single} that emits a {@link Boolean} value that indicates whether two {@link ObservableSource} sequences are the + * same by comparing the items emitted by each {@code ObservableSource} pairwise. *

* *

@@ -3626,12 +3632,12 @@ public static Observable rangeLong(long start, long count) { *
* * @param source1 - * the first ObservableSource to compare + * the first {@code ObservableSource} to compare * @param source2 - * the second ObservableSource to compare + * the second {@code ObservableSource} to compare * @param - * the type of items emitted by each ObservableSource - * @return a Single that emits a Boolean value that indicates whether the two sequences are the same + * the type of items emitted by each {@code ObservableSource} + * @return a {@code Single} that emits a {@code Boolean} value that indicates whether the two sequences are the same * @see ReactiveX operators documentation: SequenceEqual */ @CheckReturnValue @@ -3642,8 +3648,8 @@ public static Single sequenceEqual(@NonNull ObservableSource * @@ -3653,14 +3659,14 @@ public static Single sequenceEqual(@NonNull ObservableSource * * @param source1 - * the first ObservableSource to compare + * the first {@code ObservableSource} to compare * @param source2 - * the second ObservableSource to compare + * the second {@code ObservableSource} to compare * @param isEqual - * a function used to compare items emitted by each ObservableSource + * a function used to compare items emitted by each {@code ObservableSource} * @param - * the type of items emitted by each ObservableSource - * @return a Single that emits a Boolean value that indicates whether the two ObservableSource two sequences + * the type of items emitted by each {@code ObservableSource} + * @return a {@code Single} that emits a {@code Boolean} value that indicates whether the two {@code ObservableSource} two sequences * are the same according to the specified function * @see ReactiveX operators documentation: SequenceEqual */ @@ -3674,8 +3680,8 @@ public static Single sequenceEqual( } /** - * Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the - * same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified + * Returns a {@link Single} that emits a {@link Boolean} value that indicates whether two {@link ObservableSource} sequences are the + * same by comparing the items emitted by each {@code ObservableSource} pairwise based on the results of a specified * equality function. *

* @@ -3685,16 +3691,16 @@ public static Single sequenceEqual( *

* * @param source1 - * the first ObservableSource to compare + * the first {@code ObservableSource} to compare * @param source2 - * the second ObservableSource to compare + * the second {@code ObservableSource} to compare * @param isEqual - * a function used to compare items emitted by each ObservableSource + * a function used to compare items emitted by each {@code ObservableSource} * @param bufferSize - * the number of items to prefetch from the first and second source ObservableSource + * the number of items to prefetch from the first and second source {@code ObservableSource} * @param - * the type of items emitted by each ObservableSource - * @return an Observable that emits a Boolean value that indicates whether the two ObservableSource two sequences + * the type of items emitted by each {@code ObservableSource} + * @return a {@code Single} that emits a {@code Boolean} value that indicates whether the two {@code ObservableSource} two sequences * are the same according to the specified function * @see ReactiveX operators documentation: SequenceEqual */ @@ -3712,8 +3718,8 @@ public static Single sequenceEqual( } /** - * Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the - * same by comparing the items emitted by each ObservableSource pairwise. + * Returns a {@link Single} that emits a {@link Boolean} value that indicates whether two {@link ObservableSource} sequences are the + * same by comparing the items emitted by each {@code ObservableSource} pairwise. *

* *

@@ -3722,14 +3728,14 @@ public static Single sequenceEqual( *
* * @param source1 - * the first ObservableSource to compare + * the first {@code ObservableSource} to compare * @param source2 - * the second ObservableSource to compare + * the second {@code ObservableSource} to compare * @param bufferSize - * the number of items to prefetch from the first and second source ObservableSource + * the number of items to prefetch from the first and second source {@code ObservableSource} * @param - * the type of items emitted by each ObservableSource - * @return a Single that emits a Boolean value that indicates whether the two sequences are the same + * the type of items emitted by each {@code ObservableSource} + * @return a {@code Single} that emits a {@code Boolean} value that indicates whether the two sequences are the same * @see ReactiveX operators documentation: SequenceEqual */ @CheckReturnValue @@ -3741,18 +3747,18 @@ public static Single sequenceEqual(@NonNull ObservableSource * *

- * {@code switchOnNext} subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of - * these emitted ObservableSources, the ObservableSource returned by {@code switchOnNext} begins emitting the items - * emitted by that ObservableSource. When a new ObservableSource is emitted, {@code switchOnNext} stops emitting items - * from the earlier-emitted ObservableSource and begins emitting items from the new one. + * {@code switchOnNext} subscribes to an {@code ObservableSource} that emits {@code ObservableSource}s. Each time it observes one of + * these emitted {@code ObservableSource}s, the {@code ObservableSource} returned by {@code switchOnNext} begins emitting the items + * emitted by that {@code ObservableSource}. When a new {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items + * from the earlier-emitted {@code ObservableSource} and begins emitting items from the new one. *

- * The resulting ObservableSource completes if both the outer ObservableSource and the last inner ObservableSource, if any, complete. - * If the outer ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence. + * The resulting {@code Observable} completes if both the outer {@code ObservableSource} and the last inner {@code ObservableSource}, if any, complete. + * If the outer {@code ObservableSource} signals an {@code onError}, the inner {@code ObservableSource} is disposed and the error delivered in-sequence. *

*
Scheduler:
*
{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.
@@ -3760,11 +3766,11 @@ public static Single sequenceEqual(@NonNull ObservableSource the item type * @param sources - * the source ObservableSource that emits ObservableSources + * the {@code ObservableSource} that emits {@code ObservableSource}s * @param bufferSize - * the number of items to prefetch from the inner ObservableSources - * @return an Observable that emits the items emitted by the ObservableSource most recently emitted by the source - * ObservableSource + * the expected number of items to cache from the inner {@code ObservableSource}s + * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} most recently emitted by the + * {@code sources} {@code ObservableSource} * @see ReactiveX operators documentation: Switch */ @SuppressWarnings({ "rawtypes", "unchecked" }) @@ -3778,18 +3784,18 @@ public static Observable switchOnNext(@NonNull ObservableSource * *

- * {@code switchOnNext} subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of - * these emitted ObservableSources, the ObservableSource returned by {@code switchOnNext} begins emitting the items - * emitted by that ObservableSource. When a new ObservableSource is emitted, {@code switchOnNext} stops emitting items - * from the earlier-emitted ObservableSource and begins emitting items from the new one. + * {@code switchOnNext} subscribes to an {@code ObservableSource} that emits {@code ObservableSource}s. Each time it observes one of + * these emitted {@code ObservableSource}s, the {@code ObservableSource} returned by {@code switchOnNext} begins emitting the items + * emitted by that {@code ObservableSource}. When a new {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items + * from the earlier-emitted {@code ObservableSource} and begins emitting items from the new one. *

- * The resulting ObservableSource completes if both the outer ObservableSource and the last inner ObservableSource, if any, complete. - * If the outer ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence. + * The resulting {@code Observable} completes if both the outer {@code ObservableSource} and the last inner {@code ObservableSource}, if any, complete. + * If the outer {@code ObservableSource} signals an {@code onError}, the inner {@code ObservableSource} is disposed and the error delivered in-sequence. *

*
Scheduler:
*
{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.
@@ -3797,9 +3803,9 @@ public static Observable switchOnNext(@NonNull ObservableSource the item type * @param sources - * the source ObservableSource that emits ObservableSources - * @return an Observable that emits the items emitted by the ObservableSource most recently emitted by the source - * ObservableSource + * the {@code ObservableSource} that emits {@code ObservableSource}s + * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} most recently emitted by the {@code sources} + * {@code ObservableSource} * @see ReactiveX operators documentation: Switch */ @CheckReturnValue @@ -3810,19 +3816,19 @@ public static Observable switchOnNext(@NonNull ObservableSource * *

- * {@code switchOnNext} subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of - * these emitted ObservableSources, the ObservableSource returned by {@code switchOnNext} begins emitting the items - * emitted by that ObservableSource. When a new ObservableSource is emitted, {@code switchOnNext} stops emitting items - * from the earlier-emitted ObservableSource and begins emitting items from the new one. + * {@code switchOnNext} subscribes to an {@code ObservableSource} that emits {@code ObservableSource}s. Each time it observes one of + * these emitted {@code ObservableSource}s, the {@code ObservableSource} returned by {@code switchOnNext} begins emitting the items + * emitted by that {@code ObservableSource}. When a new {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items + * from the earlier-emitted {@code ObservableSource} and begins emitting items from the new one. *

- * The resulting ObservableSource completes if both the main ObservableSource and the last inner ObservableSource, if any, complete. - * If the main ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is - * or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signalled. + * The resulting {@code Observable} completes if both the main {@code ObservableSource} and the last inner {@code ObservableSource}, if any, complete. + * If the main {@code ObservableSource} signals an {@code onError}, the termination of the last inner {@code ObservableSource} will emit that error as is + * or wrapped into a {@link CompositeException} along with the other possible errors the former inner {@code ObservableSource}s signaled. *

*
Scheduler:
*
{@code switchOnNextDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3830,9 +3836,9 @@ public static Observable switchOnNext(@NonNull ObservableSource the item type * @param sources - * the source ObservableSource that emits ObservableSources - * @return an Observable that emits the items emitted by the ObservableSource most recently emitted by the source - * ObservableSource + * the {@code ObservableSource} that emits {@code ObservableSource}s + * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} most recently emitted by the {@code sources} + * {@code ObservableSource} * @see ReactiveX operators documentation: Switch * @since 2.0 */ @@ -3844,19 +3850,19 @@ public static Observable switchOnNextDelayError(@NonNull ObservableSource } /** - * Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the - * most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate. + * Converts an {@link ObservableSource} that emits {@code ObservableSource}s into an {@code Observable} that emits the items emitted by the + * most recently emitted of those {@code ObservableSource}s and delays any exception until all {@code ObservableSource}s terminate. *

* *

- * {@code switchOnNext} subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of - * these emitted ObservableSources, the ObservableSource returned by {@code switchOnNext} begins emitting the items - * emitted by that ObservableSource. When a new ObservableSource is emitted, {@code switchOnNext} stops emitting items - * from the earlier-emitted ObservableSource and begins emitting items from the new one. + * {@code switchOnNext} subscribes to an {@code ObservableSource} that emits {@code ObservableSource}s. Each time it observes one of + * these emitted {@code ObservableSource}s, the {@code ObservableSource} returned by {@code switchOnNext} begins emitting the items + * emitted by that {@code ObservableSource}. When a new {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items + * from the earlier-emitted {@code ObservableSource} and begins emitting items from the new one. *

- * The resulting ObservableSource completes if both the main ObservableSource and the last inner ObservableSource, if any, complete. - * If the main ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is - * or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signalled. + * The resulting {@code Observable} completes if both the main {@code ObservableSource} and the last inner {@code ObservableSource}, if any, complete. + * If the main {@code ObservableSource} signals an {@code onError}, the termination of the last inner {@code ObservableSource} will emit that error as is + * or wrapped into a {@link CompositeException} along with the other possible errors the former inner {@code ObservableSource}s signaled. *

*
Scheduler:
*
{@code switchOnNextDelayError} does not operate by default on a particular {@link Scheduler}.
@@ -3864,11 +3870,11 @@ public static Observable switchOnNextDelayError(@NonNull ObservableSource * * @param the item type * @param sources - * the source ObservableSource that emits ObservableSources - * @param prefetch - * the number of items to prefetch from the inner ObservableSources - * @return an Observable that emits the items emitted by the ObservableSource most recently emitted by the source - * ObservableSource + * the {@code ObservableSource} that emits {@code ObservableSource}s + * @param bufferSize + * the expected number of items to cache from the inner {@code ObservableSource}s + * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} most recently emitted by the {@code sources} + * {@code ObservableSource} * @see ReactiveX operators documentation: Switch * @since 2.0 */ @@ -3876,14 +3882,14 @@ public static Observable switchOnNextDelayError(@NonNull ObservableSource @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @NonNull - public static Observable switchOnNextDelayError(@NonNull ObservableSource> sources, int prefetch) { + public static Observable switchOnNextDelayError(@NonNull ObservableSource> sources, int bufferSize) { Objects.requireNonNull(sources, "sources is null"); - ObjectHelper.verifyPositive(prefetch, "prefetch"); - return RxJavaPlugins.onAssembly(new ObservableSwitchMap(sources, Functions.identity(), prefetch, true)); + ObjectHelper.verifyPositive(bufferSize, "bufferSize"); + return RxJavaPlugins.onAssembly(new ObservableSwitchMap(sources, Functions.identity(), bufferSize, true)); } /** - * Returns an Observable that emits {@code 0L} after a specified delay, and then completes. + * Returns an {@code Observable} that emits {@code 0L} after a specified delay, and then completes. *

* *

@@ -3895,7 +3901,7 @@ public static Observable switchOnNextDelayError(@NonNull ObservableSource * the initial delay before emitting a single {@code 0L} * @param unit * time units to use for {@code delay} - * @return an Observable that {@code 0L} after a specified delay, and then completes + * @return an {@code Observable} that {@code 0L} after a specified delay, and then completes * @see ReactiveX operators documentation: Timer */ @CheckReturnValue @@ -3906,13 +3912,13 @@ public static Observable timer(long delay, @NonNull TimeUnit unit) { } /** - * Returns an Observable that emits {@code 0L} after a specified delay, on a specified Scheduler, and then + * Returns an {@code Observable} that emits {@code 0L} after a specified delay, on a specified {@link Scheduler}, and then * completes. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param delay @@ -3920,11 +3926,10 @@ public static Observable timer(long delay, @NonNull TimeUnit unit) { * @param unit * time units to use for {@code delay} * @param scheduler - * the {@link Scheduler} to use for scheduling the item + * the {@code Scheduler} to use for scheduling the item * @throws NullPointerException - * if {@code unit} is null, or - * if {@code scheduler} is null - * @return an Observable that emits {@code 0L} after a specified delay, on a specified Scheduler, and then + * if {@code unit} or {@code scheduler} is {@code null} + * @return an {@code Observable} that emits {@code 0L} after a specified delay, on a specified {@code Scheduler}, and then * completes * @see ReactiveX operators documentation: Timer */ @@ -3939,16 +3944,19 @@ public static Observable timer(long delay, @NonNull TimeUnit unit, @NonNul } /** - * Create an Observable by wrapping an ObservableSource which has to be implemented according - * to the Reactive-Streams-based Observable specification by handling - * disposal correctly; no safeguards are provided by the Observable itself. + * Create an {@code Observable} by wrapping an {@link ObservableSource} which has to be implemented according + * to the {@code Observable} specification derived from the Reactive Streams specification by handling + * disposal correctly; no safeguards are provided by the {@code Observable} itself. *
*
Scheduler:
*
{@code unsafeCreate} by default doesn't operate on any particular {@link Scheduler}.
*
* @param the value type emitted - * @param onSubscribe the ObservableSource instance to wrap - * @return the new Observable instance + * @param onSubscribe the {@code ObservableSource} instance to wrap + * @return the new {@code Observable} instance + * @throws IllegalArgumentException if the {@code onSubscribe} is already an {@code Observable}, use + * {@link #wrap(ObservableSource)} in this case + * @see #wrap(ObservableSource) */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -3962,8 +3970,9 @@ public static Observable unsafeCreate(@NonNull ObservableSource onSubs } /** - * Constructs an ObservableSource that creates a dependent resource object which is disposed of when the downstream - * calls dispose(). + * Constructs an {@code Observable} that creates a dependent resource object, an {@link ObservableSource} with + * that resource and calls the provided {@code resourceDisposer} function if this inner source terminates or the + * downstream disposes the flow. *

* *

@@ -3971,15 +3980,15 @@ public static Observable unsafeCreate(@NonNull ObservableSource onSubs *
{@code using} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the element type of the generated ObservableSource + * @param the element type of the generated {@code Observable} * @param the type of the resource associated with the output sequence * @param resourceSupplier - * the factory function to create a resource object that depends on the ObservableSource + * the factory function to create a resource object that depends on the {@code ObservableSource} * @param sourceSupplier - * the factory function to create an ObservableSource - * @param disposer + * the factory function to create an {@code ObservableSource} + * @param resourceDisposer * the function that will dispose of the resource - * @return the ObservableSource whose lifetime controls the lifetime of the dependent resource object + * @return the {@code ObservableSource} whose lifetime controls the lifetime of the dependent resource object * @see ReactiveX operators documentation: Using */ @CheckReturnValue @@ -3988,16 +3997,14 @@ public static Observable unsafeCreate(@NonNull ObservableSource onSubs public static Observable using( @NonNull Supplier resourceSupplier, @NonNull Function> sourceSupplier, - @NonNull Consumer disposer) { - return using(resourceSupplier, sourceSupplier, disposer, true); + @NonNull Consumer resourceDisposer) { + return using(resourceSupplier, sourceSupplier, resourceDisposer, true); } /** - * Constructs an ObservableSource that creates a dependent resource object which is disposed of just before - * termination if you have set {@code disposeEagerly} to {@code true} and a dispose() call does not occur - * before termination. Otherwise resource disposal will occur on a dispose() call. Eager disposal is - * particularly appropriate for a synchronous ObservableSource that reuses resources. {@code disposeAction} will - * only be called once per subscription. + * Constructs an {@code Observable} that creates a dependent resource object, an {@link ObservableSource} with + * that resource and calls the provided {@code disposer} function if this inner source terminates or the + * downstream disposes the flow; doing it before these end-states have been reached if {@code eager == true}, after otherwise. *

* *

@@ -4005,20 +4012,20 @@ public static Observable using( *
{@code using} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the element type of the generated ObservableSource + * @param the element type of the generated {@code ObservableSource} * @param the type of the resource associated with the output sequence * @param resourceSupplier - * the factory function to create a resource object that depends on the ObservableSource + * the factory function to create a resource object that depends on the {@code ObservableSource} * @param sourceSupplier - * the factory function to create an ObservableSource - * @param disposer + * the factory function to create an {@code ObservableSource} + * @param resourceDisposer * the function that will dispose of the resource * @param eager * If {@code true} then resource disposal will happen either on a {@code dispose()} call before the upstream is disposed * or just before the emission of a terminal event ({@code onComplete} or {@code onError}). * If {@code false} the resource disposal will happen either on a {@code dispose()} call after the upstream is disposed * or just after the emission of a terminal event ({@code onComplete} or {@code onError}). - * @return the ObservableSource whose lifetime controls the lifetime of the dependent resource object + * @return the {@code ObservableSource} whose lifetime controls the lifetime of the dependent resource object * @see ReactiveX operators documentation: Using * @since 2.0 */ @@ -4028,15 +4035,15 @@ public static Observable using( public static Observable using( @NonNull Supplier resourceSupplier, @NonNull Function> sourceSupplier, - @NonNull Consumer disposer, boolean eager) { + @NonNull Consumer resourceDisposer, boolean eager) { Objects.requireNonNull(resourceSupplier, "resourceSupplier is null"); Objects.requireNonNull(sourceSupplier, "sourceSupplier is null"); - Objects.requireNonNull(disposer, "disposer is null"); - return RxJavaPlugins.onAssembly(new ObservableUsing(resourceSupplier, sourceSupplier, disposer, eager)); + Objects.requireNonNull(resourceDisposer, "resourceDisposer is null"); + return RxJavaPlugins.onAssembly(new ObservableUsing(resourceSupplier, sourceSupplier, resourceDisposer, eager)); } /** - * Wraps an ObservableSource into an Observable if not already an Observable. + * Wraps an {@link ObservableSource} into an {@code Observable} if not already an {@code Observable}. * *
*
Scheduler:
@@ -4044,9 +4051,9 @@ public static Observable using( *
* * @param the value type - * @param source the source ObservableSource instance - * @return the new Observable instance or the same as the source - * @throws NullPointerException if source is null + * @param source the {@code ObservableSource} instance to wrap or cast to {@code Observable} + * @return the new {@code Observable} instance or the same as the source + * @throws NullPointerException if {@code source} is {@code null} */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -4060,16 +4067,16 @@ public static Observable wrap(@NonNull ObservableSource source) { } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * items emitted, in sequence, by an Iterable of other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * items emitted, in sequence, by an {@link Iterable} of other {@link ObservableSource}s. *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource - * will be the result of the function applied to the first item emitted by each of the source ObservableSources; - * the second item emitted by the new ObservableSource will be the result of the function applied to the second - * item emitted by each of those ObservableSources; and so forth. + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * will be the result of the function applied to the first item emitted by each of the {@code ObservableSource}s; + * the second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second + * item emitted by each of those {@code ObservableSource}s; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@code onNext} as many times as - * the number of {@code onNext} invocations of the source ObservableSource that emits the fewest items. + * The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as + * the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if * one of the sources is shorter than the rest while disposing the other sources. Therefore, it @@ -4085,7 +4092,7 @@ public static Observable wrap(@NonNull ObservableSource source) { *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. * *

* @@ -4097,11 +4104,11 @@ public static Observable wrap(@NonNull ObservableSource source) { * @param the common value type * @param the zipped result type * @param sources - * an Iterable of source ObservableSources + * an {@code Iterable} of source {@code ObservableSource}s * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4114,16 +4121,16 @@ public static Observable zip(@NonNull Iterable - * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource - * will be the result of the function applied to the first item emitted by each of the source ObservableSources; - * the second item emitted by the new ObservableSource will be the result of the function applied to the second - * item emitted by each of those ObservableSources; and so forth. + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * will be the result of the function applied to the first item emitted by each of the {@code ObservableSource}s; + * the second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second + * item emitted by each of those {@code ObservableSource}s; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@code onNext} as many times as - * the number of {@code onNext} invocations of the source ObservableSource that emits the fewest items. + * The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as + * the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if * one of the sources is shorter than the rest while disposing the other sources. Therefore, it @@ -4139,7 +4146,7 @@ public static Observable zip(@NonNull Iterable * Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. * *

* @@ -4150,17 +4157,17 @@ public static Observable zip(@NonNull Iterable the common source value type * @param the zipped result type - * @return an Observable that emits the zipped results + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4176,18 +4183,18 @@ public static Observable zip(@NonNull Iterable * *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} * will be the result of the function applied to the first item emitted by {@code o1} and the first item - * emitted by {@code o2}; the second item emitted by the new ObservableSource will be the result of the function + * emitted by {@code o2}; the second item emitted by the new {@code ObservableSource} will be the result of the function * applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4210,13 +4217,13 @@ public static Observable zip(@NonNull Iterable the value type of the second source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results - * in an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results + * in an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4232,18 +4239,18 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * two items emitted, in sequence, by two other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * two items emitted, in sequence, by two other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} * will be the result of the function applied to the first item emitted by {@code o1} and the first item - * emitted by {@code o2}; the second item emitted by the new ObservableSource will be the result of the function + * emitted by {@code o2}; the second item emitted by the new {@code ObservableSource} will be the result of the function * applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4266,14 +4273,14 @@ public static Observable zip( * @param the value type of the second source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results - * in an item that will be emitted by the resulting ObservableSource - * @param delayError delay errors from any of the source ObservableSources till the other terminates - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results + * in an item that will be emitted by the resulting {@code Observable} + * @param delayError delay errors from any of the {@code ObservableSource}s till the other terminates + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4289,18 +4296,18 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * two items emitted, in sequence, by two other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * two items emitted, in sequence, by two other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} * will be the result of the function applied to the first item emitted by {@code o1} and the first item - * emitted by {@code o2}; the second item emitted by the new ObservableSource will be the result of the function + * emitted by {@code o2}; the second item emitted by the new {@code ObservableSource} will be the result of the function * applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4323,15 +4330,15 @@ public static Observable zip( * @param the value type of the second source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results - * in an item that will be emitted by the resulting ObservableSource - * @param delayError delay errors from any of the source ObservableSources till the other terminates - * @param bufferSize the number of elements to prefetch from each source ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results + * in an item that will be emitted by the resulting {@code Observable} + * @param delayError delay errors from any of the {@code ObservableSource}s till the other terminates + * @param bufferSize the number of elements to prefetch from each source {@code ObservableSource} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4347,19 +4354,19 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * three items emitted, in sequence, by three other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * three items emitted, in sequence, by three other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} * will be the result of the function applied to the first item emitted by {@code o1}, the first item * emitted by {@code o2}, and the first item emitted by {@code o3}; the second item emitted by the new - * ObservableSource will be the result of the function applied to the second item emitted by {@code o1}, the + * {@code ObservableSource} will be the result of the function applied to the second item emitted by {@code o1}, the * second item emitted by {@code o2}, and the second item emitted by {@code o3}; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4383,15 +4390,15 @@ public static Observable zip( * @param the value type of the third source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param source3 - * a third source ObservableSource + * a third source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4409,19 +4416,19 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * four items emitted, in sequence, by four other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * four items emitted, in sequence, by four other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} * will be the result of the function applied to the first item emitted by {@code o1}, the first item * emitted by {@code o2}, the first item emitted by {@code o3}, and the first item emitted by {@code 04}; - * the second item emitted by the new ObservableSource will be the result of the function applied to the second - * item emitted by each of those ObservableSources; and so forth. + * the second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second + * item emitted by each of those {@code ObservableSource}s; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4446,17 +4453,17 @@ public static Observable zip( * @param the value type of the fourth source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param source3 - * a third source ObservableSource + * a third source {@code ObservableSource} * @param source4 - * a fourth source ObservableSource + * a fourth source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4475,19 +4482,19 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * five items emitted, in sequence, by five other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * five items emitted, in sequence, by five other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} * will be the result of the function applied to the first item emitted by {@code o1}, the first item * emitted by {@code o2}, the first item emitted by {@code o3}, the first item emitted by {@code o4}, and - * the first item emitted by {@code o5}; the second item emitted by the new ObservableSource will be the result of - * the function applied to the second item emitted by each of those ObservableSources; and so forth. + * the first item emitted by {@code o5}; the second item emitted by the new {@code ObservableSource} will be the result of + * the function applied to the second item emitted by each of those {@code ObservableSource}s; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4513,19 +4520,19 @@ public static Observable zip( * @param the value type of the fifth source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param source3 - * a third source ObservableSource + * a third source {@code ObservableSource} * @param source4 - * a fourth source ObservableSource + * a fourth source {@code ObservableSource} * @param source5 - * a fifth source ObservableSource + * a fifth source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4545,18 +4552,18 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * six items emitted, in sequence, by six other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * six items emitted, in sequence, by six other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource - * will be the result of the function applied to the first item emitted by each source ObservableSource, the - * second item emitted by the new ObservableSource will be the result of the function applied to the second item - * emitted by each of those ObservableSources, and so forth. + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * will be the result of the function applied to the first item emitted by each source {@code ObservableSource}, the + * second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second item + * emitted by each of those {@code ObservableSource}s, and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4583,21 +4590,21 @@ public static Observable zip( * @param the value type of the sixth source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param source3 - * a third source ObservableSource + * a third source {@code ObservableSource} * @param source4 - * a fourth source ObservableSource + * a fourth source {@code ObservableSource} * @param source5 - * a fifth source ObservableSource + * a fifth source {@code ObservableSource} * @param source6 - * a sixth source ObservableSource + * a sixth source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4618,18 +4625,18 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * seven items emitted, in sequence, by seven other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * seven items emitted, in sequence, by seven other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource - * will be the result of the function applied to the first item emitted by each source ObservableSource, the - * second item emitted by the new ObservableSource will be the result of the function applied to the second item - * emitted by each of those ObservableSources, and so forth. + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * will be the result of the function applied to the first item emitted by each source {@code ObservableSource}, the + * second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second item + * emitted by each of those {@code ObservableSource}s, and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4657,23 +4664,23 @@ public static Observable zip( * @param the value type of the seventh source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param source3 - * a third source ObservableSource + * a third source {@code ObservableSource} * @param source4 - * a fourth source ObservableSource + * a fourth source {@code ObservableSource} * @param source5 - * a fifth source ObservableSource + * a fifth source {@code ObservableSource} * @param source6 - * a sixth source ObservableSource + * a sixth source {@code ObservableSource} * @param source7 - * a seventh source ObservableSource + * a seventh source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4696,18 +4703,18 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * eight items emitted, in sequence, by eight other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * eight items emitted, in sequence, by eight other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource - * will be the result of the function applied to the first item emitted by each source ObservableSource, the - * second item emitted by the new ObservableSource will be the result of the function applied to the second item - * emitted by each of those ObservableSources, and so forth. + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * will be the result of the function applied to the first item emitted by each source {@code ObservableSource}, the + * second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second item + * emitted by each of those {@code ObservableSource}s, and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4736,25 +4743,25 @@ public static Observable zip( * @param the value type of the eighth source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param source3 - * a third source ObservableSource + * a third source {@code ObservableSource} * @param source4 - * a fourth source ObservableSource + * a fourth source {@code ObservableSource} * @param source5 - * a fifth source ObservableSource + * a fifth source {@code ObservableSource} * @param source6 - * a sixth source ObservableSource + * a sixth source {@code ObservableSource} * @param source7 - * a seventh source ObservableSource + * a seventh source {@code ObservableSource} * @param source8 - * an eighth source ObservableSource + * an eighth source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4778,18 +4785,18 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * nine items emitted, in sequence, by nine other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * nine items emitted, in sequence, by nine other {@link ObservableSource}s. *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource - * will be the result of the function applied to the first item emitted by each source ObservableSource, the - * second item emitted by the new ObservableSource will be the result of the function applied to the second item - * emitted by each of those ObservableSources, and so forth. + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * will be the result of the function applied to the first item emitted by each source {@code ObservableSource}, the + * second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second item + * emitted by each of those {@code ObservableSource}s, and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@link Observer#onNext onNext} - * as many times as the number of {@code onNext} invocations of the source ObservableSource that emits the fewest + * The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} + * as many times as the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest * items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if @@ -4819,27 +4826,27 @@ public static Observable zip( * @param the value type of the ninth source * @param the zipped result type * @param source1 - * the first source ObservableSource + * the first source {@code ObservableSource} * @param source2 - * a second source ObservableSource + * a second source {@code ObservableSource} * @param source3 - * a third source ObservableSource + * a third source {@code ObservableSource} * @param source4 - * a fourth source ObservableSource + * a fourth source {@code ObservableSource} * @param source5 - * a fifth source ObservableSource + * a fifth source {@code ObservableSource} * @param source6 - * a sixth source ObservableSource + * a sixth source {@code ObservableSource} * @param source7 - * a seventh source ObservableSource + * a seventh source {@code ObservableSource} * @param source8 - * an eighth source ObservableSource + * an eighth source {@code ObservableSource} * @param source9 - * a ninth source ObservableSource + * a ninth source {@code ObservableSource} * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource - * @return an Observable that emits the zipped results + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4864,16 +4871,16 @@ public static Observable zip( } /** - * Returns an Observable that emits the results of a specified combiner function applied to combinations of - * items emitted, in sequence, by an array of other ObservableSources. + * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of + * items emitted, in sequence, by an array of other {@link ObservableSource}s. *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new ObservableSource - * will be the result of the function applied to the first item emitted by each of the source ObservableSources; - * the second item emitted by the new ObservableSource will be the result of the function applied to the second - * item emitted by each of those ObservableSources; and so forth. + * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * will be the result of the function applied to the first item emitted by each of the {@code ObservableSource}s; + * the second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second + * item emitted by each of those {@code ObservableSource}s; and so forth. *

- * The resulting {@code ObservableSource} returned from {@code zip} will invoke {@code onNext} as many times as - * the number of {@code onNext} invocations of the source ObservableSource that emits the fewest items. + * The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as + * the number of {@code onNext} invocations of the {@code ObservableSource} that emits the fewest items. *

* The operator subscribes to its sources in order they are specified and completes eagerly if * one of the sources is shorter than the rest while disposing the other sources. Therefore, it @@ -4890,7 +4897,7 @@ public static Observable zip( *

* Note on method signature: since Java doesn't allow creating a generic array with {@code new T[]}, the * implementation of this operator has to create an {@code Object[]} instead. Unfortunately, a - * {@code Function} passed to the method would trigger a {@code ClassCastException}. + * {@code Function} passed to the method would trigger a {@link ClassCastException}. * *

* @@ -4902,15 +4909,15 @@ public static Observable zip( * @param the common element type * @param the result type * @param sources - * an array of source ObservableSources + * an array of source {@code ObservableSource}s * @param zipper - * a function that, when applied to an item emitted by each of the source ObservableSources, results in - * an item that will be emitted by the resulting ObservableSource + * a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in + * an item that will be emitted by the resulting {@code Observable} * @param delayError - * delay errors signalled by any of the source ObservableSource until all ObservableSources terminate + * delay errors signaled by any of the {@code ObservableSource} until all {@code ObservableSource}s terminate * @param bufferSize - * the number of elements to prefetch from each source ObservableSource - * @return an Observable that emits the zipped results + * the number of elements to prefetch from each source {@code ObservableSource} + * @return an {@code Observable} that emits the zipped results * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -4934,8 +4941,8 @@ public static Observable zipArray( // *************************************************************************************************** /** - * Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source - * ObservableSource satisfy a condition. + * Returns a {@link Single} that emits a {@link Boolean} that indicates whether all of the items emitted by the current + * {@code Observable} satisfy a condition. *

* *

@@ -4944,8 +4951,8 @@ public static Observable zipArray( *
* * @param predicate - * a function that evaluates an item and returns a Boolean - * @return a Single that emits {@code true} if all items emitted by the source ObservableSource satisfy the + * a function that evaluates an item and returns a {@code Boolean} + * @return a {@code Single} that emits {@code true} if all items emitted by the current {@code Observable} satisfy the * predicate; otherwise, {@code false} * @see ReactiveX operators documentation: All */ @@ -4958,7 +4965,7 @@ public final Single all(@NonNull Predicate predicate) { } /** - * Mirrors the ObservableSource (current or provided) that first either emits an item or sends a termination + * Mirrors the current {@code Observable} or the other {@link ObservableSource} provided of which the first either emits an item or sends a termination * notification. *

* @@ -4968,9 +4975,9 @@ public final Single all(@NonNull Predicate predicate) { *

* * @param other - * an ObservableSource competing to react first. A subscription to this provided source will occur after + * an {@code ObservableSource} competing to react first. A subscription to this provided source will occur after * subscribing to the current source. - * @return an Observable that emits the same sequence as whichever of the source ObservableSources first + * @return an {@code Observable} that emits the same sequence as whichever of the current {@code Observable}s first * emitted an item or sent a termination notification * @see ReactiveX operators documentation: Amb */ @@ -4983,13 +4990,13 @@ public final Observable ambWith(@NonNull ObservableSource other) } /** - * Returns a Single that emits {@code true} if any item emitted by the source ObservableSource satisfies a + * Returns a {@link Single} that emits {@code true} if any item emitted by the current {@code Observable} satisfies a * specified condition, otherwise {@code false}. Note: this always emits {@code false} if the - * source ObservableSource is empty. + * current {@code Observable} is empty. *

* *

- * In Rx.Net this is the {@code any} Observer but we renamed it in RxJava to better match Java naming + * In Rx.Net this is the {@code any} {@link Observer} but we renamed it in RxJava to better match Java naming * idioms. *

*
Scheduler:
@@ -4997,9 +5004,9 @@ public final Observable ambWith(@NonNull ObservableSource other) *
* * @param predicate - * the condition to test items emitted by the source ObservableSource - * @return a Single that emits a Boolean that indicates whether any item emitted by the source - * ObservableSource satisfies the {@code predicate} + * the condition to test items emitted by the current {@code Observable} + * @return a {@code Single} that emits a {@link Boolean} that indicates whether any item emitted by the current + * {@code Observable} satisfies the {@code predicate} * @see ReactiveX operators documentation: Contains */ @CheckReturnValue @@ -5012,7 +5019,7 @@ public final Single any(@NonNull Predicate predicate) { /** * Returns the first item emitted by this {@code Observable}, or throws - * {@code NoSuchElementException} if it emits no items. + * {@link NoSuchElementException} if it emits no items. *

* *

@@ -5065,8 +5072,8 @@ public final T blockingFirst(@NonNull T defaultItem) { } /** - * Consumes the upstream {@code Observable} in a blocking fashion and invokes the given - * {@code Consumer} with each upstream item on the current thread until the + * Consumes the current {@code Observable} in a blocking fashion and invokes the given + * {@link Consumer} with each upstream item on the current thread until the * upstream terminates. *

* @@ -5087,7 +5094,7 @@ public final T blockingFirst(@NonNull T defaultItem) { *

* * @param onNext - * the {@link Consumer} to invoke for each item emitted by the {@code Observable} + * the {@code Consumer} to invoke for each item emitted by the {@code Observable} * @throws RuntimeException * if an error occurs * @see ReactiveX documentation: Subscribe @@ -5101,8 +5108,8 @@ public final void blockingForEach(@NonNull Consumer onNext) { } /** - * Consumes the upstream {@code Observable} in a blocking fashion and invokes the given - * {@code Consumer} with each upstream item on the current thread until the + * Consumes the current {@code Observable} in a blocking fashion and invokes the given + * {@link Consumer} with each upstream item on the current thread until the * upstream terminates. *

* @@ -5123,12 +5130,12 @@ public final void blockingForEach(@NonNull Consumer onNext) { *

* * @param onNext - * the {@link Consumer} to invoke for each item emitted by the {@code Observable} + * the {@code Consumer} to invoke for each item emitted by the {@code Observable} * @param capacityHint * the number of items expected to be buffered (allows reducing buffer reallocations) * @throws RuntimeException - * if an error occurs; {@link Error}s and {@link RuntimeException}s are rethrown - * as they are, checked {@link Exception}s are wrapped into {@code RuntimeException}s + * if an error occurs; {@code Error}s and {@code RuntimeException}s are rethrown + * as they are, checked {@code Exception}s are wrapped into {@code RuntimeException}s * @see ReactiveX documentation: Subscribe * @see #subscribe(Consumer) */ @@ -5156,7 +5163,7 @@ public final void blockingForEach(@NonNull Consumer onNext, int capac *
{@code blockingIterable} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an {@link Iterable} version of this {@code Observable} + * @return an {@code Iterable} version of this {@code Observable} * @see ReactiveX documentation: To */ @CheckReturnValue @@ -5176,7 +5183,7 @@ public final Iterable blockingIterable() { *
* * @param capacityHint the expected number of items to be buffered - * @return an {@link Iterable} version of this {@code Observable} + * @return an {@code Iterable} version of this {@code Observable} * @see ReactiveX documentation: To */ @CheckReturnValue @@ -5189,7 +5196,7 @@ public final Iterable blockingIterable(int capacityHint) { /** * Returns the last item emitted by this {@code Observable}, or throws - * {@code NoSuchElementException} if this {@code Observable} emits no items. + * {@link NoSuchElementException} if this {@code Observable} emits no items. *

* *

@@ -5265,7 +5272,7 @@ public final T blockingLast(@NonNull T defaultItem) { *
{@code blockingLatest} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an Iterable that always returns the latest item emitted by this {@code Observable} + * @return an {@code Iterable} that always returns the latest item emitted by this {@code Observable} * @see ReactiveX documentation: First */ @CheckReturnValue @@ -5286,9 +5293,9 @@ public final Iterable blockingLatest() { *
* * @param initialValue - * the initial value that the {@link Iterable} sequence will yield if this + * the initial value that the {@code Iterable} sequence will yield if this * {@code Observable} has not yet emitted an item - * @return an {@link Iterable} that on each iteration returns the item that this {@code Observable} + * @return an {@code Iterable} that on each iteration returns the item that this {@code Observable} * has most recently emitted * @see ReactiveX documentation: First */ @@ -5309,8 +5316,8 @@ public final Iterable blockingMostRecent(@NonNull T initialValue) { *
{@code blockingNext} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an {@link Iterable} that blocks upon each iteration until this {@code Observable} emits - * a new item, whereupon the Iterable returns that item + * @return an {@code Iterable} that blocks upon each iteration until this {@code Observable} emits + * a new item, whereupon the {@code Iterable} returns that item * @see ReactiveX documentation: TakeLast */ @CheckReturnValue @@ -5322,7 +5329,7 @@ public final Iterable blockingNext() { /** * If this {@code Observable} completes after emitting a single item, return that item, otherwise - * throw a {@code NoSuchElementException}. + * throw a {@link NoSuchElementException}. *

* *

@@ -5350,7 +5357,7 @@ public final T blockingSingle() { /** * If this {@code Observable} completes after emitting a single item, return that item; if it emits - * more than one item, throw an {@code IllegalArgumentException}; if it emits no items, return a default + * more than one item, throw an {@link IllegalArgumentException}; if it emits no items, return a default * value. *

* @@ -5392,7 +5399,7 @@ public final T blockingSingle(@NonNull T defaultItem) { *

{@code toFuture} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a {@link Future} that expects a single item to be emitted by this {@code Observable} + * @return a {@code Future} that expects a single item to be emitted by this {@code Observable} * @see ReactiveX documentation: To */ @CheckReturnValue @@ -5403,7 +5410,7 @@ public final Future toFuture() { } /** - * Runs the source observable to a terminal event, ignoring any values and rethrowing any exception. + * Runs the current {@code Observable} to a terminal event, ignoring any values and rethrowing any exception. *

* *

@@ -5431,7 +5438,7 @@ public final void blockingSubscribe() { *

* If the {@code Observable} emits an error, it is wrapped into an * {@link io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException} - * and routed to the RxJavaPlugins.onError handler. + * and routed to the {@link RxJavaPlugins#onError(Throwable)} handler. * Using the overloads {@link #blockingSubscribe(Consumer, Consumer)} * or {@link #blockingSubscribe(Consumer, Consumer, Action)} instead is recommended. *

@@ -5518,10 +5525,10 @@ public final void blockingSubscribe(@NonNull Observer observer) { } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping buffers, each containing {@code count} items. When the source - * ObservableSource completes, the resulting ObservableSource emits the current buffer and propagates the notification - * from the source ObservableSource. Note that if the source ObservableSource issues an onError notification + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping buffers, each containing {@code count} items. When the current + * {@code Observable} completes, the resulting {@code Observable} emits the current buffer and propagates the notification + * from the current {@code Observable}. Note that if the current {@code Observable} issues an {@code onError} notification * the event is passed on immediately without first emitting the buffer it is in the process of assembling. *

* @@ -5532,8 +5539,8 @@ public final void blockingSubscribe(@NonNull Observer observer) { * * @param count * the maximum number of items in each buffer before it should be emitted - * @return an Observable that emits connected, non-overlapping buffers, each containing at most - * {@code count} items from the source ObservableSource + * @return an {@code Observable} that emits connected, non-overlapping buffers, each containing at most + * {@code count} items from the current {@code Observable} * @see ReactiveX operators documentation: Buffer */ @CheckReturnValue @@ -5544,10 +5551,10 @@ public final void blockingSubscribe(@NonNull Observer observer) { } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits buffers every {@code skip} items, each containing {@code count} items. When the source - * ObservableSource completes, the resulting ObservableSource emits the current buffer and propagates the notification - * from the source ObservableSource. Note that if the source ObservableSource issues an onError notification + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits buffers every {@code skip} items, each containing {@code count} items. When the current + * {@code Observable} completes, the resulting {@code Observable} emits the current buffer and propagates the notification + * from the current {@code Observable}. Note that if the current {@code Observable} issues an {@code onError} notification * the event is passed on immediately without first emitting the buffer it is in the process of assembling. *

* @@ -5559,10 +5566,10 @@ public final void blockingSubscribe(@NonNull Observer observer) { * @param count * the maximum size of each buffer before it should be emitted * @param skip - * how many items emitted by the source ObservableSource should be skipped before starting a new + * how many items emitted by the current {@code Observable} should be skipped before starting a new * buffer. Note that when {@code skip} and {@code count} are equal, this is the same operation as * {@link #buffer(int)}. - * @return an Observable that emits buffers for every {@code skip} item from the source ObservableSource and + * @return an {@code Observable} that emits buffers for every {@code skip} item from the current {@code Observable} and * containing at most {@code count} items * @see ReactiveX operators documentation: Buffer */ @@ -5574,10 +5581,10 @@ public final void blockingSubscribe(@NonNull Observer observer) { } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits buffers every {@code skip} items, each containing {@code count} items. When the source - * ObservableSource completes, the resulting ObservableSource emits the current buffer and propagates the notification - * from the source ObservableSource. Note that if the source ObservableSource issues an onError notification + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits buffers every {@code skip} items, each containing {@code count} items. When the current + * {@code Observable} completes, the resulting {@code Observable} emits the current buffer and propagates the notification + * from the current {@code Observable}. Note that if the current {@code Observable} issues an {@code onError} notification * the event is passed on immediately without first emitting the buffer it is in the process of assembling. *

* @@ -5590,13 +5597,13 @@ public final void blockingSubscribe(@NonNull Observer observer) { * @param count * the maximum size of each buffer before it should be emitted * @param skip - * how many items emitted by the source ObservableSource should be skipped before starting a new + * how many items emitted by the current {@code Observable} should be skipped before starting a new * buffer. Note that when {@code skip} and {@code count} are equal, this is the same operation as * {@link #buffer(int)}. * @param bufferSupplier * a factory function that returns an instance of the collection subclass to be used and returned * as the buffer - * @return an Observable that emits buffers for every {@code skip} item from the source ObservableSource and + * @return an {@code Observable} that emits buffers for every {@code skip} item from the current {@code Observable} and * containing at most {@code count} items * @see ReactiveX operators documentation: Buffer */ @@ -5611,10 +5618,10 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping buffers, each containing {@code count} items. When the source - * ObservableSource completes, the resulting ObservableSource emits the current buffer and propagates the notification - * from the source ObservableSource. Note that if the source ObservableSource issues an onError notification + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping buffers, each containing {@code count} items. When the current + * {@code Observable} completes, the resulting {@code Observable} emits the current buffer and propagates the notification + * from the current {@code Observable}. Note that if the current {@code Observable} issues an {@code onError} notification * the event is passed on immediately without first emitting the buffer it is in the process of assembling. *

* @@ -5629,8 +5636,8 @@ public final > Observable buffer(int count, i * @param bufferSupplier * a factory function that returns an instance of the collection subclass to be used and returned * as the buffer - * @return an Observable that emits connected, non-overlapping buffers, each containing at most - * {@code count} items from the source ObservableSource + * @return an {@code Observable} that emits connected, non-overlapping buffers, each containing at most + * {@code count} items from the current {@code Observable} * @see ReactiveX operators documentation: Buffer */ @CheckReturnValue @@ -5641,11 +5648,11 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource starts a new buffer periodically, as determined by the {@code timeskip} argument. It emits - * each buffer after a fixed timespan, specified by the {@code timespan} argument. When the source - * ObservableSource completes, the resulting ObservableSource emits the current buffer and propagates the notification - * from the source ObservableSource. Note that if the source ObservableSource issues an onError notification + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} starts a new buffer periodically, as determined by the {@code timeskip} argument. It emits + * each buffer after a fixed timespan, specified by the {@code timespan} argument. When the current + * {@code Observable} completes, the resulting {@code Observable} emits the current buffer and propagates the notification + * from the current {@code Observable}. Note that if the current {@code Observable} issues an {@code onError} notification * the event is passed on immediately without first emitting the buffer it is in the process of assembling. *

* @@ -5660,7 +5667,7 @@ public final > Observable buffer(int count, i * the period of time after which a new buffer will be created * @param unit * the unit of time that applies to the {@code timespan} and {@code timeskip} arguments - * @return an Observable that emits new buffers of items emitted by the source ObservableSource periodically after + * @return an {@code Observable} that emits new buffers of items emitted by the current {@code Observable} periodically after * a fixed timespan has elapsed * @see ReactiveX operators documentation: Buffer */ @@ -5672,12 +5679,12 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource starts a new buffer periodically, as determined by the {@code timeskip} argument, and on the + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} starts a new buffer periodically, as determined by the {@code timeskip} argument, and on the * specified {@code scheduler}. It emits each buffer after a fixed timespan, specified by the - * {@code timespan} argument. When the source ObservableSource completes, the resulting ObservableSource emits the - * current buffer and propagates the notification from the source ObservableSource. Note that if the source - * ObservableSource issues an onError notification the event is passed on immediately without first emitting the + * {@code timespan} argument. When the current {@code Observable} completes, the resulting {@code Observable} emits the + * current buffer and propagates the notification from the current {@code Observable}. Note that if the current + * {@code Observable} issues an {@code onError} notification the event is passed on immediately without first emitting the * buffer it is in the process of assembling. *

* @@ -5693,8 +5700,8 @@ public final > Observable buffer(int count, i * @param unit * the unit of time that applies to the {@code timespan} and {@code timeskip} arguments * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a buffer - * @return an Observable that emits new buffers of items emitted by the source ObservableSource periodically after + * the {@code Scheduler} to use when determining the end and start of a buffer + * @return an {@code Observable} that emits new buffers of items emitted by the current {@code Observable} periodically after * a fixed timespan has elapsed * @see ReactiveX operators documentation: Buffer */ @@ -5706,12 +5713,12 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource starts a new buffer periodically, as determined by the {@code timeskip} argument, and on the + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} starts a new buffer periodically, as determined by the {@code timeskip} argument, and on the * specified {@code scheduler}. It emits each buffer after a fixed timespan, specified by the - * {@code timespan} argument. When the source ObservableSource completes, the resulting ObservableSource emits the - * current buffer and propagates the notification from the source ObservableSource. Note that if the source - * ObservableSource issues an onError notification the event is passed on immediately without first emitting the + * {@code timespan} argument. When the current {@code Observable} completes, the resulting {@code Observable} emits the + * current buffer and propagates the notification from the current {@code Observable}. Note that if the current + * {@code Observable} issues an {@code onError} notification the event is passed on immediately without first emitting the * buffer it is in the process of assembling. *

* @@ -5728,11 +5735,11 @@ public final > Observable buffer(int count, i * @param unit * the unit of time that applies to the {@code timespan} and {@code timeskip} arguments * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a buffer + * the {@code Scheduler} to use when determining the end and start of a buffer * @param bufferSupplier * a factory function that returns an instance of the collection subclass to be used and returned * as the buffer - * @return an Observable that emits new buffers of items emitted by the source ObservableSource periodically after + * @return an {@code Observable} that emits new buffers of items emitted by the current {@code Observable} periodically after * a fixed timespan has elapsed * @see ReactiveX operators documentation: Buffer */ @@ -5747,11 +5754,11 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping buffers, each of a fixed duration specified by the - * {@code timespan} argument. When the source ObservableSource completes, the resulting ObservableSource emits the - * current buffer and propagates the notification from the source ObservableSource. Note that if the source - * ObservableSource issues an onError notification the event is passed on immediately without first emitting the + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping buffers, each of a fixed duration specified by the + * {@code timespan} argument. When the current {@code Observable} completes, the resulting {@code Observable} emits the + * current buffer and propagates the notification from the current {@code Observable}. Note that if the current + * {@code Observable} issues an {@code onError} notification the event is passed on immediately without first emitting the * buffer it is in the process of assembling. *

* @@ -5765,8 +5772,8 @@ public final > Observable buffer(int count, i * buffer * @param unit * the unit of time that applies to the {@code timespan} argument - * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source - * ObservableSource within a fixed duration + * @return an {@code Observable} that emits connected, non-overlapping buffers of items emitted by the current + * {@code Observable} within a fixed duration * @see ReactiveX operators documentation: Buffer */ @CheckReturnValue @@ -5777,12 +5784,12 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping buffers, each of a fixed duration specified by the + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping buffers, each of a fixed duration specified by the * {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached - * first). When the source ObservableSource completes, the resulting ObservableSource emits the current buffer and - * propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an - * onError notification the event is passed on immediately without first emitting the buffer it is in the process of + * first). When the current {@code Observable} completes, the resulting {@code Observable} emits the current buffer and + * propagates the notification from the current {@code Observable}. Note that if the current {@code Observable} issues an + * {@code onError} notification the event is passed on immediately without first emitting the buffer it is in the process of * assembling. *

* @@ -5798,8 +5805,8 @@ public final > Observable buffer(int count, i * the unit of time which applies to the {@code timespan} argument * @param count * the maximum size of each buffer before it is emitted - * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source - * ObservableSource, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs + * @return an {@code Observable} that emits connected, non-overlapping buffers of items emitted by the current + * {@code Observable}, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs * first) * @see ReactiveX operators documentation: Buffer */ @@ -5811,12 +5818,12 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping buffers, each of a fixed duration specified by the + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping buffers, each of a fixed duration specified by the * {@code timespan} argument as measured on the specified {@code scheduler}, or a maximum size specified by - * the {@code count} argument (whichever is reached first). When the source ObservableSource completes, the resulting - * ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note - * that if the source ObservableSource issues an onError notification the event is passed on immediately without + * the {@code count} argument (whichever is reached first). When the current {@code Observable} completes, the resulting + * {@code Observable} emits the current buffer and propagates the notification from the current {@code Observable}. Note + * that if the current {@code Observable} issues an {@code onError} notification the event is passed on immediately without * first emitting the buffer it is in the process of assembling. *

* @@ -5831,11 +5838,11 @@ public final > Observable buffer(int count, i * @param unit * the unit of time which applies to the {@code timespan} argument * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a buffer + * the {@code Scheduler} to use when determining the end and start of a buffer * @param count * the maximum size of each buffer before it is emitted - * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source - * ObservableSource after a fixed duration or when the buffer reaches maximum capacity (whichever occurs + * @return an {@code Observable} that emits connected, non-overlapping buffers of items emitted by the current + * {@code Observable} after a fixed duration or when the buffer reaches maximum capacity (whichever occurs * first) * @see ReactiveX operators documentation: Buffer */ @@ -5847,12 +5854,12 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping buffers, each of a fixed duration specified by the + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping buffers, each of a fixed duration specified by the * {@code timespan} argument as measured on the specified {@code scheduler}, or a maximum size specified by - * the {@code count} argument (whichever is reached first). When the source ObservableSource completes, the resulting - * ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note - * that if the source ObservableSource issues an onError notification the event is passed on immediately without + * the {@code count} argument (whichever is reached first). When the current {@code Observable} completes, the resulting + * {@code Observable} emits the current buffer and propagates the notification from the current {@code Observable}. Note + * that if the current {@code Observable} issues an {@code onError} notification the event is passed on immediately without * first emitting the buffer it is in the process of assembling. *

* @@ -5868,16 +5875,16 @@ public final > Observable buffer(int count, i * @param unit * the unit of time which applies to the {@code timespan} argument * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a buffer + * the {@code Scheduler} to use when determining the end and start of a buffer * @param count * the maximum size of each buffer before it is emitted * @param bufferSupplier * a factory function that returns an instance of the collection subclass to be used and returned * as the buffer - * @param restartTimerOnMaxSize if true the time window is restarted when the max capacity of the current buffer + * @param restartTimerOnMaxSize if {@code true} the time window is restarted when the max capacity of the current buffer * is reached - * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source - * ObservableSource after a fixed duration or when the buffer reaches maximum capacity (whichever occurs + * @return an {@code Observable} that emits connected, non-overlapping buffers of items emitted by the current + * {@code Observable} after a fixed duration or when the buffer reaches maximum capacity (whichever occurs * first) * @see ReactiveX operators documentation: Buffer */ @@ -5897,11 +5904,11 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping buffers, each of a fixed duration specified by the - * {@code timespan} argument and on the specified {@code scheduler}. When the source ObservableSource completes, - * the resulting ObservableSource emits the current buffer and propagates the notification from the source - * ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping buffers, each of a fixed duration specified by the + * {@code timespan} argument and on the specified {@code scheduler}. When the current {@code Observable} completes, + * the resulting {@code Observable} emits the current buffer and propagates the notification from the current + * {@code Observable}. Note that if the current {@code Observable} issues an {@code onError} notification the event is passed on * immediately without first emitting the buffer it is in the process of assembling. *

* @@ -5916,9 +5923,9 @@ public final > Observable buffer(int count, i * @param unit * the unit of time which applies to the {@code timespan} argument * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a buffer - * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source - * ObservableSource within a fixed duration + * the {@code Scheduler} to use when determining the end and start of a buffer + * @return an {@code Observable} that emits connected, non-overlapping buffers of items emitted by the current + * {@code Observable} within a fixed duration * @see ReactiveX operators documentation: Buffer */ @CheckReturnValue @@ -5929,10 +5936,10 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits buffers that it creates when the specified {@code openingIndicator} ObservableSource emits an - * item, and closes when the ObservableSource returned from {@code closingIndicator} emits an item. If any of the - * source ObservableSource, {@code openingIndicator} or {@code closingIndicator} issues an onError notification the + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits buffers that it creates when the specified {@code openingIndicator} {@link ObservableSource} emits an + * item, and closes when the {@code ObservableSource} returned from {@code closingIndicator} emits an item. If any of the + * current {@code Observable}, {@code openingIndicator} or {@code closingIndicator} issues an {@code onError} notification the * event is passed on immediately without first emitting the buffer it is in the process of assembling. *

* @@ -5941,15 +5948,15 @@ public final > Observable buffer(int count, i *

This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the element type of the buffer-opening ObservableSource - * @param the element type of the individual buffer-closing ObservableSources + * @param the element type of the buffer-opening {@code ObservableSource} + * @param the element type of the individual buffer-closing {@code ObservableSource}s * @param openingIndicator - * the ObservableSource that, when it emits an item, causes a new buffer to be created + * the {@code ObservableSource} that, when it emits an item, causes a new buffer to be created * @param closingIndicator - * the {@link Function} that is used to produce an ObservableSource for every buffer created. When this - * ObservableSource emits an item, the associated buffer is emitted. - * @return an Observable that emits buffers, containing items from the source ObservableSource, that are created - * and closed when the specified ObservableSources emit items + * the {@link Function} that is used to produce an {@code ObservableSource} for every buffer created. When this + * {@code ObservableSource} emits an item, the associated buffer is emitted. + * @return an {@code Observable} that emits buffers, containing items from the current {@code Observable}, that are created + * and closed when the specified {@code ObservableSource}s emit items * @see ReactiveX operators documentation: Buffer */ @CheckReturnValue @@ -5962,10 +5969,10 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting - * ObservableSource emits buffers that it creates when the specified {@code openingIndicator} ObservableSource emits an - * item, and closes when the ObservableSource returned from {@code closingIndicator} emits an item. If any of the - * source ObservableSource, {@code openingIndicator} or {@code closingIndicator} issues an onError notification the + * Returns an {@code Observable} that emits buffers of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits buffers that it creates when the specified {@code openingIndicator} {@link ObservableSource} emits an + * item, and closes when the {@code ObservableSource} returned from {@code closingIndicator} emits an item. If any of the + * current {@code Observable}, {@code openingIndicator} or {@code closingIndicator} issues an {@code onError} notification the * event is passed on immediately without first emitting the buffer it is in the process of assembling. *

* @@ -5975,18 +5982,18 @@ public final > Observable buffer(int count, i *

* * @param the collection subclass type to buffer into - * @param the element type of the buffer-opening ObservableSource - * @param the element type of the individual buffer-closing ObservableSources + * @param the element type of the buffer-opening {@code ObservableSource} + * @param the element type of the individual buffer-closing {@code ObservableSource}s * @param openingIndicator - * the ObservableSource that, when it emits an item, causes a new buffer to be created + * the {@code ObservableSource} that, when it emits an item, causes a new buffer to be created * @param closingIndicator - * the {@link Function} that is used to produce an ObservableSource for every buffer created. When this - * ObservableSource emits an item, the associated buffer is emitted. + * the {@link Function} that is used to produce an {@code ObservableSource} for every buffer created. When this + * {@code ObservableSource} emits an item, the associated buffer is emitted. * @param bufferSupplier * a factory function that returns an instance of the collection subclass to be used and returned * as the buffer - * @return an Observable that emits buffers, containing items from the source ObservableSource, that are created - * and closed when the specified ObservableSources emit items + * @return an {@code Observable} that emits buffers, containing items from the current {@code Observable}, that are created + * and closed when the specified {@code ObservableSource}s emit items * @see ReactiveX operators documentation: Buffer */ @CheckReturnValue @@ -6003,14 +6010,14 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the - * specified boundary ObservableSource emits an item. + * Returns an {@code Observable} that emits non-overlapping buffered items from the current {@code Observable} each time the + * specified boundary {@link ObservableSource} emits an item. *

* *

- * Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the - * latest buffer and complete. If either the source ObservableSource or the boundary ObservableSource issues an - * onError notification the event is passed on immediately without first emitting the buffer it is in the process of + * Completion of either the source or the boundary {@code ObservableSource} causes the returned {@code ObservableSource} to emit the + * latest buffer and complete. If either the current {@code Observable} or the boundary {@code ObservableSource} issues an + * {@code onError} notification the event is passed on immediately without first emitting the buffer it is in the process of * assembling. *

*
Scheduler:
@@ -6020,8 +6027,8 @@ public final > Observable buffer(int count, i * @param * the boundary value type (ignored) * @param boundary - * the boundary ObservableSource - * @return an Observable that emits buffered items from the source ObservableSource when the boundary ObservableSource + * the boundary {@code ObservableSource} + * @return an {@code Observable} that emits buffered items from the current {@code Observable} when the boundary {@code ObservableSource} * emits an item * @see #buffer(ObservableSource, int) * @see ReactiveX operators documentation: Buffer @@ -6034,14 +6041,14 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the - * specified boundary ObservableSource emits an item. + * Returns an {@code Observable} that emits non-overlapping buffered items from the current {@code Observable} each time the + * specified boundary {@link ObservableSource} emits an item. *

* *

- * Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the - * latest buffer and complete. If either the source ObservableSource or the boundary ObservableSource issues an - * onError notification the event is passed on immediately without first emitting the buffer it is in the process of + * Completion of either the source or the boundary {@code ObservableSource} causes the returned {@code ObservableSource} to emit the + * latest buffer and complete. If either the current {@code Observable} or the boundary {@code ObservableSource} issues an + * {@code onError} notification the event is passed on immediately without first emitting the buffer it is in the process of * assembling. *

*
Scheduler:
@@ -6051,10 +6058,10 @@ public final > Observable buffer(int count, i * @param * the boundary value type (ignored) * @param boundary - * the boundary ObservableSource + * the boundary {@code ObservableSource} * @param initialCapacity * the initial capacity of each buffer chunk - * @return an Observable that emits buffered items from the source ObservableSource when the boundary ObservableSource + * @return an {@code Observable} that emits buffered items from the current {@code Observable} when the boundary {@code ObservableSource} * emits an item * @see ReactiveX operators documentation: Buffer * @see #buffer(ObservableSource) @@ -6068,14 +6075,14 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the - * specified boundary ObservableSource emits an item. + * Returns an {@code Observable} that emits non-overlapping buffered items from the current {@code Observable} each time the + * specified boundary {@link ObservableSource} emits an item. *

* *

- * Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the - * latest buffer and complete. If either the source ObservableSource or the boundary ObservableSource issues an - * onError notification the event is passed on immediately without first emitting the buffer it is in the process of + * Completion of either the source or the boundary {@code ObservableSource} causes the returned {@code ObservableSource} to emit the + * latest buffer and complete. If either the current {@code Observable} or the boundary {@code ObservableSource} issues an + * {@code onError} notification the event is passed on immediately without first emitting the buffer it is in the process of * assembling. *

*
Scheduler:
@@ -6086,11 +6093,11 @@ public final > Observable buffer(int count, i * @param * the boundary value type (ignored) * @param boundary - * the boundary ObservableSource + * the boundary {@code ObservableSource} * @param bufferSupplier * a factory function that returns an instance of the collection subclass to be used and returned * as the buffer - * @return an Observable that emits buffered items from the source ObservableSource when the boundary ObservableSource + * @return an {@code Observable} that emits buffered items from the current {@code Observable} when the boundary {@code ObservableSource} * emits an item * @see #buffer(ObservableSource, int) * @see ReactiveX operators documentation: Buffer @@ -6105,23 +6112,23 @@ public final > Observable buffer(int count, i } /** - * Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events - * and replays them, in the same order as received, to all the downstream subscribers. + * Returns an {@code Observable} that subscribes to this {@code Observable} lazily, caches all of its events + * and replays them, in the same order as received, to all the downstream observers. *

* *

- * This is useful when you want an ObservableSource to cache responses and you can't control the + * This is useful when you want an {@code Observable} to cache responses and you can't control the * subscribe/dispose behavior of all the {@link Observer}s. *

- * The operator subscribes only when the first downstream subscriber subscribes and maintains - * a single subscription towards this ObservableSource. In contrast, the operator family of {@link #replay()} + * The operator subscribes only when the first downstream observer subscribes and maintains + * a single subscription towards this {@code Observable}. In contrast, the operator family of {@link #replay()} * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}. *

* Note: You sacrifice the ability to dispose the origin when you use the {@code cache} - * Observer so be careful not to use this Observer on ObservableSources that emit an infinite or very large number + * operator so be careful not to use this operator on {@code Observable}s that emit an infinite or very large number * of items that will use up memory. - * A possible workaround is to apply `takeUntil` with a predicate or - * another source before (and perhaps after) the application of cache(). + * A possible workaround is to apply {@code takeUntil} with a predicate or + * another source before (and perhaps after) the application of {@code cache()}. * 


      * AtomicBoolean shouldStop = new AtomicBoolean();
      *
@@ -6148,9 +6155,11 @@ public final > Observable buffer(int count, i
      *  
{@code cache} does not operate by default on a particular {@link Scheduler}.

      *
* - * @return an Observable that, when first subscribed to, caches all of its items and notifications for the + * @return an {@code Observable} that, when first subscribed to, caches all of its items and notifications for the * benefit of subsequent subscribers * @see ReactiveX operators documentation: Replay + * @see #takeUntil(Predicate) + * @see #takeUntil(ObservableSource) */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -6160,23 +6169,23 @@ public final Observable cache() { } /** - * Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events - * and replays them, in the same order as received, to all the downstream subscribers. + * Returns an {@code Observable} that subscribes to this {@code Observable} lazily, caches all of its events + * and replays them, in the same order as received, to all the downstream observers. *

* *

- * This is useful when you want an ObservableSource to cache responses and you can't control the + * This is useful when you want an {@code Observable} to cache responses and you can't control the * subscribe/dispose behavior of all the {@link Observer}s. *

- * The operator subscribes only when the first downstream subscriber subscribes and maintains - * a single subscription towards this ObservableSource. In contrast, the operator family of {@link #replay()} + * The operator subscribes only when the first downstream observer subscribes and maintains + * a single subscription towards this {@code Observable}. In contrast, the operator family of {@link #replay()} * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}. *

* Note: You sacrifice the ability to dispose the origin when you use the {@code cache} - * Observer so be careful not to use this Observer on ObservableSources that emit an infinite or very large number + * operator so be careful not to use this operator on {@code Observable}s that emit an infinite or very large number * of items that will use up memory. * A possible workaround is to apply `takeUntil` with a predicate or - * another source before (and perhaps after) the application of cache(). + * another source before (and perhaps after) the application of {@code cache()}. * 


      * AtomicBoolean shouldStop = new AtomicBoolean();
      *
@@ -6207,9 +6216,11 @@ public final Observable cache() {
      * {@link #replay(int)} in combination with {@link ConnectableObservable#autoConnect()} or similar.
      *
      * @param initialCapacity hint for number of items to cache (for optimizing underlying data structure)
-     * @return an Observable that, when first subscribed to, caches all of its items and notifications for the
+     * @return an {@code Observable} that, when first subscribed to, caches all of its items and notifications for the
      *         benefit of subsequent subscribers
      * @see ReactiveX operators documentation: Replay
+     * @see #takeUntil(Predicate)
+     * @see #takeUntil(ObservableSource)
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
@@ -6220,7 +6231,7 @@ public final Observable cacheWithInitialCapacity(int initialCapacity) {
     }
 
     /**
-     * Returns an Observable that emits the items emitted by the source ObservableSource, converted to the specified
+     * Returns an {@code Observable} that emits the items emitted by the current {@code Observable}, converted to the specified
      * type.
      * 

      * 
@@ -6231,9 +6242,9 @@ public final Observable cacheWithInitialCapacity(int initialCapacity) {
      *
      * @param  the output value type cast to
      * @param clazz
-     *            the target class type that {@code cast} will cast the items emitted by the source ObservableSource
-     *            into before emitting them from the resulting ObservableSource
-     * @return an Observable that emits each item from the source ObservableSource after converting it to the
+     *            the target class type that {@code cast} will cast the items emitted by the current {@code Observable}
+     *            into before emitting them from the resulting {@code Observable}
+     * @return an {@code Observable} that emits each item from the current {@code Observable} after converting it to the
      *         specified type
      * @see ReactiveX operators documentation: Map
      */
@@ -6246,8 +6257,8 @@ public final  Observable cast(@NonNull Class clazz) {
     }
 
     /**
-     * Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns
-     * a Single that emits this structure.
+     * Collects items emitted by the finite source {@code Observable} into a single mutable data structure and returns
+     * a {@link Single} that emits this structure.
      * 

      * 
      * 

@@ -6255,7 +6266,7 @@ public final  Observable cast(@NonNull Class clazz) {
      * 

      * Note that this operator requires the upstream to signal {@code onComplete} for the accumulator object to
      * be emitted. Sources that are infinite and never complete will never emit anything through this
-     * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}.
+     * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}.
      * 

      *  
Scheduler:

      *  
{@code collect} does not operate by default on a particular {@link Scheduler}.

@@ -6267,7 +6278,7 @@ public final  Observable cast(@NonNull Class clazz) {
      * @param collector
      *           a function that accepts the {@code state} and an emitted item, and modifies {@code state}
      *           accordingly
-     * @return a Single that emits the result of collecting the values emitted by the source ObservableSource
+     * @return a {@code Single} that emits the result of collecting the values emitted by the current {@code Observable}
      *         into a single mutable data structure
      * @see ReactiveX operators documentation: Reduce
      */
@@ -6281,8 +6292,8 @@ public final  Single collect(@NonNull Supplier initialValueSu
     }
 
     /**
-     * Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns
-     * a Single that emits this structure.
+     * Collects items emitted by the finite source {@code Observable} into a single mutable data structure and returns
+     * a {@link Single} that emits this structure.
      * 

      * 
      * 

@@ -6290,7 +6301,7 @@ public final  Single collect(@NonNull Supplier initialValueSu
      * 

      * Note that this operator requires the upstream to signal {@code onComplete} for the accumulator object to
      * be emitted. Sources that are infinite and never complete will never emit anything through this
-     * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}.
+     * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}.
      * 

      *  
Scheduler:

      *  
{@code collectInto} does not operate by default on a particular {@link Scheduler}.

@@ -6302,7 +6313,7 @@ public final  Single collect(@NonNull Supplier initialValueSu
      * @param collector
      *           a function that accepts the {@code state} and an emitted item, and modifies {@code state}
      *           accordingly
-     * @return a Single that emits the result of collecting the values emitted by the source ObservableSource
+     * @return a {@code Single} that emits the result of collecting the values emitted by the current {@code Observable}
      *         into a single mutable data structure
      * @see ReactiveX operators documentation: Reduce
      */
@@ -6315,22 +6326,22 @@ public final  Single collectInto(@NonNull U initialValue, @NonNull BiConsu
     }
 
     /**
-     * Transform an ObservableSource by applying a particular Transformer function to it.
+     * Transform this {@code Observable} by applying a particular {@link ObservableTransformer} function to it.
      * 

-     * This method operates on the ObservableSource itself whereas {@link #lift} operates on the ObservableSource's
-     * Observers.
+     * This method operates on the {@code Observable} itself whereas {@link #lift} operates on the {@link ObservableSource}'s
+     * {@link Observer}s.
      * 

-     * If the operator you are creating is designed to act on the individual items emitted by a source
-     * ObservableSource, use {@link #lift}. If your operator is designed to transform the source ObservableSource as a whole
+     * If the operator you are creating is designed to act on the individual items emitted by the current
+     * {@code Observable}, use {@link #lift}. If your operator is designed to transform the current {@code Observable} as a whole
      * (for instance, by applying a particular set of existing RxJava operators to it) use {@code compose}.
      * 

      *  
Scheduler:

      *  
{@code compose} does not operate by default on a particular {@link Scheduler}.

      * 

      *
-     * @param  the value type of the output ObservableSource
-     * @param composer implements the function that transforms the source ObservableSource
-     * @return the source ObservableSource, transformed by the transformer function
+     * @param  the value type of the output {@code ObservableSource}
+     * @param composer implements the function that transforms the current {@code Observable}
+     * @return the current {@code Observable}, transformed by the transformer function
      * @see RxJava wiki: Implementing Your Own Operators
      */
     @SuppressWarnings("unchecked")
@@ -6342,9 +6353,9 @@ public final  Observable compose(@NonNull ObservableTransformer
      * 
      * 

@@ -6356,12 +6367,12 @@ public final  Observable compose(@NonNull ObservableTransformer{@code concatMap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the type of the inner ObservableSource sources and thus the output type + * @param the type of the inner {@code ObservableSource} sources and thus the output type * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource - * @return an Observable that emits the result of applying the transformation function to each item emitted - * by the source ObservableSource and concatenating the ObservableSources obtained from this transformation + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} + * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted + * by the current {@code Observable} and concatenating the {@code ObservableSource}s obtained from this transformation * @see ReactiveX operators documentation: FlatMap * @see #concatMap(Function, int, Scheduler) */ @@ -6373,9 +6384,9 @@ public final Observable concatMap(@NonNull Function * *

@@ -6387,14 +6398,14 @@ public final Observable concatMap(@NonNull Function{@code concatMap} does not operate by default on a particular {@link Scheduler}.

*
* - * @param the type of the inner ObservableSource sources and thus the output type + * @param the type of the inner {@code ObservableSource} sources and thus the output type * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} * @param prefetch - * the number of elements to prefetch from the current Observable - * @return an Observable that emits the result of applying the transformation function to each item emitted - * by the source ObservableSource and concatenating the ObservableSources obtained from this transformation + * the number of elements to prefetch from the current {@code Observable} + * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted + * by the current {@code Observable} and concatenating the {@code ObservableSource}s obtained from this transformation * @see ReactiveX operators documentation: FlatMap * @see #concatMap(Function, int, Scheduler) */ @@ -6416,9 +6427,9 @@ public final Observable concatMap(@NonNull Function * *

@@ -6429,16 +6440,16 @@ public final Observable concatMap(@NonNull Function{@code concatMap} executes the given {@code mapper} function on the provided {@link Scheduler}.

*
* - * @param the type of the inner ObservableSource sources and thus the output type + * @param the type of the inner {@code ObservableSource} sources and thus the output type * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} * @param prefetch - * the number of elements to prefetch from the current Observable + * the number of elements to prefetch from the current {@code Observable} * @param scheduler * the scheduler where the {@code mapper} function will be executed - * @return an Observable that emits the result of applying the transformation function to each item emitted - * by the source ObservableSource and concatenating the ObservableSources obtained from this transformation + * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted + * by the current {@code Observable} and concatenating the {@code ObservableSource}s obtained from this transformation * @since 3.0.0 * @see ReactiveX operators documentation: FlatMap */ @@ -6453,9 +6464,9 @@ public final Observable concatMap(@NonNull Function * @@ -6469,8 +6480,8 @@ public final Observable concatMap(@NonNull Function * * @param the result value type - * @param mapper the function that maps the items of this ObservableSource into the inner ObservableSources. - * @return the new ObservableSource instance with the concatenation behavior + * @param mapper the function that maps the items of this {@code ObservableSource} into the inner {@code ObservableSource}s. + * @return the new {@code ObservableSource} instance with the concatenation behavior * @see #concatMapDelayError(Function, boolean, int, Scheduler) */ @CheckReturnValue @@ -6481,9 +6492,9 @@ public final Observable concatMapDelayError(@NonNull Function * @@ -6497,13 +6508,13 @@ public final Observable concatMapDelayError(@NonNull Function * * @param the result value type - * @param mapper the function that maps the items of this ObservableSource into the inner ObservableSources. + * @param mapper the function that maps the items of this {@code ObservableSource} into the inner {@code ObservableSource}s. * @param tillTheEnd - * if true, all errors from the outer and inner ObservableSource sources are delayed until the end, - * if false, an error from the main source is signalled when the current ObservableSource source terminates + * if {@code true}, all errors from the outer and inner {@code ObservableSource} sources are delayed until the end, + * if {@code false}, an error from the main source is signaled when the current {@code Observable} source terminates * @param prefetch - * the number of elements to prefetch from the current Observable - * @return the new ObservableSource instance with the concatenation behavior + * the number of elements to prefetch from the current {@code Observable} + * @return the new {@code ObservableSource} instance with the concatenation behavior * @see #concatMapDelayError(Function, boolean, int, Scheduler) */ @CheckReturnValue @@ -6525,9 +6536,9 @@ public final Observable concatMapDelayError(@NonNull Function * @@ -6537,15 +6548,15 @@ public final Observable concatMapDelayError(@NonNull Function * * @param the result value type - * @param mapper the function that maps the items of this ObservableSource into the inner ObservableSources. + * @param mapper the function that maps the items of this {@code ObservableSource} into the inner {@code ObservableSource}s. * @param tillTheEnd - * if true, all errors from the outer and inner ObservableSource sources are delayed until the end, - * if false, an error from the main source is signalled when the current ObservableSource source terminates + * if {@code true}, all errors from the outer and inner {@code ObservableSource} sources are delayed until the end, + * if {@code false}, an error from the main source is signaled when the current {@code Observable} source terminates * @param prefetch - * the number of elements to prefetch from the current Observable + * the number of elements to prefetch from the current {@code Observable} * @param scheduler * the scheduler where the {@code mapper} function will be executed - * @return the new ObservableSource instance with the concatenation behavior + * @return the new {@code ObservableSource} instance with the concatenation behavior * @see #concatMapDelayError(Function, boolean, int) * @since 3.0.0 */ @@ -6561,11 +6572,11 @@ public final Observable concatMapDelayError(@NonNull Function * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in + * current {@code Observable}s. The operator buffers the values emitted by these {@code ObservableSource}s and then drains them in * order, each one after the previous one completes. *

* @@ -6574,9 +6585,9 @@ public final Observable concatMapDelayError(@NonNull FunctionThis method does not operate by default on a particular {@link Scheduler}.

*
* @param the value type - * @param mapper the function that maps a sequence of values into a sequence of ObservableSources that will be + * @param mapper the function that maps a sequence of values into a sequence of {@code ObservableSource}s that will be * eagerly concatenated - * @return the new ObservableSource instance with the specified concatenation behavior + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -6587,11 +6598,11 @@ public final Observable concatMapEager(@NonNull Function * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in + * current {@code Observable}s. The operator buffers the values emitted by these {@code ObservableSource}s and then drains them in * order, each one after the previous one completes. *

* @@ -6600,11 +6611,11 @@ public final Observable concatMapEager(@NonNull FunctionThis method does not operate by default on a particular {@link Scheduler}.

*
* @param the value type - * @param mapper the function that maps a sequence of values into a sequence of ObservableSources that will be + * @param mapper the function that maps a sequence of values into a sequence of {@code ObservableSource}s that will be * eagerly concatenated - * @param maxConcurrency the maximum number of concurrent subscribed ObservableSources - * @param prefetch hints about the number of expected values from each inner ObservableSource, must be positive - * @return the new ObservableSource instance with the specified concatenation behavior + * @param maxConcurrency the maximum number of concurrent subscribed {@code ObservableSource}s + * @param prefetch hints about the number of expected values from each inner {@code ObservableSource}, must be positive + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -6619,11 +6630,11 @@ public final Observable concatMapEager(@NonNull Function * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in + * current {@code Observable}s. The operator buffers the values emitted by these {@code ObservableSource}s and then drains them in * order, each one after the previous one completes. *

* @@ -6632,12 +6643,12 @@ public final Observable concatMapEager(@NonNull FunctionThis method does not operate by default on a particular {@link Scheduler}.

*
* @param the value type - * @param mapper the function that maps a sequence of values into a sequence of ObservableSources that will be + * @param mapper the function that maps a sequence of values into a sequence of {@code ObservableSource}s that will be * eagerly concatenated * @param tillTheEnd - * if true, all errors from the outer and inner ObservableSource sources are delayed until the end, - * if false, an error from the main source is signalled when the current ObservableSource source terminates - * @return the new ObservableSource instance with the specified concatenation behavior + * if {@code true}, all errors from the outer and inner {@code ObservableSource} sources are delayed until the end, + * if {@code false}, an error from the main source is signaled when the current {@code Observable} source terminates + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -6649,11 +6660,11 @@ public final Observable concatMapEagerDelayError(@NonNull Function * Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the - * source ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in + * current {@code Observable}s. The operator buffers the values emitted by these {@code ObservableSource}s and then drains them in * order, each one after the previous one completes. *

* @@ -6662,16 +6673,16 @@ public final Observable concatMapEagerDelayError(@NonNull FunctionThis method does not operate by default on a particular {@link Scheduler}.

*
* @param the value type - * @param mapper the function that maps a sequence of values into a sequence of ObservableSources that will be + * @param mapper the function that maps a sequence of values into a sequence of {@code ObservableSource}s that will be * eagerly concatenated * @param tillTheEnd - * if true, exceptions from the current Observable and all the inner ObservableSources are delayed until - * all of them terminate, if false, exception from the current Observable is delayed until the - * currently running ObservableSource terminates - * @param maxConcurrency the maximum number of concurrent subscribed ObservableSources + * if {@code true}, exceptions from the current {@code Observable} and all the inner {@code ObservableSource}s are delayed until + * all of them terminate, if {@code false}, exception from the current {@code Observable} is delayed until the + * currently running {@code ObservableSource} terminates + * @param maxConcurrency the maximum number of concurrent subscribed {@code ObservableSource}s * @param prefetch - * the number of elements to prefetch from each source ObservableSource - * @return the new ObservableSource instance with the specified concatenation behavior + * the number of elements to prefetch from each source {@code ObservableSource} + * @return the new {@code ObservableSource} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -6686,8 +6697,8 @@ public final Observable concatMapEagerDelayError(@NonNull Function * *
@@ -6696,8 +6707,8 @@ public final Observable concatMapEagerDelayError(@NonNull Function *

History: 2.1.6 - experimental * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns a CompletableSource - * @return a Completable that signals {@code onComplete} when the upstream and all CompletableSources complete + * a function that, when applied to an item emitted by the current {@code Observable}, returns a {@code CompletableSource} + * @return a {@link Completable} that signals {@code onComplete} when the upstream and all {@code CompletableSource}s complete * @since 2.2 */ @CheckReturnValue @@ -6708,8 +6719,8 @@ public final Completable concatMapCompletable(@NonNull Function * *

@@ -6718,12 +6729,12 @@ public final Completable concatMapCompletable(@NonNull Function *

History: 2.1.6 - experimental * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns a CompletableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns a {@code CompletableSource} * * @param capacityHint - * the number of upstream items expected to be buffered until the current CompletableSource, mapped from + * the number of upstream items expected to be buffered until the current {@code CompletableSource}, mapped from * the current item, completes. - * @return a Completable that signals {@code onComplete} when the upstream and all CompletableSources complete + * @return a {@link Completable} that signals {@code onComplete} when the upstream and all {@code CompletableSources} complete * @since 2.2 */ @CheckReturnValue @@ -6749,7 +6760,7 @@ public final Completable concatMapCompletable(@NonNull Function * * @@ -6840,12 +6851,12 @@ public final Completable concatMapCompletableDelayError(@NonNull Function * * @param - * the type of item emitted by the resulting ObservableSource + * the type of item emitted by the resulting {@code Observable} * @param mapper - * a function that returns an Iterable sequence of values for when given an item emitted by the - * source ObservableSource - * @return an Observable that emits the results of concatenating the items emitted by the source ObservableSource with - * the values in the Iterables corresponding to those items, as generated by {@code collectionSelector} + * a function that returns an {@code Iterable} sequence of values for when given an item emitted by the + * current {@code Observable} + * @return an {@code Observable} that emits the results of concatenating the items emitted by the current {@code Observable} with + * the values in the {@code Iterable}s corresponding to those items * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -6857,8 +6868,8 @@ public final Observable concatMapIterable(@NonNull Function * * @@ -6868,14 +6879,14 @@ public final Observable concatMapIterable(@NonNull Function * * @param - * the type of item emitted by the resulting ObservableSource + * the type of item emitted by the resulting {@code Observable} * @param mapper - * a function that returns an Iterable sequence of values for when given an item emitted by the - * source ObservableSource + * a function that returns an {@code Iterable} sequence of values for when given an item emitted by the + * current {@code Observable} * @param prefetch - * the number of elements to prefetch from the current Observable - * @return an Observable that emits the results of concatenating the items emitted by the source ObservableSource with - * the values in the Iterables corresponding to those items, as generated by {@code collectionSelector} + * the number of elements to prefetch from the current {@code Observable} + * @return an {@code Observable} that emits the results of concatenating the items emitted by the current {@code Observable} with + * the values in the {@code Iterable}s corresponding to those items * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -6902,7 +6913,7 @@ public final Observable concatMapIterable(@NonNull Function Observable concatMapMaybe(@NonNull Function Observable concatMapMaybe(@NonNull Function Observable concatMapMaybeDelayError(@NonNull Function Observable concatMapMaybeDelayError(@NonNull Function Observable concatMapMaybeDelayError(@NonNull Function Observable concatMapSingle(@NonNull Function Observable concatMapSingle(@NonNull Function Observable concatMapSingleDelayError(@NonNull Function Observable concatMapSingleDelayError(@NonNull Function Observable concatMapSingleDelayError(@NonNull Function * *

@@ -7214,8 +7225,8 @@ public final Observable concatMapSingleDelayError(@NonNull Function * * @param other - * an ObservableSource to be concatenated after the current - * @return an Observable that emits items emitted by the two source ObservableSources, one after the other, + * an {@code ObservableSource} to be concatenated after the current + * @return an {@code Observable} that emits items emitted by the two source {@code ObservableSource}s, one after the other, * without interleaving them * @see ReactiveX operators documentation: Concat */ @@ -7229,7 +7240,7 @@ public final Observable concatWith(@NonNull ObservableSource oth /** * Returns an {@code Observable} that emits the items from this {@code Observable} followed by the success item or error event - * of the other {@link SingleSource}. + * of the {@code other} {@link SingleSource}. *

* *

@@ -7237,8 +7248,8 @@ public final Observable concatWith(@NonNull ObservableSource oth *
{@code concatWith} does not operate by default on a particular {@link Scheduler}.
*
*

History: 2.1.10 - experimental - * @param other the SingleSource whose signal should be emitted after this {@code Observable} completes normally. - * @return the new Observable instance + * @param other the {@code SingleSource} whose signal should be emitted after this {@code Observable} completes normally. + * @return the new {@code Observable} instance * @since 2.2 */ @CheckReturnValue @@ -7259,8 +7270,8 @@ public final Observable concatWith(@NonNull SingleSource other) *

{@code concatWith} does not operate by default on a particular {@link Scheduler}.
*
*

History: 2.1.10 - experimental - * @param other the MaybeSource whose signal should be emitted after this Observable completes normally. - * @return the new Observable instance + * @param other the {@code MaybeSource} whose signal should be emitted after this {@code Observable} completes normally. + * @return the new {@code Observable} instance * @since 2.2 */ @CheckReturnValue @@ -7282,7 +7293,7 @@ public final Observable concatWith(@NonNull MaybeSource other) { *

*

History: 2.1.10 - experimental * @param other the {@code CompletableSource} to subscribe to once the current {@code Observable} completes normally - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 2.2 */ @CheckReturnValue @@ -7294,7 +7305,7 @@ public final Observable concatWith(@NonNull CompletableSource other) { } /** - * Returns a Single that emits a Boolean that indicates whether the source ObservableSource emitted a + * Returns a {@link Single} that emits a {@link Boolean} that indicates whether the current {@code Observable} emitted a * specified item. *

* @@ -7304,9 +7315,9 @@ public final Observable concatWith(@NonNull CompletableSource other) { *

* * @param element - * the item to search for in the emissions from the source ObservableSource - * @return a Single that emits {@code true} if the specified item is emitted by the source ObservableSource, - * or {@code false} if the source ObservableSource completes without emitting that item + * the item to search for in the emissions from the current {@code Observable} + * @return a {@code Single} that emits {@code true} if the specified item is emitted by the current {@code Observable}, + * or {@code false} if the current {@code Observable} completes without emitting that item * @see ReactiveX operators documentation: Contains */ @CheckReturnValue @@ -7318,8 +7329,8 @@ public final Single contains(@NonNull Object element) { } /** - * Returns a Single that counts the total number of items emitted by the source ObservableSource and emits - * this count as a 64-bit Long. + * Returns a {@link Single} that counts the total number of items emitted by the current {@code Observable} and emits + * this count as a 64-bit {@link Long}. *

* *

@@ -7327,8 +7338,8 @@ public final Single contains(@NonNull Object element) { *
{@code count} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a Single that emits a single item: the number of items emitted by the source ObservableSource as a - * 64-bit Long item + * @return a {@code Single} that emits a single item: the number of items emitted by the current {@code Observable} as a + * 64-bit {@code Long} item * @see ReactiveX operators documentation: Count */ @CheckReturnValue @@ -7339,8 +7350,9 @@ public final Single count() { } /** - * Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the - * source ObservableSource that are followed by another item within a computed debounce duration. + * Returns an {@code Observable} that mirrors the current {@code Observable}, except that it drops items emitted by the + * current {@code Observable} that are followed by another item within a computed debounce duration + * denoted by an item emission or completion from a generated inner {@link ObservableSource} for that original item. *

* *

@@ -7359,8 +7371,8 @@ public final Single count() { * @param * the debounce value type (ignored) * @param debounceSelector - * function to retrieve a sequence that indicates the throttle duration for each item - * @return an Observable that omits items emitted by the source ObservableSource that are followed by another item + * function to return a sequence that indicates the throttle duration for each item via its own emission or completion + * @return an {@code Observable} that omits items emitted by the current {@code Observable} that are followed by another item * within a computed debounce duration * @see ReactiveX operators documentation: Debounce */ @@ -7373,12 +7385,12 @@ public final Observable debounce(@NonNull Function - * Note: If items keep being emitted by the source ObservableSource faster than the timeout then no items - * will be emitted by the resulting ObservableSource. + * Note: If items keep being emitted by the current {@code Observable} faster than the timeout then no items + * will be emitted by the resulting {@code Observable}. *

* *

@@ -7394,12 +7406,12 @@ public final Observable debounce(@NonNull Function * * @param timeout - * the length of the window of time that must pass after the emission of an item from the source - * ObservableSource in which that ObservableSource emits no items in order for the item to be emitted by the - * resulting ObservableSource + * the length of the window of time that must pass after the emission of an item from the current + * {@code Observable} in which that {@code ObservableSource} emits no items in order for the item to be emitted by the + * resulting {@code Observable} * @param unit * the unit of time for the specified {@code timeout} - * @return an Observable that filters out items from the source ObservableSource that are too quickly followed by + * @return an {@code Observable} that filters out items from the current {@code Observable} that are too quickly followed by * newer items * @see ReactiveX operators documentation: Debounce * @see #throttleWithTimeout(long, TimeUnit) @@ -7412,12 +7424,12 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit) { } /** - * Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the - * source ObservableSource that are followed by newer items before a timeout value expires on a specified + * Returns an {@code Observable} that mirrors the current {@code Observable}, except that it drops items emitted by the + * current {@code Observable} that are followed by newer items before a timeout value expires on a specified * Scheduler. The timer resets on each emission. *

- * Note: If items keep being emitted by the source ObservableSource faster than the timeout then no items - * will be emitted by the resulting ObservableSource. + * Note: If items keep being emitted by the current {@code Observable} faster than the timeout then no items + * will be emitted by the resulting {@code Observable}. *

* *

@@ -7433,14 +7445,14 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit) { *

* * @param timeout - * the time each item has to be "the most recent" of those emitted by the source ObservableSource to + * the time each item has to be "the most recent" of those emitted by the current {@code Observable} to * ensure that it's not dropped * @param unit * the unit of time for the specified {@code timeout} * @param scheduler * the {@link Scheduler} to use internally to manage the timers that handle the timeout for each * item - * @return an Observable that filters out items from the source ObservableSource that are too quickly followed by + * @return an {@code Observable} that filters out items from the current {@code Observable} that are too quickly followed by * newer items * @see ReactiveX operators documentation: Debounce * @see #throttleWithTimeout(long, TimeUnit, Scheduler) @@ -7455,8 +7467,8 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit, @NonNu } /** - * Returns an Observable that emits the items emitted by the source ObservableSource or a specified default item - * if the source ObservableSource is empty. + * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} or a specified default item + * if the current {@code Observable} is empty. *

* *

@@ -7465,9 +7477,9 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit, @NonNu *
* * @param defaultItem - * the item to emit if the source ObservableSource emits no items - * @return an Observable that emits either the specified default item if the source ObservableSource emits no - * items, or the items emitted by the source ObservableSource + * the item to emit if the current {@code Observable} emits no items + * @return an {@code Observable} that emits either the specified default item if the current {@code Observable} emits no + * items, or the items emitted by the current {@code Observable} * @see ReactiveX operators documentation: DefaultIfEmpty */ @CheckReturnValue @@ -7479,13 +7491,13 @@ public final Observable defaultIfEmpty(@NonNull T defaultItem) { } /** - * Returns an Observable that delays the emissions of the source ObservableSource via another ObservableSource on a + * Returns an {@code Observable} that delays the emissions of the current {@code Observable} via another {@code ObservableSource} on a * per-item basis. *

* *

- * Note: the resulting ObservableSource will immediately propagate any {@code onError} notification - * from the source ObservableSource. + * Note: the resulting {@code Observable} will immediately propagate any {@code onError} notification + * from the current {@code Observable}. *

*
Scheduler:
*
This version of {@code delay} does not operate by default on a particular {@link Scheduler}.
@@ -7494,10 +7506,10 @@ public final Observable defaultIfEmpty(@NonNull T defaultItem) { * @param * the item delay value type (ignored) * @param itemDelay - * a function that returns an ObservableSource for each item emitted by the source ObservableSource, which is - * then used to delay the emission of that item by the resulting ObservableSource until the ObservableSource + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable}, which is + * then used to delay the emission of that item by the resulting {@code Observable} until the {@code ObservableSource} * returned from {@code itemDelay} emits an item - * @return an Observable that delays the emissions of the source ObservableSource via another ObservableSource on a + * @return an {@code Observable} that delays the emissions of the current {@code Observable} via another {@code ObservableSource} on a * per-item basis * @see ReactiveX operators documentation: Delay */ @@ -7510,8 +7522,8 @@ public final Observable delay(@NonNull Function * *
@@ -7523,7 +7535,7 @@ public final Observable delay(@NonNull FunctionReactiveX operators documentation: Delay */ @CheckReturnValue @@ -7534,8 +7546,8 @@ public final Observable delay(long delay, @NonNull TimeUnit unit) { } /** - * Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a - * specified delay. If {@code delayError} is true, error notifications will also be delayed. + * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} shifted forward in time by a + * specified delay. If {@code delayError} is {@code true}, error notifications will also be delayed. *

* *

@@ -7548,9 +7560,9 @@ public final Observable delay(long delay, @NonNull TimeUnit unit) { * @param unit * the {@link TimeUnit} in which {@code period} is defined * @param delayError - * if true, the upstream exception is signalled with the given delay, after all preceding normal elements, - * if false, the upstream exception is signalled immediately - * @return the source ObservableSource shifted in time by the specified delay + * if {@code true}, the upstream exception is signaled with the given delay, after all preceding normal elements, + * if {@code false}, the upstream exception is signaled immediately + * @return the current {@code Observable} shifted in time by the specified delay * @see ReactiveX operators documentation: Delay */ @CheckReturnValue @@ -7561,8 +7573,8 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, boolean del } /** - * Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a - * specified delay. Error notifications from the source ObservableSource are not delayed. + * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} shifted forward in time by a + * specified delay. Error notifications from the current {@code Observable} are not delayed. *

* *

@@ -7576,7 +7588,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, boolean del * the time unit of {@code delay} * @param scheduler * the {@link Scheduler} to use for delaying - * @return the source ObservableSource shifted in time by the specified delay + * @return the current {@code Observable} shifted in time by the specified delay * @see ReactiveX operators documentation: Delay */ @CheckReturnValue @@ -7587,8 +7599,8 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, @NonNull Sc } /** - * Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a - * specified delay. If {@code delayError} is true, error notifications will also be delayed. + * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} shifted forward in time by a + * specified delay. If {@code delayError} is {@code true}, error notifications will also be delayed. *

* *

@@ -7603,9 +7615,9 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, @NonNull Sc * @param scheduler * the {@link Scheduler} to use for delaying * @param delayError - * if true, the upstream exception is signalled with the given delay, after all preceding normal elements, - * if false, the upstream exception is signalled immediately - * @return the source ObservableSource shifted in time by the specified delay + * if {@code true}, the upstream exception is signaled with the given delay, after all preceding normal elements, + * if {@code false}, the upstream exception is signaled immediately + * @return the current {@code Observable} shifted in time by the specified delay * @see ReactiveX operators documentation: Delay */ @CheckReturnValue @@ -7619,13 +7631,13 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, @NonNull Sc } /** - * Returns an Observable that delays the subscription to and emissions from the source ObservableSource via another - * ObservableSource on a per-item basis. + * Returns an {@code Observable} that delays the subscription to and emissions from the current {@code Observable} via another + * {@code ObservableSource} on a per-item basis. *

* *

- * Note: the resulting ObservableSource will immediately propagate any {@code onError} notification - * from the source ObservableSource. + * Note: the resulting {@code Observable} will immediately propagate any {@code onError} notification + * from the current {@code Observable}. *

*
Scheduler:
*
This version of {@code delay} does not operate by default on a particular {@link Scheduler}.
@@ -7636,14 +7648,14 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, @NonNull Sc * @param * the item delay value type (ignored) * @param subscriptionDelay - * a function that returns an ObservableSource that triggers the subscription to the source ObservableSource + * a function that returns an {@code ObservableSource} that triggers the subscription to the current {@code Observable} * once it emits any item * @param itemDelay - * a function that returns an ObservableSource for each item emitted by the source ObservableSource, which is - * then used to delay the emission of that item by the resulting ObservableSource until the ObservableSource + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable}, which is + * then used to delay the emission of that item by the resulting {@code Observable} until the {@code ObservableSource} * returned from {@code itemDelay} emits an item - * @return an Observable that delays the subscription and emissions of the source ObservableSource via another - * ObservableSource on a per-item basis + * @return an {@code Observable} that delays the subscription and emissions of the current {@code Observable} via another + * {@code ObservableSource} on a per-item basis * @see ReactiveX operators documentation: Delay */ @CheckReturnValue @@ -7655,8 +7667,8 @@ public final Observable delay(@NonNull ObservableSource subscriptio } /** - * Returns an Observable that delays the subscription to this Observable - * until the other Observable emits an element or completes normally. + * Returns an {@code Observable} that delays the subscription to this {@code Observable} + * until the other {@code Observable} emits an element or completes normally. *

* *

@@ -7664,11 +7676,11 @@ public final Observable delay(@NonNull ObservableSource subscriptio *
This method does not operate by default on a particular {@link Scheduler}.
*
* - * @param the value type of the other Observable, irrelevant - * @param other the other Observable that should trigger the subscription - * to this Observable. - * @return an Observable that delays the subscription to this Observable - * until the other Observable emits an element or completes normally. + * @param the value type of the other {@code Observable}, irrelevant + * @param other the other {@code Observable} that should trigger the subscription + * to this {@code Observable}. + * @return an {@code Observable} that delays the subscription to this {@code Observable} + * until the other {@code Observable} emits an element or completes normally. * @since 2.0 */ @CheckReturnValue @@ -7680,7 +7692,7 @@ public final Observable delaySubscription(@NonNull ObservableSource ot } /** - * Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time. + * Returns an {@code Observable} that delays the subscription to the current {@code Observable} by a given amount of time. *

* *

@@ -7692,7 +7704,7 @@ public final Observable delaySubscription(@NonNull ObservableSource ot * the time to delay the subscription * @param unit * the time unit of {@code delay} - * @return an Observable that delays the subscription to the source ObservableSource by the given amount + * @return an {@code Observable} that delays the subscription to the current {@code Observable} by the given amount * @see ReactiveX operators documentation: Delay */ @CheckReturnValue @@ -7703,7 +7715,7 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit) } /** - * Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time, + * Returns an {@code Observable} that delays the subscription to the current {@code Observable} by a given amount of time, * both waiting and subscribing on a given Scheduler. *

* @@ -7718,7 +7730,7 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit) * the time unit of {@code delay} * @param scheduler * the Scheduler on which the waiting and subscription will happen - * @return an Observable that delays the subscription to the source ObservableSource by a given + * @return an {@code Observable} that delays the subscription to the current {@code Observable} by a given * amount, waiting and subscribing on the given Scheduler * @see ReactiveX operators documentation: Delay */ @@ -7730,7 +7742,7 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit, } /** - * Returns an Observable that reverses the effect of {@link #materialize materialize} by transforming the + * Returns an {@code Observable} that reverses the effect of {@link #materialize materialize} by transforming the * {@link Notification} objects extracted from the source items via a selector function * into their respective {@code Observer} signal types. *

@@ -7744,7 +7756,7 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit, *

* When the upstream signals an {@link Notification#createOnError(Throwable) onError} or * {@link Notification#createOnComplete() onComplete} item, the - * returned Observable disposes of the flow and terminates with that type of terminal event: + * returned {@code Observable} disposes of the flow and terminates with that type of terminal event: * 


      * Observable.just(createOnNext(1), createOnComplete(), createOnNext(2))
      * .doOnDispose(() -> System.out.println("Disposed!"));
@@ -7771,8 +7783,8 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit,
      * @param  the output value type
      * @param selector function that returns the upstream item and should return a Notification to signal
      * the corresponding {@code Observer} event to the downstream.
-     * @return an Observable that emits the items and notifications embedded in the {@link Notification} objects
-     *         selected from the items emitted by the source ObservableSource
+     * @return an {@code Observable} that emits the items and notifications embedded in the {@link Notification} objects
+     *         selected from the items emitted by the current {@code Observable}
      * @see ReactiveX operators documentation: Dematerialize
      * @since 3.0.0
      */
@@ -7785,7 +7797,7 @@ public final  Observable dematerialize(@NonNull Function
      * 
@@ -7794,7 +7806,7 @@ public final  Observable dematerialize(@NonNull Function
-     * By default, {@code distinct()} uses an internal {@link java.util.HashSet} per Observer to remember
+     * By default, {@code distinct()} uses an internal {@link java.util.HashSet} per {@code Observer} to remember
      * previously seen items and uses {@link java.util.Set#add(Object)} returning {@code false} as the
      * indicator for duplicates.
      * 

@@ -7809,7 +7821,7 @@ public final  Observable dematerialize(@NonNull Function{@code distinct} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an Observable that emits only those items emitted by the source ObservableSource that are distinct from + * @return an {@code Observable} that emits only those items emitted by the current {@code Observable} that are distinct from * each other * @see ReactiveX operators documentation: Distinct * @see #distinct(Function) @@ -7823,7 +7835,7 @@ public final Observable distinct() { } /** - * Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according + * Returns an {@code Observable} that emits all items emitted by the current {@code Observable} that are distinct according * to a key selector function and based on {@link Object#equals(Object)} comparison of the objects * returned by the key selector function. *

@@ -7833,7 +7845,7 @@ public final Observable distinct() { * and {@link Object#hashCode()} to provide meaningful comparison between the key objects as the default * Java implementation only considers reference equivalence. *

- * By default, {@code distinct()} uses an internal {@link java.util.HashSet} per Observer to remember + * By default, {@code distinct()} uses an internal {@link java.util.HashSet} per {@code Observer} to remember * previously seen keys and uses {@link java.util.Set#add(Object)} returning {@code false} as the * indicator for duplicates. *

@@ -7852,7 +7864,7 @@ public final Observable distinct() { * @param keySelector * a function that projects an emitted item to a key value that is used to decide whether an item * is distinct from another one or not - * @return an Observable that emits those items emitted by the source ObservableSource that have distinct keys + * @return an {@code Observable} that emits those items emitted by the current {@code Observable} that have distinct keys * @see ReactiveX operators documentation: Distinct * @see #distinct(Function, Supplier) */ @@ -7864,7 +7876,7 @@ public final Observable distinct(@NonNull Function keySelec } /** - * Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according + * Returns an {@code Observable} that emits all items emitted by the current {@code Observable} that are distinct according * to a key selector function and based on {@link Object#equals(Object)} comparison of the objects * returned by the key selector function. *

@@ -7883,9 +7895,9 @@ public final Observable distinct(@NonNull Function keySelec * a function that projects an emitted item to a key value that is used to decide whether an item * is distinct from another one or not * @param collectionSupplier - * function called for each individual Observer to return a Collection subtype for holding the extracted + * function called for each individual {@code Observer} to return a Collection subtype for holding the extracted * keys and whose add() method's return indicates uniqueness. - * @return an Observable that emits those items emitted by the source ObservableSource that have distinct keys + * @return an {@code Observable} that emits those items emitted by the current {@code Observable} that have distinct keys * @see ReactiveX operators documentation: Distinct */ @CheckReturnValue @@ -7898,7 +7910,7 @@ public final Observable distinct(@NonNull Function keySelec } /** - * Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their + * Returns an {@code Observable} that emits all items emitted by the current {@code Observable} that are distinct from their * immediate predecessors based on {@link Object#equals(Object)} comparison. *

* @@ -7923,7 +7935,7 @@ public final Observable distinct(@NonNull Function keySelec *

{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an Observable that emits those items from the source ObservableSource that are distinct from their + * @return an {@code Observable} that emits those items from the current {@code Observable} that are distinct from their * immediate predecessors * @see ReactiveX operators documentation: Distinct * @see #distinctUntilChanged(BiPredicate) @@ -7936,7 +7948,7 @@ public final Observable distinctUntilChanged() { } /** - * Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their + * Returns an {@code Observable} that emits all items emitted by the current {@code Observable} that are distinct from their * immediate predecessors, according to a key selector function and based on {@link Object#equals(Object)} comparison * of those objects returned by the key selector function. *

@@ -7967,7 +7979,7 @@ public final Observable distinctUntilChanged() { * @param keySelector * a function that projects an emitted item to a key value that is used to decide whether an item * is distinct from another one or not - * @return an Observable that emits those items from the source ObservableSource whose keys are distinct from + * @return an {@code Observable} that emits those items from the current {@code Observable} whose keys are distinct from * those of their immediate predecessors * @see ReactiveX operators documentation: Distinct */ @@ -7980,7 +7992,7 @@ public final Observable distinctUntilChanged(@NonNull Function * @@ -8001,7 +8013,7 @@ public final Observable distinctUntilChanged(@NonNull FunctionReactiveX operators documentation: Distinct * @since 2.0 @@ -8028,7 +8040,7 @@ public final Observable distinctUntilChanged(@NonNull BiPredicate *

History: 2.0.1 - experimental * @param onAfterNext the Consumer that will be called after emitting an item from upstream to the downstream - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 2.1 */ @CheckReturnValue @@ -8040,7 +8052,7 @@ public final Observable doAfterNext(@NonNull Consumer onAfterNext) } /** - * Registers an {@link Action} to be called when this ObservableSource invokes either + * Registers an {@link Action} to be called when this {@code ObservableSource} invokes either * {@link Observer#onComplete onComplete} or {@link Observer#onError onError}. *

* @@ -8050,8 +8062,8 @@ public final Observable doAfterNext(@NonNull Consumer onAfterNext) *

* * @param onFinally - * an {@link Action} to be invoked when the source ObservableSource finishes - * @return an Observable that emits the same items as the source ObservableSource, then invokes the + * an {@link Action} to be invoked when the current {@code Observable} finishes + * @return an {@code Observable} that emits the same items as the current {@code Observable}, then invokes the * {@link Action} * @see ReactiveX operators documentation: Do * @see #doOnTerminate(Action) @@ -8065,7 +8077,7 @@ public final Observable doAfterTerminate(@NonNull Action onFinally) { } /** - * Calls the specified action after this Observable signals onError or onCompleted or gets disposed by + * Calls the specified action after this {@code Observable} signals onError or onCompleted or gets disposed by * the downstream. *

In case of a race between a terminal event and a dispose call, the provided {@code onFinally} action * is executed once per subscription. @@ -8080,8 +8092,8 @@ public final Observable doAfterTerminate(@NonNull Action onFinally) { *

This operator supports boundary-limited synchronous or asynchronous queue-fusion.
*
*

History: 2.0.1 - experimental - * @param onFinally the action called when this Observable terminates or gets disposed - * @return the new Observable instance + * @param onFinally the action called when this {@code Observable} terminates or gets disposed + * @return the new {@code Observable} instance * @since 2.1 */ @CheckReturnValue @@ -8108,8 +8120,8 @@ public final Observable doFinally(@NonNull Action onFinally) { *

* * @param onDispose - * the action that gets called when the source {@code ObservableSource}'s Disposable is disposed - * @return the source {@code ObservableSource} modified so as to call this Action when appropriate + * the action that gets called when the current {@code Observable}'s Disposable is disposed + * @return the current {@code Observable} modified so as to call this Action when appropriate * @throws NullPointerException if onDispose is null * @see ReactiveX operators documentation: Do */ @@ -8121,7 +8133,7 @@ public final Observable doOnDispose(@NonNull Action onDispose) { } /** - * Modifies the source ObservableSource so that it invokes an action when it calls {@code onComplete}. + * Modifies the current {@code Observable} so that it invokes an action when it calls {@code onComplete}. *

* *

@@ -8130,8 +8142,8 @@ public final Observable doOnDispose(@NonNull Action onDispose) { *
* * @param onComplete - * the action to invoke when the source ObservableSource calls {@code onComplete} - * @return the source ObservableSource with the side-effecting behavior applied + * the action to invoke when the current {@code Observable} calls {@code onComplete} + * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8151,7 +8163,7 @@ public final Observable doOnComplete(@NonNull Action onComplete) { *
{@code doOnEach} does not operate by default on a particular {@link Scheduler}.
*
* - * @return the source ObservableSource with the side-effecting behavior applied + * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8166,7 +8178,7 @@ private Observable doOnEach(@NonNull Consumer onNext, @NonNull Con } /** - * Modifies the source ObservableSource so that it invokes an action for each item it emits. + * Modifies the current {@code Observable} so that it invokes an action for each item it emits. *

* *

@@ -8175,8 +8187,8 @@ private Observable doOnEach(@NonNull Consumer onNext, @NonNull Con *
* * @param onNotification - * the action to invoke for each item emitted by the source ObservableSource - * @return the source ObservableSource with the side-effecting behavior applied + * the action to invoke for each item emitted by the current {@code Observable} + * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8193,7 +8205,7 @@ public final Observable doOnEach(@NonNull Consumer> o } /** - * Modifies the source ObservableSource so that it notifies an Observer for each item and terminal event it emits. + * Modifies the current {@code Observable} so that it notifies an {@code Observer} for each item and terminal event it emits. *

* In case the {@code onError} of the supplied observer throws, the downstream will receive a composite * exception containing the original exception and the exception thrown by {@code onError}. If either the @@ -8208,8 +8220,8 @@ public final Observable doOnEach(@NonNull Consumer> o * * @param observer * the observer to be notified about onNext, onError and onComplete events on its - * respective methods before the actual downstream Observer gets notified. - * @return the source ObservableSource with the side-effecting behavior applied + * respective methods before the actual downstream {@code Observer} gets notified. + * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8225,7 +8237,7 @@ public final Observable doOnEach(@NonNull Observer observer) { } /** - * Modifies the source ObservableSource so that it invokes an action if it calls {@code onError}. + * Modifies the current {@code Observable} so that it invokes an action if it calls {@code onError}. *

* In case the {@code onError} action throws, the downstream will receive a composite exception containing * the original exception and the exception thrown by {@code onError}. @@ -8237,8 +8249,8 @@ public final Observable doOnEach(@NonNull Observer observer) { *

* * @param onError - * the action to invoke if the source ObservableSource calls {@code onError} - * @return the source ObservableSource with the side-effecting behavior applied + * the action to invoke if the current {@code Observable} calls {@code onError} + * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8262,7 +8274,7 @@ public final Observable doOnError(@NonNull Consumer onErro * a Consumer called with the Disposable sent via Observer.onSubscribe() * @param onDispose * called when the downstream disposes the Disposable via dispose() - * @return the source ObservableSource with the side-effecting behavior applied + * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8275,7 +8287,7 @@ public final Observable doOnLifecycle(@NonNull Consumer o } /** - * Modifies the source ObservableSource so that it invokes an action when it calls {@code onNext}. + * Modifies the current {@code Observable} so that it invokes an action when it calls {@code onNext}. *

* *

@@ -8284,8 +8296,8 @@ public final Observable doOnLifecycle(@NonNull Consumer o *
* * @param onNext - * the action to invoke when the source ObservableSource calls {@code onNext} - * @return the source ObservableSource with the side-effecting behavior applied + * the action to invoke when the current {@code Observable} calls {@code onNext} + * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8296,9 +8308,9 @@ public final Observable doOnNext(@NonNull Consumer onNext) { } /** - * Modifies the source {@code ObservableSource} so that it invokes the given action when it is subscribed from + * Modifies the current {@code Observable} so that it invokes the given action when it is subscribed from * its subscribers. Each subscription will result in an invocation of the given action except when the - * source {@code ObservableSource} is reference counted, in which case the source {@code ObservableSource} will invoke + * current {@code Observable} is reference counted, in which case the current {@code Observable} will invoke * the given action for the first subscription. *

* @@ -8308,8 +8320,8 @@ public final Observable doOnNext(@NonNull Consumer onNext) { *

* * @param onSubscribe - * the Consumer that gets called when an Observer subscribes to the current {@code Observable} - * @return the source {@code ObservableSource} modified so as to call this Consumer when appropriate + * the Consumer that gets called when an {@code Observer} subscribes to the current {@code Observable} + * @return the current {@code Observable} modified so as to call this Consumer when appropriate * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8320,7 +8332,7 @@ public final Observable doOnSubscribe(@NonNull Consumer o } /** - * Modifies the source ObservableSource so that it invokes an action when it calls {@code onComplete} or + * Modifies the current {@code Observable} so that it invokes an action when it calls {@code onComplete} or * {@code onError}. *

* @@ -8333,8 +8345,8 @@ public final Observable doOnSubscribe(@NonNull Consumer o *

* * @param onTerminate - * the action to invoke when the source ObservableSource calls {@code onComplete} or {@code onError} - * @return the source ObservableSource with the side-effecting behavior applied + * the action to invoke when the current {@code Observable} calls {@code onComplete} or {@code onError} + * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do * @see #doAfterTerminate(Action) */ @@ -8350,7 +8362,7 @@ public final Observable doOnTerminate(@NonNull Action onTerminate) { /** * Returns a Maybe that emits the single item at a specified index in a sequence of emissions from - * this Observable or completes if this Observable signals fewer elements than index. + * this {@code Observable} or completes if this {@code Observable} signals fewer elements than index. *

* *

@@ -8361,7 +8373,7 @@ public final Observable doOnTerminate(@NonNull Action onTerminate) { * @param index * the zero-based index of the item to retrieve * @return a Maybe that emits a single item: the item at the specified position in the sequence of - * those emitted by the source ObservableSource + * those emitted by the current {@code Observable} * @throws IndexOutOfBoundsException * if {@code index} is less than 0 * @see ReactiveX operators documentation: ElementAt @@ -8378,7 +8390,7 @@ public final Maybe elementAt(long index) { /** * Returns a Single that emits the item found at a specified index in a sequence of emissions from - * this Observable, or a default item if that index is out of range. + * the current {@code Observable}, or a default item if that index is out of range. *

* *

@@ -8390,8 +8402,8 @@ public final Maybe elementAt(long index) { * the zero-based index of the item to retrieve * @param defaultItem * the default item - * @return a Single that emits the item at the specified position in the sequence emitted by the source - * ObservableSource, or the default item if that index is outside the bounds of the source sequence + * @return a Single that emits the item at the specified position in the sequence emitted by the current + * {@code Observable}, or the default item if that index is outside the bounds of the source sequence * @throws IndexOutOfBoundsException * if {@code index} is less than 0 * @see ReactiveX operators documentation: ElementAt @@ -8408,8 +8420,8 @@ public final Single elementAt(long index, @NonNull T defaultItem) { } /** - * Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable - * or signals a {@link NoSuchElementException} if this Observable signals fewer elements than index. + * Returns a Single that emits the item found at a specified index in a sequence of emissions from this {@code Observable} + * or signals a {@link NoSuchElementException} if this {@code Observable} signals fewer elements than index. *

* *

@@ -8419,8 +8431,8 @@ public final Single elementAt(long index, @NonNull T defaultItem) { * * @param index * the zero-based index of the item to retrieve - * @return a Single that emits the item at the specified position in the sequence emitted by the source - * ObservableSource, or the default item if that index is outside the bounds of the source sequence + * @return a Single that emits the item at the specified position in the sequence emitted by the current + * {@code Observable}, or the default item if that index is outside the bounds of the source sequence * @throws IndexOutOfBoundsException * if {@code index} is less than 0 * @see ReactiveX operators documentation: ElementAt @@ -8436,7 +8448,7 @@ public final Single elementAtOrError(long index) { } /** - * Filters items emitted by an ObservableSource by only emitting those that satisfy a specified predicate. + * Filters items emitted by an {@code ObservableSource} by only emitting those that satisfy a specified predicate. *

* *

@@ -8445,9 +8457,9 @@ public final Single elementAtOrError(long index) { *
* * @param predicate - * a function that evaluates each item emitted by the source ObservableSource, returning {@code true} + * a function that evaluates each item emitted by the current {@code Observable}, returning {@code true} * if it passes the filter - * @return an Observable that emits only those items emitted by the source ObservableSource that the filter + * @return an {@code Observable} that emits only those items emitted by the current {@code Observable} that the filter * evaluates as {@code true} * @see ReactiveX operators documentation: Filter */ @@ -8460,8 +8472,8 @@ public final Observable filter(@NonNull Predicate predicate) { } /** - * Returns a Maybe that emits only the very first item emitted by the source ObservableSource, or - * completes if the source ObservableSource is empty. + * Returns a Maybe that emits only the very first item emitted by the current {@code Observable}, or + * completes if the current {@code Observable} is empty. *

* *

@@ -8480,8 +8492,8 @@ public final Maybe firstElement() { } /** - * Returns a Single that emits only the very first item emitted by the source ObservableSource, or a default item - * if the source ObservableSource completes without emitting any items. + * Returns a Single that emits only the very first item emitted by the current {@code Observable}, or a default item + * if the current {@code Observable} completes without emitting any items. *

* *

@@ -8490,7 +8502,7 @@ public final Maybe firstElement() { *
* * @param defaultItem - * the default item to emit if the source ObservableSource doesn't emit anything + * the default item to emit if the current {@code Observable} doesn't emit anything * @return the new Single instance * @see ReactiveX operators documentation: First */ @@ -8502,8 +8514,8 @@ public final Single first(@NonNull T defaultItem) { } /** - * Returns a Single that emits only the very first item emitted by this Observable or - * signals a {@link NoSuchElementException} if this Observable is empty. + * Returns a Single that emits only the very first item emitted by this {@code Observable} or + * signals a {@link NoSuchElementException} if this {@code Observable} is empty. *

* *

@@ -8522,9 +8534,9 @@ public final Single firstOrError() { } /** - * Returns an Observable that emits items based on applying a function that you supply to each item emitted - * by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting - * ObservableSources and emitting the results of this merger. + * Returns an {@code Observable} that emits items based on applying a function that you supply to each item emitted + * by the current {@code Observable}, where that function returns an {@code ObservableSource}, and then merging those resulting + * {@code ObservableSource}s and emitting the results of this merger. *

* *

@@ -8532,12 +8544,12 @@ public final Single firstOrError() { *
{@code flatMap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the value type of the inner ObservableSources and the output type + * @param the value type of the inner {@code ObservableSource}s and the output type * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource - * @return an Observable that emits the result of applying the transformation function to each item emitted - * by the source ObservableSource and merging the results of the ObservableSources obtained from this + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} + * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted + * by the current {@code Observable} and merging the results of the {@code ObservableSource}s obtained from this * transformation * @see ReactiveX operators documentation: FlatMap */ @@ -8549,9 +8561,9 @@ public final Observable flatMap(@NonNull Function * *
@@ -8559,15 +8571,15 @@ public final Observable flatMap(@NonNull Function{@code flatMap} does not operate by default on a particular {@link Scheduler}. *
* - * @param the value type of the inner ObservableSources and the output type + * @param the value type of the inner {@code ObservableSource}s and the output type * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} * @param delayErrors - * if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate - * if false, the first one signalling an exception will terminate the whole sequence immediately - * @return an Observable that emits the result of applying the transformation function to each item emitted - * by the source ObservableSource and merging the results of the ObservableSources obtained from this + * if {@code true}, exceptions from the current {@code Observable} and all inner {@code ObservableSource}s are delayed until all of them terminate + * if {@code false}, the first one signaling an exception will terminate the whole sequence immediately + * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted + * by the current {@code Observable} and merging the results of the {@code ObservableSource}s obtained from this * transformation * @see ReactiveX operators documentation: FlatMap */ @@ -8579,10 +8591,10 @@ public final Observable flatMap(@NonNull Function * *
@@ -8590,17 +8602,17 @@ public final Observable flatMap(@NonNull Function{@code flatMap} does not operate by default on a particular {@link Scheduler}. *
* - * @param the value type of the inner ObservableSources and the output type + * @param the value type of the inner {@code ObservableSource}s and the output type * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @param delayErrors - * if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate - * if false, the first one signalling an exception will terminate the whole sequence immediately - * @return an Observable that emits the result of applying the transformation function to each item emitted - * by the source ObservableSource and merging the results of the ObservableSources obtained from this + * if {@code true}, exceptions from the current {@code Observable} and all inner {@code ObservableSource}s are delayed until all of them terminate + * if {@code false}, the first one signaling an exception will terminate the whole sequence immediately + * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted + * by the current {@code Observable} and merging the results of the {@code ObservableSource}s obtained from this * transformation * @see ReactiveX operators documentation: FlatMap * @since 2.0 @@ -8613,10 +8625,10 @@ public final Observable flatMap(@NonNull Function * *
@@ -8624,19 +8636,19 @@ public final Observable flatMap(@NonNull Function{@code flatMap} does not operate by default on a particular {@link Scheduler}. *
* - * @param the value type of the inner ObservableSources and the output type + * @param the value type of the inner {@code ObservableSource}s and the output type * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @param delayErrors - * if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate - * if false, the first one signalling an exception will terminate the whole sequence immediately + * if {@code true}, exceptions from the current {@code Observable} and all inner {@code ObservableSource}s are delayed until all of them terminate + * if {@code false}, the first one signaling an exception will terminate the whole sequence immediately * @param bufferSize - * the number of elements to prefetch from each inner ObservableSource - * @return an Observable that emits the result of applying the transformation function to each item emitted - * by the source ObservableSource and merging the results of the ObservableSources obtained from this + * the number of elements to prefetch from each inner {@code ObservableSource} + * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted + * by the current {@code Observable} and merging the results of the {@code ObservableSource}s obtained from this * transformation * @see ReactiveX operators documentation: FlatMap * @since 2.0 @@ -8661,8 +8673,8 @@ public final Observable flatMap(@NonNull Function * *
@@ -8673,15 +8685,15 @@ public final Observable flatMap(@NonNull Function * the result type * @param onNextMapper - * a function that returns an ObservableSource to merge for each item emitted by the source ObservableSource + * a function that returns an {@code ObservableSource} to merge for each item emitted by the current {@code Observable} * @param onErrorMapper - * a function that returns an ObservableSource to merge for an onError notification from the source - * ObservableSource + * a function that returns an {@code ObservableSource} to merge for an onError notification from the current + * {@code Observable} * @param onCompleteSupplier - * a function that returns an ObservableSource to merge for an onComplete notification from the source - * ObservableSource - * @return an Observable that emits the results of merging the ObservableSources returned from applying the - * specified functions to the emissions and notifications of the source ObservableSource + * a function that returns an {@code ObservableSource} to merge for an onComplete notification from the current + * {@code Observable} + * @return an {@code Observable} that emits the results of merging the {@code ObservableSource}s returned from applying the + * specified functions to the emissions and notifications of the current {@code Observable} * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -8698,9 +8710,9 @@ public final Observable flatMap( } /** - * Returns an Observable that applies a function to each item emitted or notification raised by the source - * ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items, - * while limiting the maximum number of concurrent subscriptions to these ObservableSources. + * Returns an {@code Observable} that applies a function to each item emitted or notification raised by the current + * {@code Observable} and then flattens the {@code ObservableSource}s returned from these functions and emits the resulting items, + * while limiting the maximum number of concurrent subscriptions to these {@code ObservableSource}s. *

* *

@@ -8711,17 +8723,17 @@ public final Observable flatMap( * @param * the result type * @param onNextMapper - * a function that returns an ObservableSource to merge for each item emitted by the source ObservableSource + * a function that returns an {@code ObservableSource} to merge for each item emitted by the current {@code Observable} * @param onErrorMapper - * a function that returns an ObservableSource to merge for an onError notification from the source - * ObservableSource + * a function that returns an {@code ObservableSource} to merge for an onError notification from the current + * {@code Observable} * @param onCompleteSupplier - * a function that returns an ObservableSource to merge for an onComplete notification from the source - * ObservableSource + * a function that returns an {@code ObservableSource} to merge for an onComplete notification from the current + * {@code Observable} * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently - * @return an Observable that emits the results of merging the ObservableSources returned from applying the - * specified functions to the emissions and notifications of the source ObservableSource + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently + * @return an {@code Observable} that emits the results of merging the {@code ObservableSource}s returned from applying the + * specified functions to the emissions and notifications of the current {@code Observable} * @see ReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8740,10 +8752,10 @@ public final Observable flatMap( } /** - * Returns an Observable that emits items based on applying a function that you supply to each item emitted - * by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting - * ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent - * subscriptions to these ObservableSources. + * Returns an {@code Observable} that emits items based on applying a function that you supply to each item emitted + * by the current {@code Observable}, where that function returns an {@code ObservableSource}, and then merging those resulting + * {@code ObservableSource}s and emitting the results of this merger, while limiting the maximum number of concurrent + * subscriptions to these {@code ObservableSource}s. *

* *

@@ -8751,14 +8763,14 @@ public final Observable flatMap( *
{@code flatMap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the value type of the inner ObservableSources and the output type + * @param the value type of the inner {@code ObservableSource}s and the output type * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently - * @return an Observable that emits the result of applying the transformation function to each item emitted - * by the source ObservableSource and merging the results of the ObservableSources obtained from this + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently + * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted + * by the current {@code Observable} and merging the results of the {@code ObservableSource}s obtained from this * transformation * @see ReactiveX operators documentation: FlatMap * @since 2.0 @@ -8771,8 +8783,8 @@ public final Observable flatMap(@NonNull Function * *
@@ -8781,16 +8793,16 @@ public final Observable flatMap(@NonNull Function * * @param - * the type of items emitted by the collection ObservableSource + * the type of items emitted by the collection {@code ObservableSource} * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param mapper - * a function that returns an ObservableSource for each item emitted by the source ObservableSource + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable} * @param resultSelector - * a function that combines one item emitted by each of the source and collection ObservableSources and - * returns an item to be emitted by the resulting ObservableSource - * @return an Observable that emits the results of applying a function to a pair of values emitted by the - * source ObservableSource and the collection ObservableSource + * a function that combines one item emitted by each of the source and collection {@code ObservableSource}s and + * returns an item to be emitted by the resulting {@code Observable} + * @return an {@code Observable} that emits the results of applying a function to a pair of values emitted by the + * current {@code Observable} and the inner {@code ObservableSource}s * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -8802,8 +8814,8 @@ public final Observable flatMap(@NonNull Function * *
@@ -8812,19 +8824,19 @@ public final Observable flatMap(@NonNull Function * * @param - * the type of items emitted by the collection ObservableSource + * the type of items emitted by the collection {@code ObservableSource} * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param mapper - * a function that returns an ObservableSource for each item emitted by the source ObservableSource + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable} * @param combiner - * a function that combines one item emitted by each of the source and collection ObservableSources and - * returns an item to be emitted by the resulting ObservableSource + * a function that combines one item emitted by each of the source and collection {@code ObservableSource}s and + * returns an item to be emitted by the resulting {@code Observable} * @param delayErrors - * if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate - * if false, the first one signalling an exception will terminate the whole sequence immediately - * @return an Observable that emits the results of applying a function to a pair of values emitted by the - * source ObservableSource and the collection ObservableSource + * if {@code true}, exceptions from the current {@code Observable} and all inner {@code ObservableSource}s are delayed until all of them terminate + * if {@code false}, the first one signaling an exception will terminate the whole sequence immediately + * @return an {@code Observable} that emits the results of applying a function to a pair of values emitted by the + * current {@code Observable} and the inner {@code ObservableSource}s * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -8836,9 +8848,9 @@ public final Observable flatMap(@NonNull Function * *
@@ -8847,21 +8859,21 @@ public final Observable flatMap(@NonNull Function * * @param - * the type of items emitted by the collection ObservableSource + * the type of items emitted by the collection {@code ObservableSource} * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param mapper - * a function that returns an ObservableSource for each item emitted by the source ObservableSource + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable} * @param combiner - * a function that combines one item emitted by each of the source and collection ObservableSources and - * returns an item to be emitted by the resulting ObservableSource + * a function that combines one item emitted by each of the source and collection {@code ObservableSource}s and + * returns an item to be emitted by the resulting {@code Observable} * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @param delayErrors - * if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate - * if false, the first one signalling an exception will terminate the whole sequence immediately - * @return an Observable that emits the results of applying a function to a pair of values emitted by the - * source ObservableSource and the collection ObservableSource + * if {@code true}, exceptions from the current {@code Observable} and all inner {@code ObservableSource}s are delayed until all of them terminate + * if {@code false}, the first one signaling an exception will terminate the whole sequence immediately + * @return an {@code Observable} that emits the results of applying a function to a pair of values emitted by the + * current {@code Observable} and the inner {@code ObservableSource} * @see ReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8874,9 +8886,9 @@ public final Observable flatMap(@NonNull Function * *
@@ -8885,23 +8897,23 @@ public final Observable flatMap(@NonNull Function * * @param - * the type of items emitted by the collection ObservableSource + * the type of items emitted by the collection {@code ObservableSource} * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param mapper - * a function that returns an ObservableSource for each item emitted by the source ObservableSource + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable} * @param combiner - * a function that combines one item emitted by each of the source and collection ObservableSources and - * returns an item to be emitted by the resulting ObservableSource + * a function that combines one item emitted by each of the source and collection {@code ObservableSource}s and + * returns an item to be emitted by the resulting {@code Observable} * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @param delayErrors - * if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate - * if false, the first one signalling an exception will terminate the whole sequence immediately + * if {@code true}, exceptions from the current {@code Observable} and all inner {@code ObservableSource}s are delayed until all of them terminate + * if {@code false}, the first one signaling an exception will terminate the whole sequence immediately * @param bufferSize - * the number of elements to prefetch from the inner ObservableSources. - * @return an Observable that emits the results of applying a function to a pair of values emitted by the - * source ObservableSource and the collection ObservableSource + * the number of elements to prefetch from the inner {@code ObservableSource}s. + * @return an {@code Observable} that emits the results of applying a function to a pair of values emitted by the + * current {@code Observable} and the inner {@code ObservableSource} * @see ReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8916,9 +8928,9 @@ public final Observable flatMap(@NonNull Function * *
@@ -8927,18 +8939,18 @@ public final Observable flatMap(@NonNull Function * * @param - * the type of items emitted by the collection ObservableSource + * the type of items emitted by the collection {@code ObservableSource} * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param mapper - * a function that returns an ObservableSource for each item emitted by the source ObservableSource + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable} * @param combiner - * a function that combines one item emitted by each of the source and collection ObservableSources and - * returns an item to be emitted by the resulting ObservableSource + * a function that combines one item emitted by each of the source and collection {@code ObservableSource}s and + * returns an item to be emitted by the resulting {@code Observable} * @param maxConcurrency - * the maximum number of ObservableSources that may be subscribed to concurrently - * @return an Observable that emits the results of applying a function to a pair of values emitted by the - * source ObservableSource and the collection ObservableSource + * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently + * @return an {@code Observable} that emits the results of applying a function to a pair of values emitted by the + * current {@code Observable} and the inner {@code ObservableSource}s * @see ReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8951,8 +8963,8 @@ public final Observable flatMap(@NonNull Function * *
@@ -8970,7 +8982,7 @@ public final Completable flatMapCompletable(@NonNull Function * @@ -8992,8 +9004,8 @@ public final Completable flatMapCompletable(@NonNull Function * *
@@ -9002,11 +9014,11 @@ public final Completable flatMapCompletable(@NonNull Function * * @param - * the type of item emitted by the resulting Iterable + * the type of item emitted by the resulting {@code Iterable} * @param mapper - * a function that returns an Iterable sequence of values for when given an item emitted by the - * source ObservableSource - * @return an Observable that emits the results of merging the items emitted by the source ObservableSource with + * a function that returns an {@code Iterable} sequence of values for when given an item emitted by the + * current {@code Observable} + * @return an {@code Observable} that emits the results of merging the items emitted by the current {@code Observable} with * the values in the Iterables corresponding to those items, as generated by {@code collectionSelector} * @see ReactiveX operators documentation: FlatMap */ @@ -9019,8 +9031,8 @@ public final Observable flatMapIterable(@NonNull Function * *
@@ -9033,13 +9045,13 @@ public final Observable flatMapIterable(@NonNull Function * the type of item emitted by the resulting Iterable * @param mapper - * a function that returns an Iterable sequence of values for each item emitted by the source - * ObservableSource + * a function that returns an Iterable sequence of values for each item emitted by the current + * {@code Observable} * @param resultSelector - * a function that returns an item based on the item emitted by the source ObservableSource and the + * a function that returns an item based on the item emitted by the current {@code Observable} and the * Iterable returned for that item by the {@code collectionSelector} - * @return an Observable that emits the items returned by {@code resultSelector} for each item in the source - * ObservableSource + * @return an {@code Observable} that emits the items returned by {@code resultSelector} for each item in the current + * {@code Observable} * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -9053,8 +9065,8 @@ public final Observable flatMapIterable(@NonNull Function * *
@@ -9063,7 +9075,7 @@ public final Observable flatMapIterable(@NonNull Function * @param the result value type * @param mapper the function that received each source value and transforms them into MaybeSources. - * @return the new Observable instance + * @return the new {@code Observable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -9073,8 +9085,8 @@ public final Observable flatMapMaybe(@NonNull Function * @@ -9086,7 +9098,7 @@ public final Observable flatMapMaybe(@NonNull Function Observable flatMapMaybe(@NonNull Function * *
@@ -9107,7 +9119,7 @@ public final Observable flatMapMaybe(@NonNull Function * @param the result value type * @param mapper the function that received each source value and transforms them into SingleSources. - * @return the new Observable instance + * @return the new {@code Observable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -9117,8 +9129,8 @@ public final Observable flatMapSingle(@NonNull Function * @@ -9130,7 +9142,7 @@ public final Observable flatMapSingle(@NonNull Function onNext) { *

* *

- * If the Observable emits an error, it is wrapped into an + * If the {@code Observable} emits an error, it is wrapped into an * {@link io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException} * and routed to the RxJavaPlugins.onError handler. *

@@ -9234,7 +9246,7 @@ public final Disposable forEachWhile(@NonNull Predicate onNext, @NonN * @param onError * {@link Consumer} to execute when an error is emitted. * @param onComplete - * {@link Action} to execute when completion is signalled. + * {@link Action} to execute when completion is signaled. * @return * a Disposable that allows disposing of an asynchronous sequence * @throws NullPointerException @@ -9286,7 +9298,7 @@ public final Disposable forEachWhile(@NonNull Predicate onNext, @NonN * @param * the key type * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a - * unique key value and each of which emits those items from the source ObservableSource that share that + * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy */ @@ -9327,10 +9339,10 @@ public final Observable> groupBy(@NonNull Function * the key type * @param delayError - * if true, the exception from the current Observable is delayed in each group until that specific group emitted - * the normal values; if false, the exception bypasses values in the groups and is reported immediately. + * if {@code true}, the exception from the current {@code Observable} is delayed in each group until that specific group emitted + * the normal values; if {@code false}, the exception bypasses values in the groups and is reported immediately. * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a - * unique key value and each of which emits those items from the source ObservableSource that share that + * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy */ @@ -9375,7 +9387,7 @@ public final Observable> groupBy(@NonNull Function * the element type * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a - * unique key value and each of which emits those items from the source ObservableSource that share that + * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy */ @@ -9420,10 +9432,10 @@ public final Observable> groupBy(@NonNull Functio * @param * the element type * @param delayError - * if true, the exception from the current Observable is delayed in each group until that specific group emitted - * the normal values; if false, the exception bypasses values in the groups and is reported immediately. + * if {@code true}, the exception from the current {@code Observable} is delayed in each group until that specific group emitted + * the normal values; if {@code false}, the exception bypasses values in the groups and is reported immediately. * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a - * unique key value and each of which emits those items from the source ObservableSource that share that + * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy */ @@ -9464,8 +9476,8 @@ public final Observable> groupBy(@NonNull Functio * @param valueSelector * a function that extracts the return element for each item * @param delayError - * if true, the exception from the current Observable is delayed in each group until that specific group emitted - * the normal values; if false, the exception bypasses values in the groups and is reported immediately. + * if {@code true}, the exception from the current {@code Observable} is delayed in each group until that specific group emitted + * the normal values; if {@code false}, the exception bypasses values in the groups and is reported immediately. * @param bufferSize * the hint for how many {@link GroupedObservable}s and element in each {@link GroupedObservable} should be buffered * @param @@ -9473,7 +9485,7 @@ public final Observable> groupBy(@NonNull Functio * @param * the element type * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a - * unique key value and each of which emits those items from the source ObservableSource that share that + * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy */ @@ -9491,10 +9503,10 @@ public final Observable> groupBy(@NonNull Functio } /** - * Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results. + * Returns an {@code Observable} that correlates two {@code ObservableSource}s when they overlap in time and groups the results. *

* There are no guarantees in what order the items get combined when multiple - * items from one or both source ObservableSources overlap. + * items from one or both source {@code ObservableSource}s overlap. *

* *

@@ -9502,22 +9514,22 @@ public final Observable> groupBy(@NonNull Functio *
{@code groupJoin} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the value type of the right ObservableSource source - * @param the element type of the left duration ObservableSources - * @param the element type of the right duration ObservableSources + * @param the value type of the right {@code ObservableSource} source + * @param the element type of the left duration {@code ObservableSource}s + * @param the element type of the right duration {@code ObservableSource}s * @param the result type * @param other - * the other ObservableSource to correlate items from the source ObservableSource with + * the other {@code ObservableSource} to correlate items from the current {@code Observable} with * @param leftEnd - * a function that returns an ObservableSource whose emissions indicate the duration of the values of - * the source ObservableSource + * a function that returns an {@code ObservableSource} whose emissions indicate the duration of the values of + * the current {@code Observable} * @param rightEnd - * a function that returns an ObservableSource whose emissions indicate the duration of the values of - * the {@code right} ObservableSource + * a function that returns an {@code ObservableSource} whose emissions indicate the duration of the values of + * the {@code right} {@code ObservableSource} * @param resultSelector - * a function that takes an item emitted by each ObservableSource and returns the value to be emitted - * by the resulting ObservableSource - * @return an Observable that emits items based on combining those items emitted by the source ObservableSources + * a function that takes an item emitted by each {@code ObservableSource} and returns the value to be emitted + * by the resulting {@code Observable} + * @return an {@code Observable} that emits items based on combining those items emitted by the current {@code Observable}s * whose durations overlap * @see ReactiveX operators documentation: Join */ @@ -9539,7 +9551,7 @@ public final Observable groupJoin( } /** - * Hides the identity of this Observable and its Disposable. + * Hides the identity of this {@code Observable} and its Disposable. *

Allows hiding extra features such as {@link io.reactivex.rxjava3.subjects.Subject}'s * {@link Observer} methods or preventing certain identity-based * optimizations (fusion). @@ -9549,7 +9561,7 @@ public final Observable groupJoin( *

Scheduler:
*
{@code hide} does not operate by default on a particular {@link Scheduler}.
*
- * @return the new Observable instance + * @return the new {@code Observable} instance * * @since 2.0 */ @@ -9561,7 +9573,7 @@ public final Observable hide() { } /** - * Ignores all items emitted by the source ObservableSource and only calls {@code onComplete} or {@code onError}. + * Ignores all items emitted by the current {@code Observable} and only calls {@code onComplete} or {@code onError}. *

* *

@@ -9580,9 +9592,9 @@ public final Completable ignoreElements() { } /** - * Returns a Single that emits {@code true} if the source ObservableSource is empty, otherwise {@code false}. + * Returns a Single that emits {@code true} if the current {@code Observable} is empty, otherwise {@code false}. *

- * In Rx.Net this is negated as the {@code any} Observer but we renamed this in RxJava to better match Java + * In Rx.Net this is negated as the {@code any} {@code Observer} but we renamed this in RxJava to better match Java * naming idioms. *

* @@ -9602,10 +9614,10 @@ public final Single isEmpty() { } /** - * Correlates the items emitted by two ObservableSources based on overlapping durations. + * Correlates the items emitted by two {@code ObservableSource}s based on overlapping durations. *

* There are no guarantees in what order the items get combined when multiple - * items from one or both source ObservableSources overlap. + * items from one or both source {@code ObservableSource}s overlap. *

* *

@@ -9613,22 +9625,22 @@ public final Single isEmpty() { *
{@code join} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the value type of the right ObservableSource source - * @param the element type of the left duration ObservableSources - * @param the element type of the right duration ObservableSources + * @param the value type of the right {@code ObservableSource} source + * @param the element type of the left duration {@code ObservableSource}s + * @param the element type of the right duration {@code ObservableSource}s * @param the result type * @param other - * the second ObservableSource to join items from + * the second {@code ObservableSource} to join items from * @param leftEnd - * a function to select a duration for each item emitted by the source ObservableSource, used to + * a function to select a duration for each item emitted by the current {@code Observable}, used to * determine overlap * @param rightEnd - * a function to select a duration for each item emitted by the {@code right} ObservableSource, used to + * a function to select a duration for each item emitted by the {@code right} {@code ObservableSource}, used to * determine overlap * @param resultSelector - * a function that computes an item to be emitted by the resulting ObservableSource for any two - * overlapping items emitted by the two ObservableSources - * @return an Observable that emits items correlating to items emitted by the source ObservableSources that have + * a function that computes an item to be emitted by the resulting {@code Observable} for any two + * overlapping items emitted by the two {@code ObservableSource}s + * @return an {@code Observable} that emits items correlating to items emitted by the current {@code Observable}s that have * overlapping durations * @see ReactiveX operators documentation: Join */ @@ -9650,8 +9662,8 @@ public final Observable join( } /** - * Returns a Maybe that emits the last item emitted by this Observable or - * completes if this Observable is empty. + * Returns a Maybe that emits the last item emitted by this {@code Observable} or + * completes if this {@code Observable} is empty. *

* *

@@ -9659,7 +9671,7 @@ public final Observable join( *
{@code lastElement} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a Maybe that emits the last item from the source ObservableSource or notifies observers of an + * @return a Maybe that emits the last item from the current {@code Observable} or notifies observers of an * error * @see ReactiveX operators documentation: Last */ @@ -9671,8 +9683,8 @@ public final Maybe lastElement() { } /** - * Returns a Single that emits only the last item emitted by this Observable, or a default item - * if this Observable completes without emitting any items. + * Returns a Single that emits only the last item emitted by this {@code Observable}, or a default item + * if this {@code Observable} completes without emitting any items. *

* *

@@ -9681,9 +9693,9 @@ public final Maybe lastElement() { *
* * @param defaultItem - * the default item to emit if the source ObservableSource is empty - * @return a Single that emits only the last item emitted by the source ObservableSource, or a default item - * if the source ObservableSource is empty + * the default item to emit if the current {@code Observable} is empty + * @return a Single that emits only the last item emitted by the current {@code Observable}, or a default item + * if the current {@code Observable} is empty * @see ReactiveX operators documentation: Last */ @CheckReturnValue @@ -9695,8 +9707,8 @@ public final Single last(@NonNull T defaultItem) { } /** - * Returns a Single that emits only the last item emitted by this Observable or - * signals a {@link NoSuchElementException} if this Observable is empty. + * Returns a Single that emits only the last item emitted by this {@code Observable} or + * signals a {@link NoSuchElementException} if this {@code Observable} is empty. *

* *

@@ -9704,8 +9716,8 @@ public final Single last(@NonNull T defaultItem) { *
{@code lastOrError} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a Single that emits only the last item emitted by the source ObservableSource. - * If the source ObservableSource completes without emitting any items a {@link NoSuchElementException} will be thrown. + * @return a Single that emits only the last item emitted by the current {@code Observable}. + * If the current {@code Observable} completes without emitting any items a {@link NoSuchElementException} will be thrown. * @see ReactiveX operators documentation: Last */ @CheckReturnValue @@ -9838,7 +9850,7 @@ public final Single lastOrError() { *

* Note also that it is not possible to stop the subscription phase in {@code lift()} as the {@code apply()} method * requires a non-null {@code Observer} instance to be returned, which is then unconditionally subscribed to - * the upstream {@code Observable}. For example, if the operator decided there is no reason to subscribe to the + * the current {@code Observable}. For example, if the operator decided there is no reason to subscribe to the * upstream source because of some optimization possibility or a failure to prepare the operator, it still has to * return an {@code Observer} that should immediately dispose the upstream's {@code Disposable} in its * {@code onSubscribe} method. Again, using an {@code ObservableTransformer} and extending the {@code Observable} is @@ -9853,7 +9865,7 @@ public final Single lastOrError() { * @param lifter the {@link ObservableOperator} that receives the downstream's {@code Observer} and should return * an {@code Observer} with custom behavior to be used as the consumer for the current * {@code Observable}. - * @return the new Observable instance + * @return the new {@code Observable} instance * @see RxJava wiki: Writing operators * @see #compose(ObservableTransformer) */ @@ -9866,7 +9878,7 @@ public final Observable lift(@NonNull ObservableOperator * @@ -9877,8 +9889,8 @@ public final Observable lift(@NonNull ObservableOperator the output type * @param mapper - * a function to apply to each item emitted by the ObservableSource - * @return an Observable that emits the items from the source ObservableSource, transformed by the specified + * a function to apply to each item emitted by the {@code ObservableSource} + * @return an {@code Observable} that emits the items from the current {@code Observable}, transformed by the specified * function * @see ReactiveX operators documentation: Map */ @@ -9891,8 +9903,8 @@ public final Observable map(@NonNull Function map } /** - * Returns an Observable that represents all of the emissions and notifications from the source - * ObservableSource into emissions marked with their original types within {@link Notification} objects. + * Returns an {@code Observable} that represents all of the emissions and notifications from the current + * {@code Observable} into emissions marked with their original types within {@link Notification} objects. *

* *

@@ -9900,8 +9912,8 @@ public final Observable map(@NonNull Function map *
{@code materialize} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an Observable that emits items that are the result of materializing the items and notifications - * of the source ObservableSource + * @return an {@code Observable} that emits items that are the result of materializing the items and notifications + * of the current {@code Observable} * @see ReactiveX operators documentation: Materialize * @see #dematerialize(Function) */ @@ -9913,11 +9925,11 @@ public final Observable> materialize() { } /** - * Flattens this and another ObservableSource into a single ObservableSource, without any transformation. + * Flattens this and another {@code ObservableSource} into a single {@code ObservableSource}, without any transformation. *

* *

- * You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by + * You can combine items emitted by multiple {@code ObservableSource}s so that they appear as a single {@code ObservableSource}, by * using the {@code mergeWith} method. *

*
Scheduler:
@@ -9925,8 +9937,8 @@ public final Observable> materialize() { *
* * @param other - * an ObservableSource to be merged - * @return an Observable that emits all of the items emitted by the source ObservableSources + * an {@code ObservableSource} to be merged + * @return an {@code Observable} that emits all of the items emitted by the current {@code Observable}s * @see ReactiveX operators documentation: Merge */ @CheckReturnValue @@ -9938,7 +9950,7 @@ public final Observable mergeWith(@NonNull ObservableSource othe } /** - * Merges the sequence of items of this Observable with the success value of the other SingleSource. + * Merges the sequence of items of this {@code Observable} with the success value of the other SingleSource. *

* *

@@ -9950,7 +9962,7 @@ public final Observable mergeWith(@NonNull ObservableSource othe *

*

History: 2.1.10 - experimental * @param other the {@code SingleSource} whose success value to merge with - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 2.2 */ @CheckReturnValue @@ -9962,7 +9974,7 @@ public final Observable mergeWith(@NonNull SingleSource other) { } /** - * Merges the sequence of items of this Observable with the success value of the other MaybeSource + * Merges the sequence of items of this {@code Observable} with the success value of the other MaybeSource * or waits both to complete normally if the MaybeSource is empty. *

* @@ -9975,7 +9987,7 @@ public final Observable mergeWith(@NonNull SingleSource other) { *

*

History: 2.1.10 - experimental * @param other the {@code MaybeSource} which provides a success value to merge with or completes - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 2.2 */ @CheckReturnValue @@ -9987,7 +9999,7 @@ public final Observable mergeWith(@NonNull MaybeSource other) { } /** - * Relays the items of this Observable and completes only when the other CompletableSource completes + * Relays the items of this {@code Observable} and completes only when the other CompletableSource completes * as well. *

* @@ -9997,7 +10009,7 @@ public final Observable mergeWith(@NonNull MaybeSource other) { *

*

History: 2.1.10 - experimental * @param other the {@code CompletableSource} to await for completion - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 2.2 */ @CheckReturnValue @@ -10009,7 +10021,7 @@ public final Observable mergeWith(@NonNull CompletableSource other) { } /** - * Modifies an ObservableSource to perform its emissions and notifications on a specified {@link Scheduler}, + * Modifies an {@code ObservableSource} to perform its emissions and notifications on a specified {@link Scheduler}, * asynchronously with an unbounded buffer with {@link Flowable#bufferSize()} "island size". * *

Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly @@ -10030,7 +10042,7 @@ public final Observable mergeWith(@NonNull CompletableSource other) { * * @param scheduler * the {@link Scheduler} to notify {@link Observer}s on - * @return the source ObservableSource modified so that its {@link Observer}s are notified on the specified + * @return the current {@code Observable} modified so that its {@link Observer}s are notified on the specified * {@link Scheduler} * @see ReactiveX operators documentation: ObserveOn * @see RxJava Threading Examples @@ -10047,7 +10059,7 @@ public final Observable observeOn(@NonNull Scheduler scheduler) { } /** - * Modifies an ObservableSource to perform its emissions and notifications on a specified {@link Scheduler}, + * Modifies an {@code ObservableSource} to perform its emissions and notifications on a specified {@link Scheduler}, * asynchronously with an unbounded buffer with {@link Flowable#bufferSize()} "island size" and optionally delays onError notifications. *

* @@ -10069,7 +10081,7 @@ public final Observable observeOn(@NonNull Scheduler scheduler) { * indicates if the onError notification may not cut ahead of onNext notification on the other side of the * scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received * from upstream - * @return the source ObservableSource modified so that its {@link Observer}s are notified on the specified + * @return the current {@code Observable} modified so that its {@link Observer}s are notified on the specified * {@link Scheduler} * @see ReactiveX operators documentation: ObserveOn * @see RxJava Threading Examples @@ -10086,7 +10098,7 @@ public final Observable observeOn(@NonNull Scheduler scheduler, boolean delay } /** - * Modifies an ObservableSource to perform its emissions and notifications on a specified {@link Scheduler}, + * Modifies an {@code ObservableSource} to perform its emissions and notifications on a specified {@link Scheduler}, * asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications. *

* @@ -10109,7 +10121,7 @@ public final Observable observeOn(@NonNull Scheduler scheduler, boolean delay * scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received * from upstream * @param bufferSize the size of the buffer. - * @return the source ObservableSource modified so that its {@link Observer}s are notified on the specified + * @return the current {@code Observable} modified so that its {@link Observer}s are notified on the specified * {@link Scheduler} * @see ReactiveX operators documentation: ObserveOn * @see RxJava Threading Examples @@ -10128,7 +10140,7 @@ public final Observable observeOn(@NonNull Scheduler scheduler, boolean delay } /** - * Filters the items emitted by an ObservableSource, only emitting those of the specified type. + * Filters the items emitted by an {@code ObservableSource}, only emitting those of the specified type. *

* *

@@ -10138,8 +10150,8 @@ public final Observable observeOn(@NonNull Scheduler scheduler, boolean delay * * @param the output type * @param clazz - * the class type to filter the items emitted by the source ObservableSource - * @return an Observable that emits items from the source ObservableSource of type {@code clazz} + * the class type to filter the items emitted by the current {@code Observable} + * @return an {@code Observable} that emits items from the current {@code Observable} of type {@code clazz} * @see ReactiveX operators documentation: Filter */ @CheckReturnValue @@ -10151,19 +10163,19 @@ public final Observable ofType(@NonNull Class clazz) { } /** - * Instructs an ObservableSource to pass control to another ObservableSource rather than invoking + * Instructs an {@code ObservableSource} to pass control to another {@code ObservableSource} rather than invoking * {@link Observer#onError onError} if it encounters an error. *

* *

- * By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to - * its {@link Observer}, the ObservableSource invokes its Observer's {@code onError} method, and then quits + * By default, when an {@code ObservableSource} encounters an error that prevents it from emitting the expected item to + * its {@link Observer}, the {@code ObservableSource} invokes its Observer's {@code onError} method, and then quits * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this - * behavior. If you pass a function that returns an ObservableSource ({@code resumeFunction}) to - * {@code onErrorResumeNext}, if the original ObservableSource encounters an error, instead of invoking its - * Observer's {@code onError} method, it will instead relinquish control to the ObservableSource returned from + * behavior. If you pass a function that returns an {@code ObservableSource} ({@code resumeFunction}) to + * {@code onErrorResumeNext}, if the original {@code ObservableSource} encounters an error, instead of invoking its + * Observer's {@code onError} method, it will instead relinquish control to the {@code ObservableSource} returned from * {@code resumeFunction}, which will invoke the Observer's {@link Observer#onNext onNext} method if it is - * able to do so. In such a case, because no ObservableSource necessarily invokes {@code onError}, the Observer + * able to do so. In such a case, because no {@code ObservableSource} necessarily invokes {@code onError}, the Observer * may never know that an error happened. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be @@ -10174,9 +10186,9 @@ public final Observable ofType(@NonNull Class clazz) { *

* * @param resumeFunction - * a function that returns an ObservableSource that will take over if the source ObservableSource encounters + * a function that returns an {@code ObservableSource} that will take over if the current {@code Observable} encounters * an error - * @return the original ObservableSource, with appropriately modified behavior + * @return the original {@code ObservableSource}, with appropriately modified behavior * @see ReactiveX operators documentation: Catch */ @CheckReturnValue @@ -10188,19 +10200,19 @@ public final Observable onErrorResumeNext(@NonNull Function * *

- * By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to - * its {@link Observer}, the ObservableSource invokes its Observer's {@code onError} method, and then quits + * By default, when an {@code ObservableSource} encounters an error that prevents it from emitting the expected item to + * its {@link Observer}, the {@code ObservableSource} invokes its Observer's {@code onError} method, and then quits * without invoking any more of its Observer's methods. The {@code onErrorResumeWith} method changes this - * behavior. If you pass another ObservableSource ({@code next}) to an ObservableSource's - * {@code onErrorResumeWith} method, if the original ObservableSource encounters an error, instead of invoking its + * behavior. If you pass another {@code ObservableSource} ({@code next}) to an {@code ObservableSource}'s + * {@code onErrorResumeWith} method, if the original {@code ObservableSource} encounters an error, instead of invoking its * Observer's {@code onError} method, it will instead relinquish control to {@code next} which * will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case, - * because no ObservableSource necessarily invokes {@code onError}, the Observer may never know that an error + * because no {@code ObservableSource} necessarily invokes {@code onError}, the {@code Observer} may never know that an error * happened. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be @@ -10211,9 +10223,9 @@ public final Observable onErrorResumeNext(@NonNull Function * * @param next - * the next ObservableSource source that will take over if the source ObservableSource encounters + * the next {@code ObservableSource} source that will take over if the current {@code Observable} encounters * an error - * @return the original ObservableSource, with appropriately modified behavior + * @return the original {@code ObservableSource}, with appropriately modified behavior * @see ReactiveX operators documentation: Catch */ @CheckReturnValue @@ -10225,16 +10237,16 @@ public final Observable onErrorResumeWith(@NonNull ObservableSource * *

- * By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to - * its {@link Observer}, the ObservableSource invokes its Observer's {@code onError} method, and then quits + * By default, when an {@code ObservableSource} encounters an error that prevents it from emitting the expected item to + * its {@link Observer}, the {@code ObservableSource} invokes its Observer's {@code onError} method, and then quits * without invoking any more of its Observer's methods. The {@code onErrorReturn} method changes this - * behavior. If you pass a function ({@code resumeFunction}) to an ObservableSource's {@code onErrorReturn} - * method, if the original ObservableSource encounters an error, instead of invoking its Observer's + * behavior. If you pass a function ({@code resumeFunction}) to an {@code ObservableSource}'s {@code onErrorReturn} + * method, if the original {@code ObservableSource} encounters an error, instead of invoking its Observer's * {@code onError} method, it will instead emit the return value of {@code resumeFunction}. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be @@ -10246,8 +10258,8 @@ public final Observable onErrorResumeWith(@NonNull ObservableSourceReactiveX operators documentation: Catch */ @CheckReturnValue @@ -10259,16 +10271,16 @@ public final Observable onErrorReturn(@NonNull Function * *

- * By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to - * its {@link Observer}, the ObservableSource invokes its Observer's {@code onError} method, and then quits + * By default, when an {@code ObservableSource} encounters an error that prevents it from emitting the expected item to + * its {@link Observer}, the {@code ObservableSource} invokes its Observer's {@code onError} method, and then quits * without invoking any more of its Observer's methods. The {@code onErrorReturn} method changes this - * behavior. If you pass a function ({@code resumeFunction}) to an ObservableSource's {@code onErrorReturn} - * method, if the original ObservableSource encounters an error, instead of invoking its Observer's + * behavior. If you pass a function ({@code resumeFunction}) to an {@code ObservableSource}'s {@code onErrorReturn} + * method, if the original {@code ObservableSource} encounters an error, instead of invoking its Observer's * {@code onError} method, it will instead emit the return value of {@code resumeFunction}. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be @@ -10280,8 +10292,8 @@ public final Observable onErrorReturn(@NonNull FunctionReactiveX operators documentation: Catch */ @CheckReturnValue @@ -10293,7 +10305,7 @@ public final Observable onErrorReturnItem(@NonNull T item) { } /** - * Nulls out references to the upstream producer and downstream Observer if + * Nulls out references to the upstream producer and downstream {@code Observer} if * the sequence is terminated or downstream calls dispose(). *

* @@ -10301,7 +10313,7 @@ public final Observable onErrorReturnItem(@NonNull T item) { *

Scheduler:
*
{@code onTerminateDetach} does not operate by default on a particular {@link Scheduler}.
*
- * @return an Observable which nulls out references to the upstream producer and downstream Observer if + * @return an {@code Observable} which nulls out references to the upstream producer and downstream {@code Observer} if * the sequence is terminated or downstream calls dispose() * @since 2.0 */ @@ -10313,7 +10325,7 @@ public final Observable onTerminateDetach() { } /** - * Returns a {@link ConnectableObservable}, which is a variety of ObservableSource that waits until its + * Returns a {@link ConnectableObservable}, which is a variety of {@code ObservableSource} that waits until its * {@link ConnectableObservable#connect connect} method is called before it begins emitting items to those * {@link Observer}s that have subscribed to it. *

@@ -10323,7 +10335,7 @@ public final Observable onTerminateDetach() { *

{@code publish} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a {@link ConnectableObservable} that upon connection causes the source ObservableSource to emit items + * @return a {@link ConnectableObservable} that upon connection causes the current {@code Observable} to emit items * to its {@link Observer}s * @see ReactiveX operators documentation: Publish */ @@ -10335,7 +10347,7 @@ public final ConnectableObservable publish() { } /** - * Returns an Observable that emits the results of invoking a specified selector on items emitted by a + * Returns an {@code Observable} that emits the results of invoking a specified selector on items emitted by a * {@link ConnectableObservable} that shares a single subscription to the underlying sequence. *

* @@ -10345,12 +10357,12 @@ public final ConnectableObservable publish() { *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * a function that can use the multicasted source sequence as many times as needed, without - * causing multiple subscriptions to the source sequence. Observers to the given source will + * causing multiple subscriptions to the source sequence. {@code Observer}s to the given source will * receive all notifications of the source from the time of the subscription forward. - * @return an Observable that emits the results of invoking the selector on the items emitted by a {@link ConnectableObservable} that shares a single subscription to the underlying sequence + * @return an {@code Observable} that emits the results of invoking the selector on the items emitted by a {@link ConnectableObservable} that shares a single subscription to the underlying sequence * @see ReactiveX operators documentation: Publish */ @CheckReturnValue @@ -10362,9 +10374,9 @@ public final Observable publish(@NonNull Function, } /** - * Returns a Maybe that applies a specified accumulator function to the first item emitted by a source - * ObservableSource, then feeds the result of that function along with the second item emitted by the source - * ObservableSource into the same function, and so on until all items have been emitted by the finite source ObservableSource, + * Returns a Maybe that applies a specified accumulator function to the first item emitted by the current + * {@code Observable}, then feeds the result of that function along with the second item emitted by the current + * {@code Observable} into the same function, and so on until all items have been emitted by the finite source {@code ObservableSource}, * and emits the final result from the final call to your function as its sole item. *

* @@ -10382,10 +10394,10 @@ public final Observable publish(@NonNull Function, *

* * @param reducer - * an accumulator function to be invoked on each item emitted by the source ObservableSource, whose + * an accumulator function to be invoked on each item emitted by the current {@code Observable}, whose * result will be used in the next accumulator call * @return a Maybe that emits a single item that is the result of accumulating the items emitted by - * the source ObservableSource + * the current {@code Observable} * @see ReactiveX operators documentation: Reduce * @see Wikipedia: Fold (higher-order function) */ @@ -10398,10 +10410,10 @@ public final Maybe reduce(@NonNull BiFunction reducer) { } /** - * Returns a Single that applies a specified accumulator function to the first item emitted by a source - * ObservableSource and a specified seed value, then feeds the result of that function along with the second item - * emitted by an ObservableSource into the same function, and so on until all items have been emitted by the - * finite source ObservableSource, emitting the final result from the final call to your function as its sole item. + * Returns a {@link Single} that applies a specified accumulator function to the first item emitted by the current + * {@code Observable} and a specified seed value, then feeds the result of that function along with the second item + * emitted by the current {@code Observable} into the same function, and so on until all items have been emitted by the + * current and finite {@code Observable}, emitting the final result from the final call to your function as its sole item. *

* *

@@ -10409,7 +10421,7 @@ public final Maybe reduce(@NonNull BiFunction reducer) { * "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method * that does a similar operation on lists. *

- * Note that the {@code seed} is shared among all subscribers to the resulting ObservableSource + * Note that the {@code seed} is shared among all subscribers to the resulting {@code Observable} * and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer * the application of this operator via {@link #defer(Supplier)}: * 


@@ -10439,10 +10451,10 @@ public final Maybe reduce(@NonNull BiFunction reducer) {
      * @param seed
      *            the initial (seed) accumulator value
      * @param reducer
-     *            an accumulator function to be invoked on each item emitted by the source ObservableSource, the
+     *            an accumulator function to be invoked on each item emitted by the current {@code Observable}, the
      *            result of which will be used in the next accumulator call
      * @return a Single that emits a single item that is the result of accumulating the output from the
-     *         items emitted by the source ObservableSource
+     *         items emitted by the current {@code Observable}
      * @see ReactiveX operators documentation: Reduce
      * @see Wikipedia: Fold (higher-order function)
      * @see #reduceWith(Supplier, BiFunction)
@@ -10457,10 +10469,10 @@ public final Maybe reduce(@NonNull BiFunction reducer) {
     }
 
     /**
-     * Returns a Single that applies a specified accumulator function to the first item emitted by a source
-     * ObservableSource and a seed value derived from calling a specified seedSupplier, then feeds the result
-     * of that function along with the second item emitted by an ObservableSource into the same function,
-     * and so on until all items have been emitted by the finite source ObservableSource, emitting the final result
+     * Returns a Single that applies a specified accumulator function to the first item emitted by the current
+     * {@code Observable} and a seed value derived from calling a specified seedSupplier, then feeds the result
+     * of that function along with the second item emitted by the current {@code Observable} into the same function,
+     * and so on until all items have been emitted by the current and finite {@code Observable}, emitting the final result
      * from the final call to your function as its sole item.
      * 

      * 
@@ -10481,10 +10493,10 @@ public final Maybe reduce(@NonNull BiFunction reducer) {
      * @param seedSupplier
      *            the Supplier that provides the initial (seed) accumulator value for each individual Observer
      * @param reducer
-     *            an accumulator function to be invoked on each item emitted by the source ObservableSource, the
+     *            an accumulator function to be invoked on each item emitted by the current {@code Observable}, the
      *            result of which will be used in the next accumulator call
      * @return a Single that emits a single item that is the result of accumulating the output from the
-     *         items emitted by the source ObservableSource
+     *         items emitted by the current {@code Observable}
      * @see ReactiveX operators documentation: Reduce
      * @see Wikipedia: Fold (higher-order function)
      */
@@ -10498,7 +10510,7 @@ public final Maybe reduce(@NonNull BiFunction reducer) {
     }
 
     /**
-     * Returns an Observable that repeats the sequence of items emitted by the source ObservableSource indefinitely.
+     * Returns an {@code Observable} that repeats the sequence of items emitted by the current {@code Observable} indefinitely.
      * 

      * 
      * 

@@ -10506,7 +10518,7 @@ public final Maybe reduce(@NonNull BiFunction reducer) {
      *  
{@code repeat} does not operate by default on a particular {@link Scheduler}.

      * 

      *
-     * @return an Observable that emits the items emitted by the source ObservableSource repeatedly and in sequence
+     * @return an {@code Observable} that emits the items emitted by the current {@code Observable} repeatedly and in sequence
      * @see ReactiveX operators documentation: Repeat
      */
     @CheckReturnValue
@@ -10517,7 +10529,7 @@ public final Observable repeat() {
     }
 
     /**
-     * Returns an Observable that repeats the sequence of items emitted by the source ObservableSource at most
+     * Returns an {@code Observable} that repeats the sequence of items emitted by the current {@code Observable} at most
      * {@code count} times.
      * 

      * 
@@ -10527,9 +10539,9 @@ public final Observable repeat() {
      *
* * @param times - * the number of times the source ObservableSource items are repeated, a count of 0 will yield an empty + * the number of times the current {@code Observable} items are repeated, a count of 0 will yield an empty * sequence - * @return an Observable that repeats the sequence of items emitted by the source ObservableSource at most + * @return an {@code Observable} that repeats the sequence of items emitted by the current {@code Observable} at most * {@code count} times * @throws IllegalArgumentException * if {@code count} is less than zero @@ -10549,7 +10561,7 @@ public final Observable repeat(long times) { } /** - * Returns an Observable that repeats the sequence of items emitted by the source ObservableSource until + * Returns an {@code Observable} that repeats the sequence of items emitted by the current {@code Observable} until * the provided stop function returns true. *

* @@ -10559,10 +10571,10 @@ public final Observable repeat(long times) { *

* * @param stop - * a boolean supplier that is called when the current Observable completes; - * if it returns true, the returned Observable completes; if it returns false, - * the upstream Observable is resubscribed. - * @return the new Observable instance + * a boolean supplier that is called when the current {@code Observable} completes; + * if it returns {@code true}, the returned {@code Observable} completes; if it returns {@code false}, + * the current {@code Observable} is resubscribed. + * @return the new {@code Observable} instance * @throws NullPointerException * if {@code stop} is null * @see ReactiveX operators documentation: Repeat @@ -10576,12 +10588,12 @@ public final Observable repeatUntil(@NonNull BooleanSupplier stop) { } /** - * Returns an Observable that emits the same values as the source ObservableSource with the exception of an + * Returns an {@code Observable} that emits the same values as the current {@code Observable} with the exception of an * {@code onComplete}. An {@code onComplete} notification from the source will result in the emission of - * a {@code void} item to the ObservableSource provided as an argument to the {@code notificationHandler} - * function. If that ObservableSource calls {@code onComplete} or {@code onError} then {@code repeatWhen} will - * call {@code onComplete} or {@code onError} on the child subscription. Otherwise, this ObservableSource will - * resubscribe to the source ObservableSource. + * a {@code void} item to the {@code ObservableSource} provided as an argument to the {@code notificationHandler} + * function. If that {@code ObservableSource} calls {@code onComplete} or {@code onError} then {@code repeatWhen} will + * call {@code onComplete} or {@code onError} on the child subscription. Otherwise, the current {@code Observable} + * will be resubscribed. *

* *

@@ -10590,8 +10602,8 @@ public final Observable repeatUntil(@NonNull BooleanSupplier stop) { *
* * @param handler - * receives an ObservableSource of notifications with which a user can complete or error, aborting the repeat. - * @return the source ObservableSource modified with repeat logic + * receives an {@code ObservableSource} of notifications with which a user can complete or error, aborting the repeat. + * @return the current {@code Observable} modified with repeat logic * @see ReactiveX operators documentation: Repeat */ @CheckReturnValue @@ -10603,9 +10615,9 @@ public final Observable repeatWhen(@NonNull Function * @@ -10614,7 +10626,7 @@ public final Observable repeatWhen(@NonNull FunctionThis version of {@code replay} does not operate by default on a particular {@link Scheduler}. *
* - * @return a {@link ConnectableObservable} that upon connection causes the source ObservableSource to emit its + * @return a {@link ConnectableObservable} that upon connection causes the current {@code Observable} to emit its * items to its {@link Observer}s * @see ReactiveX operators documentation: Replay */ @@ -10626,8 +10638,8 @@ public final ConnectableObservable replay() { } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on the items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource. + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on the items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}. *

* *

@@ -10636,12 +10648,12 @@ public final ConnectableObservable replay() { *
* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * the selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource - * @return an Observable that emits items that are the results of invoking the selector on a - * {@link ConnectableObservable} that shares a single subscription to the source ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} + * @return an {@code Observable} that emits items that are the results of invoking the selector on a + * {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -10653,8 +10665,8 @@ public final Observable replay(@NonNull Function, ? } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying {@code bufferSize} notifications. *

* Note that due to concurrency requirements, {@code replay(bufferSize)} may hold strong references to more than @@ -10667,14 +10679,14 @@ public final Observable replay(@NonNull Function, ? *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * the selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} * @param bufferSize - * the buffer size that limits the number of items the connectable ObservableSource can replay - * @return an Observable that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource + * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay + * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by + * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} * replaying no more than {@code bufferSize} items * @see ReactiveX operators documentation: Replay * @see #replay(Function, int, boolean) @@ -10689,8 +10701,8 @@ public final Observable replay(@NonNull Function, ? } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying {@code bufferSize} notifications. *

* Note that due to concurrency requirements, {@code replay(bufferSize)} may hold strong references to more than @@ -10703,17 +10715,17 @@ public final Observable replay(@NonNull Function, ? *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * the selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} * @param bufferSize - * the buffer size that limits the number of items the connectable ObservableSource can replay + * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay * @param eagerTruncate - * if true, whenever the internal buffer is truncated to the given bufferSize, the + * if {@code true}, whenever the internal buffer is truncated to the given bufferSize, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention - * @return an Observable that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource + * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by + * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} * replaying no more than {@code bufferSize} items * @see ReactiveX operators documentation: Replay */ @@ -10727,8 +10739,8 @@ public final Observable replay(@NonNull Function, ? } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying no more than {@code bufferSize} items that were emitted within a specified time window. *

* Note that due to concurrency requirements, {@code replay(bufferSize)} may hold strong references to more than @@ -10741,18 +10753,18 @@ public final Observable replay(@NonNull Function, ? *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} * @param bufferSize - * the buffer size that limits the number of items the connectable ObservableSource can replay + * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} - * @return an Observable that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, and + * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by + * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, and * replays no more than {@code bufferSize} items that were emitted within the window defined by * {@code time} * @see ReactiveX operators documentation: Replay @@ -10765,8 +10777,8 @@ public final Observable replay(@NonNull Function, ? } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying no more than {@code bufferSize} items that were emitted within a specified time window. *

* Note that due to concurrency requirements, {@code replay(bufferSize)} may hold strong references to more than @@ -10779,20 +10791,20 @@ public final Observable replay(@NonNull Function, ? *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} * @param bufferSize - * the buffer size that limits the number of items the connectable ObservableSource can replay + * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @param scheduler * the Scheduler that is the time source for the window - * @return an Observable that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, and + * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by + * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, and * replays no more than {@code bufferSize} items that were emitted within the window defined by * {@code time} * @throws IllegalArgumentException @@ -10812,8 +10824,8 @@ public final Observable replay(@NonNull Function, ? ObservableInternalHelper.replaySupplier(this, bufferSize, time, unit, scheduler, false), selector); } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying no more than {@code bufferSize} items that were emitted within a specified time window. *

* Note that due to concurrency requirements, {@code replay(bufferSize)} may hold strong references to more than @@ -10826,12 +10838,12 @@ public final Observable replay(@NonNull Function, ? *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} * @param bufferSize - * the buffer size that limits the number of items the connectable ObservableSource can replay + * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay * @param time * the duration of the window in which the replayed items must have been emitted * @param unit @@ -10839,10 +10851,10 @@ public final Observable replay(@NonNull Function, ? * @param scheduler * the Scheduler that is the time source for the window * @param eagerTruncate - * if true, whenever the internal buffer is truncated to the given bufferSize/age, the + * if {@code true}, whenever the internal buffer is truncated to the given bufferSize/age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention - * @return an Observable that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, and + * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by + * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, and * replays no more than {@code bufferSize} items that were emitted within the window defined by * {@code time} * @throws IllegalArgumentException @@ -10862,8 +10874,8 @@ public final Observable replay(@NonNull Function, ? } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within a specified time window. *

* @@ -10873,16 +10885,16 @@ public final Observable replay(@NonNull Function, ? *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} - * @return an Observable that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by + * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within the window defined by {@code time} * @see ReactiveX operators documentation: Replay */ @@ -10894,8 +10906,8 @@ public final Observable replay(@NonNull Function, ? } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within a specified time window. *

* @@ -10905,18 +10917,18 @@ public final Observable replay(@NonNull Function, ? *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @param scheduler * the scheduler that is the time source for the window - * @return an Observable that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by + * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within the window defined by {@code time} * @see ReactiveX operators documentation: Replay * @see #replay(Function, long, TimeUnit, Scheduler, boolean) @@ -10932,8 +10944,8 @@ public final Observable replay(@NonNull Function, ? } /** - * Returns an Observable that emits items that are the results of invoking a specified selector on items - * emitted by a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items + * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within a specified time window. *

* @@ -10943,10 +10955,10 @@ public final Observable replay(@NonNull Function, ? *

* * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the ObservableSource + * causing multiple subscriptions to the {@code ObservableSource} * @param time * the duration of the window in which the replayed items must have been emitted * @param unit @@ -10954,10 +10966,10 @@ public final Observable replay(@NonNull Function, ? * @param scheduler * the scheduler that is the time source for the window * @param eagerTruncate - * if true, whenever the internal buffer is truncated to the given age, the + * if {@code true}, whenever the internal buffer is truncated to the given age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention - * @return an Observable that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource, + * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by + * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within the window defined by {@code time} * @see ReactiveX operators documentation: Replay */ @@ -10972,9 +10984,9 @@ public final Observable replay(@NonNull Function, ? } /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource that - * replays at most {@code bufferSize} items emitted by that ObservableSource. A Connectable ObservableSource resembles - * an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only + * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} that + * replays at most {@code bufferSize} items emitted by that ObservableSource. A Connectable {@code ObservableSource} resembles + * an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, but only * when its {@code connect} method is called. *

* @@ -10990,8 +11002,8 @@ public final Observable replay(@NonNull Function, ? * * @param bufferSize * the buffer size that limits the number of items that can be replayed - * @return a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and - * replays at most {@code bufferSize} items emitted by that ObservableSource + * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * replays at most {@code bufferSize} items emitted by that {@code ObservableSource} * @see ReactiveX operators documentation: Replay * @see #replay(int, boolean) */ @@ -11004,9 +11016,9 @@ public final ConnectableObservable replay(int bufferSize) { } /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource that - * replays at most {@code bufferSize} items emitted by that ObservableSource. A Connectable ObservableSource resembles - * an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only + * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} that + * replays at most {@code bufferSize} items emitted by that ObservableSource. A Connectable {@code ObservableSource} resembles + * an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, but only * when its {@code connect} method is called. *

* @@ -11022,10 +11034,10 @@ public final ConnectableObservable replay(int bufferSize) { * @param bufferSize * the buffer size that limits the number of items that can be replayed * @param eagerTruncate - * if true, whenever the internal buffer is truncated to the given bufferSize/age, the + * if {@code true}, whenever the internal buffer is truncated to the given bufferSize/age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention - * @return a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and - * replays at most {@code bufferSize} items emitted by that ObservableSource + * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * replays at most {@code bufferSize} items emitted by that {@code ObservableSource} * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -11037,9 +11049,9 @@ public final ConnectableObservable replay(int bufferSize, boolean eagerTrunca } /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays at most {@code bufferSize} items that were emitted during a specified time window. A Connectable - * ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is + * {@code ObservableSource} resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is * subscribed to, but only when its {@code connect} method is called. *

* @@ -11059,7 +11071,7 @@ public final ConnectableObservable replay(int bufferSize, boolean eagerTrunca * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} - * @return a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays at most {@code bufferSize} items that were emitted during the window defined by * {@code time} * @see ReactiveX operators documentation: Replay @@ -11073,9 +11085,9 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull } /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * that replays a maximum of {@code bufferSize} items that are emitted within a specified time window. A - * Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items + * Connectable {@code ObservableSource} resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items * when it is subscribed to, but only when its {@code connect} method is called. *

* Note that due to concurrency requirements, {@code replay(bufferSize)} may hold strong references to more than @@ -11097,7 +11109,7 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull * the time unit of {@code time} * @param scheduler * the scheduler that is used as a time source for the window - * @return a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays at most {@code bufferSize} items that were emitted during the window defined by * {@code time} * @throws IllegalArgumentException @@ -11116,9 +11128,9 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull } /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * that replays a maximum of {@code bufferSize} items that are emitted within a specified time window. A - * Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items + * Connectable {@code ObservableSource} resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items * when it is subscribed to, but only when its {@code connect} method is called. *

* @@ -11140,11 +11152,11 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull * the time unit of {@code time} * @param scheduler * the scheduler that is used as a time source for the window - * @return a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays at most {@code bufferSize} items that were emitted during the window defined by * {@code time} * @param eagerTruncate - * if true, whenever the internal buffer is truncated to the given bufferSize/age, the + * if {@code true}, whenever the internal buffer is truncated to the given bufferSize/age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention * @throws IllegalArgumentException * if {@code bufferSize} is less than zero @@ -11161,9 +11173,9 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull } /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and - * replays all items emitted by that ObservableSource within a specified time window. A Connectable ObservableSource - * resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, + * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * replays all items emitted by that {@code ObservableSource} within a specified time window. A Connectable {@code ObservableSource} + * resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, * but only when its {@code connect} method is called. *

* @@ -11176,7 +11188,7 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} - * @return a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays the items that were emitted during the window defined by {@code time} * @see ReactiveX operators documentation: Replay */ @@ -11188,9 +11200,9 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit) } /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and - * replays all items emitted by that ObservableSource within a specified time window. A Connectable ObservableSource - * resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, + * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * replays all items emitted by that {@code ObservableSource} within a specified time window. A Connectable {@code ObservableSource} + * resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, * but only when its {@code connect} method is called. *

* @@ -11208,7 +11220,7 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit) * the time unit of {@code time} * @param scheduler * the Scheduler that is the time source for the window - * @return a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays the items that were emitted during the window defined by {@code time} * @see ReactiveX operators documentation: Replay * @see #replay(long, TimeUnit, Scheduler, boolean) @@ -11223,9 +11235,9 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit, } /** - * Returns a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and - * replays all items emitted by that ObservableSource within a specified time window. A Connectable ObservableSource - * resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, + * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * replays all items emitted by that {@code ObservableSource} within a specified time window. A Connectable {@code ObservableSource} + * resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, * but only when its {@code connect} method is called. *

* @@ -11244,9 +11256,9 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit, * @param scheduler * the Scheduler that is the time source for the window * @param eagerTruncate - * if true, whenever the internal buffer is truncated to the given bufferSize/age, the + * if {@code true}, whenever the internal buffer is truncated to the given bufferSize/age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention - * @return a {@link ConnectableObservable} that shares a single subscription to the source ObservableSource and + * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays the items that were emitted during the window defined by {@code time} * @see ReactiveX operators documentation: Replay */ @@ -11260,16 +11272,16 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit, } /** - * Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls {@code onError} + * Returns an {@code Observable} that mirrors the current {@code Observable}, resubscribing to it if it calls {@code onError} * (infinite retry count). *

* *

- * If the source ObservableSource calls {@link Observer#onError}, this method will resubscribe to the source - * ObservableSource rather than propagating the {@code onError} call. + * If the current {@code Observable} calls {@link Observer#onError}, this method will resubscribe to the current + * {@code Observable} rather than propagating the {@code onError} call. *

- * Any and all items emitted by the source ObservableSource will be emitted by the resulting ObservableSource, even - * those emitted during failed subscriptions. For example, if an ObservableSource fails at first but emits + * Any and all items emitted by the current {@code Observable} will be emitted by the resulting {@code Observable}, even + * those emitted during failed subscriptions. For example, if an {@code ObservableSource} fails at first but emits * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onComplete]}. *

@@ -11277,7 +11289,7 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit, *
{@code retry} does not operate by default on a particular {@link Scheduler}.
*
* - * @return the source ObservableSource modified with retry logic + * @return the current {@code Observable} modified with retry logic * @see ReactiveX operators documentation: Retry */ @CheckReturnValue @@ -11288,7 +11300,7 @@ public final Observable retry() { } /** - * Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls {@code onError} + * Returns an {@code Observable} that mirrors the current {@code Observable}, resubscribing to it if it calls {@code onError} * and the predicate returns true for that specific exception and retry count. *

* @@ -11300,7 +11312,7 @@ public final Observable retry() { * @param predicate * the predicate that determines if a resubscription may happen in case of a specific exception * and retry count - * @return the source ObservableSource modified with retry logic + * @return the current {@code Observable} modified with retry logic * @see #retry() * @see ReactiveX operators documentation: Retry */ @@ -11314,17 +11326,17 @@ public final Observable retry(@NonNull BiPredicate * *

- * If the source ObservableSource calls {@link Observer#onError}, this method will resubscribe to the source - * ObservableSource for a maximum of {@code count} resubscriptions rather than propagating the + * If the current {@code Observable} calls {@link Observer#onError}, this method will resubscribe to the current + * {@code Observable} for a maximum of {@code count} resubscriptions rather than propagating the * {@code onError} call. *

- * Any and all items emitted by the source ObservableSource will be emitted by the resulting ObservableSource, even - * those emitted during failed subscriptions. For example, if an ObservableSource fails at first but emits + * Any and all items emitted by the current {@code Observable} will be emitted by the resulting {@code Observable}, even + * those emitted during failed subscriptions. For example, if an {@code ObservableSource} fails at first but emits * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onComplete]}. *

@@ -11333,8 +11345,8 @@ public final Observable retry(@NonNull BiPredicate * * @param times - * the number of times to resubscribe if the current Observable fails - * @return the source ObservableSource modified with retry logic + * the number of times to resubscribe if the current {@code Observable} fails + * @return the current {@code Observable} modified with retry logic * @see ReactiveX operators documentation: Retry */ @CheckReturnValue @@ -11345,16 +11357,16 @@ public final Observable retry(long times) { } /** - * Retries at most times or until the predicate returns false, whichever happens first. + * Retries at most times or until the predicate returns {@code false}, whichever happens first. *

* *

*
Scheduler:
*
{@code retry} does not operate by default on a particular {@link Scheduler}.
*
- * @param times the number of times to resubscribe if the current Observable fails + * @param times the number of times to resubscribe if the current {@code Observable} fails * @param predicate the predicate called with the failure Throwable and should return true to trigger a retry. - * @return the new Observable instance + * @return the new {@code Observable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -11369,7 +11381,7 @@ public final Observable retry(long times, @NonNull Predicate * *
@@ -11378,7 +11390,7 @@ public final Observable retry(long times, @NonNull Predicate * * @param predicate the predicate that receives the failure Throwable and should return true to trigger a retry. - * @return the new Observable instance + * @return the new {@code Observable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -11396,7 +11408,7 @@ public final Observable retry(@NonNull Predicate predicate *
{@code retryUntil} does not operate by default on a particular {@link Scheduler}.
*
* @param stop the function that should return true to stop retrying - * @return the new Observable instance + * @return the new {@code Observable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -11407,12 +11419,12 @@ public final Observable retryUntil(@NonNull BooleanSupplier stop) { } /** - * Returns an Observable that emits the same values as the source ObservableSource with the exception of an + * Returns an {@code Observable} that emits the same values as the current {@code Observable} with the exception of an * {@code onError}. An {@code onError} notification from the source will result in the emission of a - * {@link Throwable} item to the ObservableSource provided as an argument to the {@code notificationHandler} - * function. If that ObservableSource calls {@code onComplete} or {@code onError} then {@code retry} will call - * {@code onComplete} or {@code onError} on the child subscription. Otherwise, this ObservableSource will - * resubscribe to the source ObservableSource. + * {@link Throwable} item to the {@code ObservableSource} provided as an argument to the {@code notificationHandler} + * function. If that {@code ObservableSource} calls {@code onComplete} or {@code onError} then {@code retry} will call + * {@code onComplete} or {@code onError} on the child subscription. Otherwise, the current {@code Observable} + * will be resubscribed. *

* *

@@ -11447,7 +11459,7 @@ public final Observable retryUntil(@NonNull BooleanSupplier stop) { * Note that the inner {@code ObservableSource} returned by the handler function should signal * either {@code onNext}, {@code onError} or {@code onComplete} in response to the received * {@code Throwable} to indicate the operator should retry or terminate. If the upstream to - * the operator is asynchronous, signalling onNext followed by onComplete immediately may + * the operator is asynchronous, signaling onNext followed by onComplete immediately may * result in the sequence to be completed immediately. Similarly, if this inner * {@code ObservableSource} signals {@code onError} or {@code onComplete} while the upstream is * active, the sequence is terminated with the same signal immediately. @@ -11474,9 +11486,9 @@ public final Observable retryUntil(@NonNull BooleanSupplier stop) { *

* * @param handler - * receives an ObservableSource of notifications with which a user can complete or error, aborting the + * receives an {@code ObservableSource} of notifications with which a user can complete or error, aborting the * retry - * @return the source ObservableSource modified with retry logic + * @return the current {@code Observable} modified with retry logic * @see ReactiveX operators documentation: Retry */ @CheckReturnValue @@ -11489,15 +11501,15 @@ public final Observable retryWhen( } /** - * Subscribes to the current Observable and wraps the given Observer into a SafeObserver + * Subscribes to the current {@code Observable} and wraps the given {@code Observer} into a SafeObserver * (if not already a SafeObserver) that - * deals with exceptions thrown by a misbehaving Observer (that doesn't follow the + * deals with exceptions thrown by a misbehaving {@code Observer} (that doesn't follow the * Reactive-Streams specification). *
*
Scheduler:
*
{@code safeSubscribe} does not operate by default on a particular {@link Scheduler}.
*
- * @param observer the incoming Observer instance + * @param observer the incoming {@code Observer} instance * @throws NullPointerException if s is null */ @SchedulerSupport(SchedulerSupport.NONE) @@ -11512,7 +11524,7 @@ public final void safeSubscribe(@NonNull Observer observer) { } /** - * Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource + * Returns an {@code Observable} that emits the most recently emitted item (if any) emitted by the current {@code Observable} * within periodic time intervals. *

* @@ -11525,7 +11537,7 @@ public final void safeSubscribe(@NonNull Observer observer) { * the sampling rate * @param unit * the {@link TimeUnit} in which {@code period} is defined - * @return an Observable that emits the results of sampling the items emitted by the source ObservableSource at + * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} at * the specified time interval * @see ReactiveX operators documentation: Sample * @see #throttleLast(long, TimeUnit) @@ -11538,7 +11550,7 @@ public final Observable sample(long period, @NonNull TimeUnit unit) { } /** - * Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource + * Returns an {@code Observable} that emits the most recently emitted item (if any) emitted by the current {@code Observable} * within periodic time intervals and optionally emit the very last upstream item when the upstream completes. *

* @@ -11552,12 +11564,12 @@ public final Observable sample(long period, @NonNull TimeUnit unit) { * the sampling rate * @param unit * the {@link TimeUnit} in which {@code period} is defined - * @return an Observable that emits the results of sampling the items emitted by the source ObservableSource at + * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} at * the specified time interval * @param emitLast * if true and the upstream completes while there is still an unsampled item available, * that item is emitted to downstream before completion - * if false, an unsampled last item is ignored. + * if {@code false}, an unsampled last item is ignored. * @see ReactiveX operators documentation: Sample * @see #throttleLast(long, TimeUnit) * @since 2.1 @@ -11570,7 +11582,7 @@ public final Observable sample(long period, @NonNull TimeUnit unit, boolean e } /** - * Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource + * Returns an {@code Observable} that emits the most recently emitted item (if any) emitted by the current {@code Observable} * within periodic time intervals, where the intervals are defined on a particular Scheduler. *

* @@ -11585,7 +11597,7 @@ public final Observable sample(long period, @NonNull TimeUnit unit, boolean e * the {@link TimeUnit} in which {@code period} is defined * @param scheduler * the {@link Scheduler} to use when sampling - * @return an Observable that emits the results of sampling the items emitted by the source ObservableSource at + * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} at * the specified time interval * @see ReactiveX operators documentation: Sample * @see #throttleLast(long, TimeUnit, Scheduler) @@ -11600,7 +11612,7 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull } /** - * Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource + * Returns an {@code Observable} that emits the most recently emitted item (if any) emitted by the current {@code Observable} * within periodic time intervals, where the intervals are defined on a particular Scheduler * and optionally emit the very last upstream item when the upstream completes. *

@@ -11620,8 +11632,8 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull * @param emitLast * if true and the upstream completes while there is still an unsampled item available, * that item is emitted to downstream before completion - * if false, an unsampled last item is ignored. - * @return an Observable that emits the results of sampling the items emitted by the source ObservableSource at + * if {@code false}, an unsampled last item is ignored. + * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} at * the specified time interval * @see ReactiveX operators documentation: Sample * @see #throttleLast(long, TimeUnit, Scheduler) @@ -11637,8 +11649,8 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull } /** - * Returns an Observable that, when the specified {@code sampler} ObservableSource emits an item or completes, - * emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous + * Returns an {@code Observable} that, when the specified {@code sampler} {@code ObservableSource} emits an item or completes, + * emits the most recently emitted item (if any) emitted by the current {@code Observable} since the previous * emission from the {@code sampler} ObservableSource. *

* @@ -11647,11 +11659,11 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull *

This version of {@code sample} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the element type of the sampler ObservableSource + * @param the element type of the sampler {@code ObservableSource} * @param sampler - * the ObservableSource to use for sampling the source ObservableSource - * @return an Observable that emits the results of sampling the items emitted by this ObservableSource whenever - * the {@code sampler} ObservableSource emits an item or completes + * the {@code ObservableSource} to use for sampling the current {@code Observable} + * @return an {@code Observable} that emits the results of sampling the items emitted by this {@code ObservableSource} whenever + * the {@code sampler} {@code ObservableSource} emits an item or completes * @see ReactiveX operators documentation: Sample */ @CheckReturnValue @@ -11663,10 +11675,10 @@ public final Observable sample(@NonNull ObservableSource sampler) { } /** - * Returns an Observable that, when the specified {@code sampler} ObservableSource emits an item or completes, - * emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous - * emission from the {@code sampler} ObservableSource - * and optionally emit the very last upstream item when the upstream or other ObservableSource complete. + * Returns an {@code Observable} that, when the specified {@code sampler} {@code ObservableSource} emits an item or completes, + * emits the most recently emitted item (if any) emitted by the current {@code Observable} since the previous + * emission from the {@code sampler} {@code ObservableSource} + * and optionally emit the very last upstream item when the upstream or other {@code ObservableSource} complete. *

* *

@@ -11675,15 +11687,15 @@ public final Observable sample(@NonNull ObservableSource sampler) { *
* *

History: 2.0.5 - experimental - * @param the element type of the sampler ObservableSource + * @param the element type of the sampler {@code ObservableSource} * @param sampler - * the ObservableSource to use for sampling the source ObservableSource + * the {@code ObservableSource} to use for sampling the current {@code Observable} * @param emitLast * if true and the upstream completes while there is still an unsampled item available, * that item is emitted to downstream before completion - * if false, an unsampled last item is ignored. - * @return an Observable that emits the results of sampling the items emitted by this ObservableSource whenever - * the {@code sampler} ObservableSource emits an item or completes + * if {@code false}, an unsampled last item is ignored. + * @return an {@code Observable} that emits the results of sampling the items emitted by this {@code ObservableSource} whenever + * the {@code sampler} {@code ObservableSource} emits an item or completes * @see ReactiveX operators documentation: Sample * @since 2.1 */ @@ -11696,9 +11708,9 @@ public final Observable sample(@NonNull ObservableSource sampler, bool } /** - * Returns an Observable that applies a specified accumulator function to the first item emitted by a source - * ObservableSource, then feeds the result of that function along with the second item emitted by the source - * ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, + * Returns an {@code Observable} that applies a specified accumulator function to the first item emitted by the current + * {@code Observable}, then feeds the result of that function along with the second item emitted by the current + * {@code Observable} into the same function, and so on until all items have been emitted by the current {@code Observable}, * emitting the result of each of these iterations. *

* @@ -11710,10 +11722,10 @@ public final Observable sample(@NonNull ObservableSource sampler, bool *

* * @param accumulator - * an accumulator function to be invoked on each item emitted by the source ObservableSource, whose + * an accumulator function to be invoked on each item emitted by the current {@code Observable}, whose * result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the * next accumulator call - * @return an Observable that emits the results of each call to the accumulator function + * @return an {@code Observable} that emits the results of each call to the accumulator function * @see ReactiveX operators documentation: Scan */ @CheckReturnValue @@ -11725,19 +11737,19 @@ public final Observable scan(@NonNull BiFunction accumulator) { } /** - * Returns an Observable that applies a specified accumulator function to the first item emitted by a source - * ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by - * the source ObservableSource into the same function, and so on until all items have been emitted by the source - * ObservableSource, emitting the result of each of these iterations. + * Returns an {@code Observable} that applies a specified accumulator function to the first item emitted by the current + * {@code Observable} and a seed value, then feeds the result of that function along with the second item emitted by + * the current {@code Observable} into the same function, and so on until all items have been emitted by the current + * {@code Observable}, emitting the result of each of these iterations. *

* *

* This sort of function is sometimes called an accumulator. *

- * Note that the ObservableSource that results from this method will emit {@code initialValue} as its first + * Note that the {@code ObservableSource} that results from this method will emit {@code initialValue} as its first * emitted item. *

- * Note that the {@code initialValue} is shared among all subscribers to the resulting ObservableSource + * Note that the {@code initialValue} is shared among all subscribers to the resulting {@code Observable} * and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer * the application of this operator via {@link #defer(Supplier)}: * 


@@ -11759,10 +11771,10 @@ public final Observable scan(@NonNull BiFunction accumulator) {
      * @param initialValue
      *            the initial (seed) accumulator item
      * @param accumulator
-     *            an accumulator function to be invoked on each item emitted by the source ObservableSource, whose
+     *            an accumulator function to be invoked on each item emitted by the current {@code Observable}, whose
      *            result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the
      *            next accumulator call
-     * @return an Observable that emits {@code initialValue} followed by the results of each call to the
+     * @return an {@code Observable} that emits {@code initialValue} followed by the results of each call to the
      *         accumulator function
      * @see ReactiveX operators documentation: Scan
      */
@@ -11775,16 +11787,16 @@ public final  Observable scan(@NonNull R initialValue, @NonNull BiFunction
     }
 
     /**
-     * Returns an Observable that applies a specified accumulator function to the first item emitted by a source
-     * ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by
-     * the source ObservableSource into the same function, and so on until all items have been emitted by the source
-     * ObservableSource, emitting the result of each of these iterations.
+     * Returns an {@code Observable} that applies a specified accumulator function to the first item emitted by the current
+     * {@code Observable} and a seed value, then feeds the result of that function along with the second item emitted by
+     * the current {@code Observable} into the same function, and so on until all items have been emitted by the current
+     * {@code Observable}, emitting the result of each of these iterations.
      * 

      * 
      * 

      * This sort of function is sometimes called an accumulator.
      * 

-     * Note that the ObservableSource that results from this method will emit the value returned
+     * Note that the {@code ObservableSource} that results from this method will emit the value returned
      * by the {@code seedSupplier} as its first item.
      * 

      *  
Scheduler:

@@ -11795,10 +11807,10 @@ public final  Observable scan(@NonNull R initialValue, @NonNull BiFunction
      * @param seedSupplier
      *            a Supplier that returns the initial (seed) accumulator item for each individual Observer
      * @param accumulator
-     *            an accumulator function to be invoked on each item emitted by the source ObservableSource, whose
+     *            an accumulator function to be invoked on each item emitted by the current {@code Observable}, whose
      *            result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the
      *            next accumulator call
-     * @return an Observable that emits {@code initialValue} followed by the results of each call to the
+     * @return an {@code Observable} that emits {@code initialValue} followed by the results of each call to the
      *         accumulator function
      * @see ReactiveX operators documentation: Scan
      */
@@ -11812,13 +11824,13 @@ public final  Observable scanWith(@NonNull Supplier seedSupplier, @NonN
     }
 
     /**
-     * Forces an ObservableSource's emissions and notifications to be serialized and for it to obey
-     * the ObservableSource contract in other ways.
+     * Forces an {@code ObservableSource}'s emissions and notifications to be serialized and for it to obey
+     * the {@code ObservableSource} contract in other ways.
      * 

-     * It is possible for an ObservableSource to invoke its Observers' methods asynchronously, perhaps from
-     * different threads. This could make such an ObservableSource poorly-behaved, in that it might try to invoke
+     * It is possible for an {@code ObservableSource} to invoke its {@code Observer}s' methods asynchronously, perhaps from
+     * different threads. This could make such an {@code ObservableSource} poorly-behaved, in that it might try to invoke
      * {@code onComplete} or {@code onError} before one of its {@code onNext} invocations, or it might call
-     * {@code onNext} from two different threads concurrently. You can force such an ObservableSource to be
+     * {@code onNext} from two different threads concurrently. You can force such an {@code ObservableSource} to be
      * well-behaved and sequential by applying the {@code serialize} method to it.
      * 

      * 
@@ -11841,7 +11853,7 @@ public final Observable serialize() {
     /**
      * Returns a new {@link ObservableSource} that multicasts (and shares a single subscription to) the original {@link ObservableSource}. As long as
      * there is at least one {@link Observer} this {@link ObservableSource} will be subscribed and emitting data.
-     * When all subscribers have disposed it will dispose the source {@link ObservableSource}.
+     * When all subscribers have disposed it will dispose the current {@code Observable}.
      * 

      * This is an alias for {@link #publish()}.{@link ConnectableObservable#refCount() refCount()}.
      * 

@@ -11851,7 +11863,7 @@ public final Observable serialize() {
      *  
{@code share} does not operate by default on a particular {@link Scheduler}.

      * 

      *
-     * @return an {@code ObservableSource} that upon connection causes the source {@code ObservableSource} to emit items
+     * @return an {@code ObservableSource} that upon connection causes the current {@code Observable} to emit items
      *         to its {@link Observer}s
      * @see ReactiveX operators documentation: RefCount
      */
@@ -11863,8 +11875,8 @@ public final Observable share() {
     }
 
     /**
-     * Returns a Maybe that completes if this Observable is empty or emits the single item emitted by this Observable,
-     * or signals an {@code IllegalArgumentException} if this Observable emits more than one item.
+     * Returns a Maybe that completes if this {@code Observable} is empty or emits the single item emitted by this {@code Observable},
+     * or signals an {@code IllegalArgumentException} if this {@code Observable} emits more than one item.
      * 

      * 
      * 

@@ -11872,7 +11884,7 @@ public final Observable share() {
      *  
{@code singleElement} does not operate by default on a particular {@link Scheduler}.

      * 

      *
-     * @return a {@link Maybe} that emits the single item emitted by the source ObservableSource
+     * @return a {@link Maybe} that emits the single item emitted by the current {@code Observable}
      * @see ReactiveX operators documentation: First
      */
     @CheckReturnValue
@@ -11883,9 +11895,9 @@ public final Maybe singleElement() {
     }
 
     /**
-     * Returns a Single that emits the single item emitted by this Observable, if this Observable
-     * emits only a single item, or a default item if the source ObservableSource emits no items. If the source
-     * ObservableSource emits more than one item, an {@code IllegalArgumentException} is signalled instead.
+     * Returns a Single that emits the single item emitted by the current {@code Observable}, if the current {@code Observable}
+     * emits only a single item, or a default item if the current {@code Observable} emits no items. If the current
+     * {@code Observable} emits more than one item, an {@code IllegalArgumentException} is signaled instead.
      * 

      * 
      * 

@@ -11894,7 +11906,7 @@ public final Maybe singleElement() {
      * 

      *
      * @param defaultItem
-     *            a default value to emit if the source ObservableSource emits no item
+     *            a default value to emit if the current {@code Observable} emits no item
      * @return the new Single instance
      * @see ReactiveX operators documentation: First
      */
@@ -11907,10 +11919,10 @@ public final Single single(@NonNull T defaultItem) {
     }
 
     /**
-     * Returns a Single that emits the single item emitted by this Observable if this Observable
+     * Returns a Single that emits the single item emitted by this {@code Observable} if this {@code Observable}
      * emits only a single item, otherwise
-     * if this Observable completes without emitting any items or emits more than one item a
-     * {@link NoSuchElementException} or {@code IllegalArgumentException} will be signalled respectively.
+     * if this {@code Observable} completes without emitting any items or emits more than one item a
+     * {@link NoSuchElementException} or {@code IllegalArgumentException} will be signaled respectively.
      * 

      * 
      * 

@@ -11929,7 +11941,7 @@ public final Single singleOrError() {
     }
 
     /**
-     * Returns an Observable that skips the first {@code count} items emitted by the source ObservableSource and emits
+     * Returns an {@code Observable} that skips the first {@code count} items emitted by the current {@code Observable} and emits
      * the remainder.
      * 

      * 
@@ -11940,8 +11952,8 @@ public final Single singleOrError() {
      *
      * @param count
      *            the number of items to skip
-     * @return an Observable that is identical to the source ObservableSource except that it does not emit the first
-     *         {@code count} items that the source ObservableSource emits
+     * @return an {@code Observable} that is identical to the current {@code Observable} except that it does not emit the first
+     *         {@code count} items that the current {@code Observable} emits
      * @see ReactiveX operators documentation: Skip
      */
     @CheckReturnValue
@@ -11955,7 +11967,7 @@ public final Observable skip(long count) {
     }
 
     /**
-     * Returns an Observable that skips values emitted by the source ObservableSource before a specified time window
+     * Returns an {@code Observable} that skips values emitted by the current {@code Observable} before a specified time window
      * elapses.
      * 

      * 
@@ -11969,7 +11981,7 @@ public final Observable skip(long count) {
      *            the length of the time window to skip
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that skips values emitted by the source ObservableSource before the time window defined
+     * @return an {@code Observable} that skips values emitted by the current {@code Observable} before the time window defined
      *         by {@code time} elapses and the emits the remainder
      * @see ReactiveX operators documentation: Skip
      */
@@ -11981,7 +11993,7 @@ public final Observable skip(long time, @NonNull TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that skips values emitted by the source ObservableSource before a specified time window
+     * Returns an {@code Observable} that skips values emitted by the current {@code Observable} before a specified time window
      * on a specified {@link Scheduler} elapses.
      * 

      * 
@@ -11996,7 +12008,7 @@ public final Observable skip(long time, @NonNull TimeUnit unit) {
      *            the time unit of {@code time}
      * @param scheduler
      *            the {@link Scheduler} on which the timed wait happens
-     * @return an Observable that skips values emitted by the source ObservableSource before the time window defined
+     * @return an {@code Observable} that skips values emitted by the current {@code Observable} before the time window defined
      *         by {@code time} and {@code scheduler} elapses, and then emits the remainder
      * @see ReactiveX operators documentation: Skip
      */
@@ -12008,12 +12020,12 @@ public final Observable skip(long time, @NonNull TimeUnit unit, @NonNull Sche
     }
 
     /**
-     * Returns an Observable that drops a specified number of items from the end of the sequence emitted by the
-     * source ObservableSource.
+     * Returns an {@code Observable} that drops a specified number of items from the end of the sequence emitted by the
+     * current {@code Observable}.
      * 

      * 
      * 

-     * This Observer accumulates a queue long enough to store the first {@code count} items. As more items are
+     * This {@code Observer} accumulates a queue long enough to store the first {@code count} items. As more items are
      * received, items are taken from the front of the queue and emitted by the returned ObservableSource. This causes
      * such items to be delayed.
      * 

@@ -12023,7 +12035,7 @@ public final Observable skip(long time, @NonNull TimeUnit unit, @NonNull Sche
      *
      * @param count
      *            number of items to drop from the end of the source sequence
-     * @return an Observable that emits the items emitted by the source ObservableSource except for the dropped ones
+     * @return an {@code Observable} that emits the items emitted by the current {@code Observable} except for the dropped ones
      *         at the end
      * @throws IndexOutOfBoundsException
      *             if {@code count} is less than zero
@@ -12043,7 +12055,7 @@ public final Observable skipLast(int count) {
     }
 
     /**
-     * Returns an Observable that drops items emitted by the source ObservableSource during a specified time window
+     * Returns an {@code Observable} that drops items emitted by the current {@code Observable} during a specified time window
      * before the source completes.
      * 

      * 
@@ -12059,7 +12071,7 @@ public final Observable skipLast(int count) {
      *            the length of the time window
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that drops those items emitted by the source ObservableSource in a time window before the
+     * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the
      *         source completes defined by {@code time}
      * @see ReactiveX operators documentation: SkipLast
      */
@@ -12071,7 +12083,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that drops items emitted by the source ObservableSource during a specified time window
+     * Returns an {@code Observable} that drops items emitted by the current {@code Observable} during a specified time window
      * before the source completes.
      * 

      * 
@@ -12088,9 +12100,9 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit) {
      * @param unit
      *            the time unit of {@code time}
      * @param delayError
-     *            if true, an exception signalled by the current Observable is delayed until the regular elements are consumed
-     *            by the downstream; if false, an exception is immediately signalled and all regular elements dropped
-     * @return an Observable that drops those items emitted by the source ObservableSource in a time window before the
+     *            if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed
+     *            by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped
+     * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the
      *         source completes defined by {@code time}
      * @see ReactiveX operators documentation: SkipLast
      */
@@ -12102,7 +12114,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, boolean d
     }
 
     /**
-     * Returns an Observable that drops items emitted by the source ObservableSource during a specified time window
+     * Returns an {@code Observable} that drops items emitted by the current {@code Observable} during a specified time window
      * (defined on a specified scheduler) before the source completes.
      * 

      * 
@@ -12119,7 +12131,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, boolean d
      *            the time unit of {@code time}
      * @param scheduler
      *            the scheduler used as the time source
-     * @return an Observable that drops those items emitted by the source ObservableSource in a time window before the
+     * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the
      *         source completes defined by {@code time} and {@code scheduler}
      * @see ReactiveX operators documentation: SkipLast
      */
@@ -12131,7 +12143,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull
     }
 
     /**
-     * Returns an Observable that drops items emitted by the source ObservableSource during a specified time window
+     * Returns an {@code Observable} that drops items emitted by the current {@code Observable} during a specified time window
      * (defined on a specified scheduler) before the source completes.
      * 

      * 
@@ -12149,9 +12161,9 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull
      * @param scheduler
      *            the scheduler used as the time source
      * @param delayError
-     *            if true, an exception signalled by the current Observable is delayed until the regular elements are consumed
-     *            by the downstream; if false, an exception is immediately signalled and all regular elements dropped
-     * @return an Observable that drops those items emitted by the source ObservableSource in a time window before the
+     *            if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed
+     *            by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped
+     * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the
      *         source completes defined by {@code time} and {@code scheduler}
      * @see ReactiveX operators documentation: SkipLast
      */
@@ -12163,7 +12175,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull
     }
 
     /**
-     * Returns an Observable that drops items emitted by the source ObservableSource during a specified time window
+     * Returns an {@code Observable} that drops items emitted by the current {@code Observable} during a specified time window
      * (defined on a specified scheduler) before the source completes.
      * 

      * 
@@ -12181,11 +12193,11 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull
      * @param scheduler
      *            the scheduler used as the time source
      * @param delayError
-     *            if true, an exception signalled by the current Observable is delayed until the regular elements are consumed
-     *            by the downstream; if false, an exception is immediately signalled and all regular elements dropped
+     *            if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed
+     *            by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped
      * @param bufferSize
      *            the hint about how many elements to expect to be skipped
-     * @return an Observable that drops those items emitted by the source ObservableSource in a time window before the
+     * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the
      *         source completes defined by {@code time} and {@code scheduler}
      * @see ReactiveX operators documentation: SkipLast
      */
@@ -12202,7 +12214,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull
     }
 
     /**
-     * Returns an Observable that skips items emitted by the source ObservableSource until a second ObservableSource emits
+     * Returns an {@code Observable} that skips items emitted by the current {@code Observable} until a second {@code ObservableSource} emits
      * an item.
      * 

      * 
@@ -12211,11 +12223,11 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull
      *  
{@code skipUntil} does not operate by default on a particular {@link Scheduler}.

      * 

      *
-     * @param  the element type of the other ObservableSource
+     * @param  the element type of the other {@code ObservableSource}
      * @param other
-     *            the second ObservableSource that has to emit an item before the source ObservableSource's elements begin
-     *            to be mirrored by the resulting ObservableSource
-     * @return an Observable that skips items from the source ObservableSource until the second ObservableSource emits an
+     *            the second {@code ObservableSource} that has to emit an item before the current {@code Observable}'s elements begin
+     *            to be mirrored by the resulting {@code Observable}
+     * @return an {@code Observable} that skips items from the current {@code Observable} until the second {@code ObservableSource} emits an
      *         item, then emits the remaining items
      * @see ReactiveX operators documentation: SkipUntil
      */
@@ -12228,8 +12240,8 @@ public final  Observable skipUntil(@NonNull ObservableSource other) {
     }
 
     /**
-     * Returns an Observable that skips all items emitted by the source ObservableSource as long as a specified
-     * condition holds true, but emits all further source items as soon as the condition becomes false.
+     * Returns an {@code Observable} that skips all items emitted by the current {@code Observable} as long as a specified
+     * condition holds {@code true}, but emits all further source items as soon as the condition becomes false.
      * 

      * 
      * 

@@ -12238,8 +12250,8 @@ public final  Observable skipUntil(@NonNull ObservableSource other) {
      * 

      *
      * @param predicate
-     *            a function to test each item emitted from the source ObservableSource
-     * @return an Observable that begins emitting items emitted by the source ObservableSource when the specified
+     *            a function to test each item emitted from the current {@code Observable}
+     * @return an {@code Observable} that begins emitting items emitted by the current {@code Observable} when the specified
      *         predicate becomes false
      * @see ReactiveX operators documentation: SkipWhile
      */
@@ -12252,14 +12264,14 @@ public final Observable skipWhile(@NonNull Predicate predicate) {
     }
 
     /**
-     * Returns an Observable that emits the events emitted by source ObservableSource, in a
-     * sorted order. Each item emitted by the ObservableSource must implement {@link Comparable} with respect to all
+     * Returns an {@code Observable} that emits the events emitted by source {@code ObservableSource}, in a
+     * sorted order. Each item emitted by the {@code ObservableSource} must implement {@link Comparable} with respect to all
      * other items in the sequence.
      * 

      * 
      * 

-     * If any item emitted by this Observable does not implement {@link Comparable} with respect to
-     * all other items emitted by this Observable, no items will be emitted and the
+     * If any item emitted by this {@code Observable} does not implement {@link Comparable} with respect to
+     * all other items emitted by this {@code Observable}, no items will be emitted and the
      * sequence is terminated with a {@link ClassCastException}.
      *
      * 
Note that calling {@code sorted} with long, non-terminating or infinite sources
@@ -12269,7 +12281,7 @@ public final Observable skipWhile(@NonNull Predicate predicate) {
      *  
Scheduler:

      *  
{@code sorted} does not operate by default on a particular {@link Scheduler}.

      * 

-     * @return an Observable that emits the items emitted by the source ObservableSource in sorted order
+     * @return an {@code Observable} that emits the items emitted by the current {@code Observable} in sorted order
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
@@ -12279,7 +12291,7 @@ public final Observable sorted() {
     }
 
     /**
-     * Returns an Observable that emits the events emitted by source ObservableSource, in a
+     * Returns an {@code Observable} that emits the events emitted by source {@code ObservableSource}, in a
      * sorted order based on a specified comparison function.
      *
      * 
Note that calling {@code sorted} with long, non-terminating or infinite sources
@@ -12291,9 +12303,9 @@ public final Observable sorted() {
      *
* * @param sortFunction - * a function that compares two items emitted by the source ObservableSource and returns an Integer + * a function that compares two items emitted by the current {@code Observable} and returns an Integer * that indicates their sort order - * @return an Observable that emits the items emitted by the source ObservableSource in sorted order + * @return an {@code Observable} that emits the items emitted by the current {@code Observable} in sorted order */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -12304,8 +12316,8 @@ public final Observable sorted(@NonNull Comparator sortFunction) { } /** - * Returns an Observable that emits the items in a specified {@link Iterable} before it begins to emit items - * emitted by the source ObservableSource. + * Returns an {@code Observable} that emits the items in a specified {@link Iterable} before it begins to emit items + * emitted by the current {@code Observable}. *

* *

@@ -12314,9 +12326,9 @@ public final Observable sorted(@NonNull Comparator sortFunction) { *
* * @param items - * an Iterable that contains the items you want the modified ObservableSource to emit first - * @return an Observable that emits the items in the specified {@link Iterable} and then emits the items - * emitted by the source ObservableSource + * an Iterable that contains the items you want the modified {@code ObservableSource} to emit first + * @return an {@code Observable} that emits the items in the specified {@link Iterable} and then emits the items + * emitted by the current {@code Observable} * @see ReactiveX operators documentation: StartWith * @since 3.0.0 * @see #startWithItem(Object) @@ -12330,8 +12342,8 @@ public final Observable startWithIterable(@NonNull Iterable item } /** - * Returns an Observable that emits the items in a specified {@link ObservableSource} before it begins to emit - * items emitted by the source ObservableSource. + * Returns an {@code Observable} that emits the items in a specified {@link ObservableSource} before it begins to emit + * items emitted by the current {@code Observable}. *

* *

@@ -12340,9 +12352,9 @@ public final Observable startWithIterable(@NonNull Iterable item *
* * @param other - * an ObservableSource that contains the items you want the modified ObservableSource to emit first - * @return an Observable that emits the items in the specified {@link ObservableSource} and then emits the items - * emitted by the source ObservableSource + * an {@code ObservableSource} that contains the items you want the modified {@code ObservableSource} to emit first + * @return an {@code Observable} that emits the items in the specified {@link ObservableSource} and then emits the items + * emitted by the current {@code Observable} * @see ReactiveX operators documentation: StartWith */ @CheckReturnValue @@ -12354,8 +12366,8 @@ public final Observable startWith(@NonNull ObservableSource othe } /** - * Returns an Observable that emits a specified item before it begins to emit items emitted by the source - * ObservableSource. + * Returns an {@code Observable} that emits a specified item before it begins to emit items emitted by the current + * {@code Observable}. *

* *

@@ -12365,8 +12377,8 @@ public final Observable startWith(@NonNull ObservableSource othe * * @param item * the item to emit first - * @return an Observable that emits the specified item before it begins to emit items emitted by the source - * ObservableSource + * @return an {@code Observable} that emits the specified item before it begins to emit items emitted by the current + * {@code Observable} * @see ReactiveX operators documentation: StartWith * @see #startWithArray(Object...) * @see #startWithIterable(Iterable) @@ -12381,8 +12393,8 @@ public final Observable startWithItem(@NonNull T item) { } /** - * Returns an Observable that emits the specified items before it begins to emit items emitted by the source - * ObservableSource. + * Returns an {@code Observable} that emits the specified items before it begins to emit items emitted by the current + * {@code Observable}. *

* *

@@ -12392,8 +12404,8 @@ public final Observable startWithItem(@NonNull T item) { * * @param items * the array of values to emit first - * @return an Observable that emits the specified items before it begins to emit items emitted by the source - * ObservableSource + * @return an {@code Observable} that emits the specified items before it begins to emit items emitted by the current + * {@code Observable} * @see ReactiveX operators documentation: StartWith * @see #startWithItem(Object) * @see #startWithIterable(Iterable) @@ -12411,9 +12423,9 @@ public final Observable startWithArray(@NonNull T... items) { } /** - * Subscribes to an ObservableSource and ignores {@code onNext} and {@code onComplete} emissions. + * Subscribes to an {@code ObservableSource} and ignores {@code onNext} and {@code onComplete} emissions. *

- * If the Observable emits an error, it is wrapped into an + * If the {@code Observable} emits an error, it is wrapped into an * {@link io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException} * and routed to the RxJavaPlugins.onError handler. *

@@ -12422,7 +12434,7 @@ public final Observable startWithArray(@NonNull T... items) { *
* * @return a {@link Disposable} reference with which the caller can stop receiving items before - * the ObservableSource has finished sending them + * the {@code ObservableSource} has finished sending them * @see ReactiveX operators documentation: Subscribe */ @SchedulerSupport(SchedulerSupport.NONE) @@ -12432,9 +12444,9 @@ public final Disposable subscribe() { } /** - * Subscribes to an ObservableSource and provides a callback to handle the items it emits. + * Subscribes to an {@code ObservableSource} and provides a callback to handle the items it emits. *

- * If the Observable emits an error, it is wrapped into an + * If the {@code Observable} emits an error, it is wrapped into an * {@link io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException} * and routed to the RxJavaPlugins.onError handler. *

@@ -12443,9 +12455,9 @@ public final Disposable subscribe() { *
* * @param onNext - * the {@code Consumer} you have designed to accept emissions from the ObservableSource + * the {@code Consumer} you have designed to accept emissions from the {@code ObservableSource} * @return a {@link Disposable} reference with which the caller can stop receiving items before - * the ObservableSource has finished sending them + * the {@code ObservableSource} has finished sending them * @throws NullPointerException * if {@code onNext} is null * @see ReactiveX operators documentation: Subscribe @@ -12458,7 +12470,7 @@ public final Disposable subscribe(@NonNull Consumer onNext) { } /** - * Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error + * Subscribes to an {@code ObservableSource} and provides callbacks to handle the items it emits and any error * notification it issues. *
*
Scheduler:
@@ -12466,12 +12478,12 @@ public final Disposable subscribe(@NonNull Consumer onNext) { *
* * @param onNext - * the {@code Consumer} you have designed to accept emissions from the ObservableSource + * the {@code Consumer} you have designed to accept emissions from the {@code ObservableSource} * @param onError * the {@code Consumer} you have designed to accept any error notification from the - * ObservableSource + * {@code ObservableSource} * @return a {@link Disposable} reference with which the caller can stop receiving items before - * the ObservableSource has finished sending them + * the {@code ObservableSource} has finished sending them * @see ReactiveX operators documentation: Subscribe * @throws NullPointerException * if {@code onNext} is null, or @@ -12485,7 +12497,7 @@ public final Disposable subscribe(@NonNull Consumer onNext, @NonNull } /** - * Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or + * Subscribes to an {@code ObservableSource} and provides callbacks to handle the items it emits and any error or * completion notification it issues. *
*
Scheduler:
@@ -12493,15 +12505,15 @@ public final Disposable subscribe(@NonNull Consumer onNext, @NonNull *
* * @param onNext - * the {@code Consumer} you have designed to accept emissions from the ObservableSource + * the {@code Consumer} you have designed to accept emissions from the {@code ObservableSource} * @param onError * the {@code Consumer} you have designed to accept any error notification from the - * ObservableSource + * {@code ObservableSource} * @param onComplete * the {@code Action} you have designed to accept a completion notification from the - * ObservableSource + * {@code ObservableSource} * @return a {@link Disposable} reference with which the caller can stop receiving items before - * the ObservableSource has finished sending them + * the {@code ObservableSource} has finished sending them * @throws NullPointerException * if {@code onNext} is null, or * if {@code onError} is null, or @@ -12559,8 +12571,8 @@ public final void subscribe(@NonNull Observer observer) { protected abstract void subscribeActual(@NonNull Observer observer); /** - * Subscribes a given Observer (subclass) to this Observable and returns the given - * Observer as is. + * Subscribes a given {@code Observer} (subclass) to this {@code Observable} and returns the given + * {@code Observer} as is. *

Usage example: * 


      * Observable<Integer> source = Observable.range(1, 10);
@@ -12576,8 +12588,8 @@ public final void subscribe(@NonNull Observer observer) {
      *  
Scheduler:

      *  
{@code subscribeWith} does not operate by default on a particular {@link Scheduler}.

      *
- * @param the type of the Observer to use and return - * @param observer the Observer (subclass) to use and return, not null + * @param the type of the {@code Observer} to use and return + * @param observer the {@code Observer} (subclass) to use and return, not null * @return the input {@code observer} * @throws NullPointerException if {@code observer} is null * @since 2.0 @@ -12591,7 +12603,7 @@ public final void subscribe(@NonNull Observer observer) { } /** - * Asynchronously subscribes Observers to this ObservableSource on the specified {@link Scheduler}. + * Asynchronously subscribes {@code Observer}s to this {@code ObservableSource} on the specified {@link Scheduler}. *

* *

@@ -12601,7 +12613,7 @@ public final void subscribe(@NonNull Observer observer) { * * @param scheduler * the {@link Scheduler} to perform subscription actions on - * @return the source ObservableSource modified so that its subscriptions happen on the + * @return the current {@code Observable} modified so that its subscriptions happen on the * specified {@link Scheduler} * @see ReactiveX operators documentation: SubscribeOn * @see RxJava Threading Examples @@ -12616,8 +12628,8 @@ public final Observable subscribeOn(@NonNull Scheduler scheduler) { } /** - * Returns an Observable that emits the items emitted by the source ObservableSource or the items of an alternate - * ObservableSource if the source ObservableSource is empty. + * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} or the items of an alternate + * {@code ObservableSource} if the current {@code Observable} is empty. *

* *

@@ -12626,9 +12638,9 @@ public final Observable subscribeOn(@NonNull Scheduler scheduler) { *
* * @param other - * the alternate ObservableSource to subscribe to if the source does not emit any items - * @return an ObservableSource that emits the items emitted by the source ObservableSource or the items of an - * alternate ObservableSource if the source ObservableSource is empty. + * the alternate {@code ObservableSource} to subscribe to if the source does not emit any items + * @return an {@code ObservableSource} that emits the items emitted by the current {@code Observable} or the items of an + * alternate {@code ObservableSource} if the current {@code Observable} is empty. * @since 1.1.0 */ @CheckReturnValue @@ -12640,12 +12652,12 @@ public final Observable switchIfEmpty(@NonNull ObservableSource } /** - * Returns a new ObservableSource by applying a function that you supply to each item emitted by the source - * ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted - * of these ObservableSources. + * Returns a new {@code Observable} by applying a function that you supply to each item emitted by the current + * {@code Observable} that returns an {@code ObservableSource}, and then emitting the items emitted by the most recently emitted + * of these {@code ObservableSource}s. *

- * The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. - * If the upstream ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence. + * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code ObservableSource}, if any, complete. + * If the current {@code Observable} signals an {@code onError}, the inner {@code ObservableSource} is disposed and the error delivered in-sequence. *

* *

@@ -12653,11 +12665,11 @@ public final Observable switchIfEmpty(@NonNull ObservableSource *
{@code switchMap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the element type of the inner ObservableSources and the output + * @param the element type of the inner {@code ObservableSource}s and the output * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource - * @return an Observable that emits the items emitted by the ObservableSource returned from applying {@code func} to the most recently emitted item emitted by the source ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} + * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} * @see ReactiveX operators documentation: FlatMap * @see #switchMapDelayError(Function) */ @@ -12669,12 +12681,12 @@ public final Observable switchMap(@NonNull Function - * The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. - * If the upstream ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence. + * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code ObservableSource}, if any, complete. + * If the current {@code Observable} signals an onError, the inner {@code ObservableSource} is disposed and the error delivered in-sequence. *

* *

@@ -12682,13 +12694,13 @@ public final Observable switchMap(@NonNull Function{@code switchMap} does not operate by default on a particular {@link Scheduler}. *
* - * @param the element type of the inner ObservableSources and the output + * @param the element type of the inner {@code ObservableSource}s and the output * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} * @param bufferSize - * the number of elements to prefetch from the current active inner ObservableSource - * @return an Observable that emits the items emitted by the ObservableSource returned from applying {@code func} to the most recently emitted item emitted by the source ObservableSource + * the number of elements to prefetch from the current active inner {@code ObservableSource} + * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} * @see ReactiveX operators documentation: FlatMap * @see #switchMapDelayError(Function, int) */ @@ -12731,7 +12743,7 @@ public final Observable switchMap(@NonNull Function *
@@ -12774,7 +12786,7 @@ public final Completable switchMapCompletable(@NonNull Function *
@@ -12819,7 +12831,7 @@ public final Completable switchMapCompletableDelayError(@NonNull Function Observable switchMapMaybe(@NonNull Function Observable switchMapMaybeDelayError(@NonNull Function - * The resulting ObservableSource completes if both the upstream ObservableSource and the last inner SingleSource, if any, complete. - * If the upstream ObservableSource signals an onError, the inner SingleSource is disposed and the error delivered in-sequence. + * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner SingleSource, if any, complete. + * If the current {@code Observable} signals an onError, the inner SingleSource is disposed and the error delivered in-sequence. *

* *

@@ -12874,9 +12886,9 @@ public final Observable switchMapMaybeDelayError(@NonNull FunctionHistory: 2.0.8 - experimental * @param the element type of the inner SingleSources and the output * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns a + * a function that, when applied to an item emitted by the current {@code Observable}, returns a * SingleSource - * @return an Observable that emits the item emitted by the SingleSource returned from applying {@code func} to the most recently emitted item emitted by the source ObservableSource + * @return an {@code Observable} that emits the item emitted by the SingleSource returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} * @see ReactiveX operators documentation: FlatMap * @see #switchMapSingleDelayError(Function) * @since 2.2 @@ -12890,13 +12902,13 @@ public final Observable switchMapSingle(@NonNull Function - * The resulting ObservableSource completes if both the upstream ObservableSource and the last inner SingleSource, if any, complete. - * If the upstream ObservableSource signals an onError, the termination of the last inner SingleSource will emit that error as is - * or wrapped into a CompositeException along with the other possible errors the former inner SingleSources signalled. + * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner SingleSource, if any, complete. + * If the current {@code Observable} signals an onError, the termination of the last inner SingleSource will emit that error as is + * or wrapped into a CompositeException along with the other possible errors the former inner SingleSources signaled. *

* *

@@ -12906,9 +12918,9 @@ public final Observable switchMapSingle(@NonNull FunctionHistory: 2.0.8 - experimental * @param the element type of the inner SingleSources and the output * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns a + * a function that, when applied to an item emitted by the current {@code Observable}, returns a * SingleSource - * @return an Observable that emits the item emitted by the SingleSource returned from applying {@code func} to the most recently emitted item emitted by the source ObservableSource + * @return an {@code Observable} that emits the item emitted by the SingleSource returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} * @see ReactiveX operators documentation: FlatMap * @see #switchMapSingle(Function) * @since 2.2 @@ -12922,13 +12934,13 @@ public final Observable switchMapSingleDelayError(@NonNull Function - * The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. - * If the upstream ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is - * or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signalled. + * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code ObservableSource}, if any, complete. + * If the current {@code Observable} signals an onError, the termination of the last inner {@code ObservableSource} will emit that error as is + * or wrapped into a CompositeException along with the other possible errors the former inner {@code ObservableSource}s signaled. *

* *

@@ -12936,11 +12948,11 @@ public final Observable switchMapSingleDelayError(@NonNull Function{@code switchMapDelayError} does not operate by default on a particular {@link Scheduler}. *
* - * @param the element type of the inner ObservableSources and the output + * @param the element type of the inner {@code ObservableSource}s and the output * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource - * @return an Observable that emits the items emitted by the ObservableSource returned from applying {@code func} to the most recently emitted item emitted by the source ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} + * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} * @see ReactiveX operators documentation: FlatMap * @see #switchMap(Function) * @since 2.0 @@ -12953,13 +12965,13 @@ public final Observable switchMapDelayError(@NonNull Function - * The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. - * If the upstream ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is - * or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signalled. + * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code ObservableSource}, if any, complete. + * If the current {@code Observable} signals an {@code onError}, the termination of the last inner {@code ObservableSource} will emit that error as is + * or wrapped into a CompositeException along with the other possible errors the former inner {@code ObservableSource}s signaled. *

* *

@@ -12967,13 +12979,13 @@ public final Observable switchMapDelayError(@NonNull Function{@code switchMapDelayError} does not operate by default on a particular {@link Scheduler}. *
* - * @param the element type of the inner ObservableSources and the output + * @param the element type of the inner {@code ObservableSource}s and the output * @param mapper - * a function that, when applied to an item emitted by the source ObservableSource, returns an - * ObservableSource + * a function that, when applied to an item emitted by the current {@code Observable}, returns an + * {@code ObservableSource} * @param bufferSize - * the number of elements to prefetch from the current active inner ObservableSource - * @return an Observable that emits the items emitted by the ObservableSource returned from applying {@code func} to the most recently emitted item emitted by the source ObservableSource + * the number of elements to prefetch from the current active inner {@code ObservableSource} + * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} * @see ReactiveX operators documentation: FlatMap * @see #switchMap(Function, int) * @since 2.0 @@ -12996,12 +13008,12 @@ public final Observable switchMapDelayError(@NonNull Function * *

- * This method returns an ObservableSource that will invoke a subscribing {@link Observer}'s + * This method returns an {@code ObservableSource} that will invoke a subscribing {@link Observer}'s * {@link Observer#onNext onNext} function a maximum of {@code count} times before invoking * {@link Observer#onComplete onComplete}. *

@@ -13011,8 +13023,8 @@ public final Observable switchMapDelayError(@NonNull FunctionReactiveX operators documentation: Take */ @CheckReturnValue @@ -13026,7 +13038,7 @@ public final Observable take(long count) { } /** - * Returns an Observable that emits those items emitted by source ObservableSource before a specified time runs + * Returns an {@code Observable} that emits those items emitted by source {@code ObservableSource} before a specified time runs * out. *

* If time runs out before the {@code Observable} completes normally, the {@code onComplete} event will be @@ -13042,7 +13054,7 @@ public final Observable take(long count) { * the length of the time window * @param unit * the time unit of {@code time} - * @return an Observable that emits those items emitted by the source ObservableSource before the time runs out + * @return an {@code Observable} that emits those items emitted by the current {@code Observable} before the time runs out * @see ReactiveX operators documentation: Take */ @CheckReturnValue @@ -13053,7 +13065,7 @@ public final Observable take(long time, @NonNull TimeUnit unit) { } /** - * Returns an Observable that emits those items emitted by source ObservableSource before a specified time (on a + * Returns an {@code Observable} that emits those items emitted by source {@code ObservableSource} before a specified time (on a * specified Scheduler) runs out. *

* If time runs out before the {@code Observable} completes normally, the {@code onComplete} event will be @@ -13071,7 +13083,7 @@ public final Observable take(long time, @NonNull TimeUnit unit) { * the time unit of {@code time} * @param scheduler * the Scheduler used for time source - * @return an Observable that emits those items emitted by the source ObservableSource before the time runs out, + * @return an {@code Observable} that emits those items emitted by the current {@code Observable} before the time runs out, * according to the specified Scheduler * @see ReactiveX operators documentation: Take */ @@ -13083,8 +13095,8 @@ public final Observable take(long time, @NonNull TimeUnit unit, @NonNull Sche } /** - * Returns an Observable that emits at most the last {@code count} items emitted by the source ObservableSource. If the source emits fewer than - * {@code count} items then all of its items are emitted. + * Returns an {@code Observable} that emits at most the last {@code count} items emitted by the current {@code Observable}. + * If the source emits fewer than {@code count} items then all of its items are emitted. *

* *

@@ -13093,9 +13105,9 @@ public final Observable take(long time, @NonNull TimeUnit unit, @NonNull Sche *
* * @param count - * the maximum number of items to emit from the end of the sequence of items emitted by the source - * ObservableSource - * @return an Observable that emits at most the last {@code count} items emitted by the source ObservableSource + * the maximum number of items to emit from the end of the sequence of items emitted by the current + * {@code Observable} + * @return an {@code Observable} that emits at most the last {@code count} items emitted by the current {@code Observable} * @throws IndexOutOfBoundsException * if {@code count} is less than zero * @see ReactiveX operators documentation: TakeLast @@ -13117,8 +13129,8 @@ public final Observable takeLast(int count) { } /** - * Returns an Observable that emits at most a specified number of items from the source ObservableSource that were - * emitted in a specified window of time before the ObservableSource completed. + * Returns an {@code Observable} that emits at most a specified number of items from the current {@code Observable} that were + * emitted in a specified window of time before the {@code ObservableSource} completed. *

* *

@@ -13133,8 +13145,8 @@ public final Observable takeLast(int count) { * the length of the time window * @param unit * the time unit of {@code time} - * @return an Observable that emits at most {@code count} items from the source ObservableSource that were emitted - * in a specified window of time before the ObservableSource completed + * @return an {@code Observable} that emits at most {@code count} items from the current {@code Observable} that were emitted + * in a specified window of time before the {@code ObservableSource} completed * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13145,8 +13157,8 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni } /** - * Returns an Observable that emits at most a specified number of items from the source ObservableSource that were - * emitted in a specified window of time before the ObservableSource completed, where the timing information is + * Returns an {@code Observable} that emits at most a specified number of items from the current {@code Observable} that were + * emitted in a specified window of time before the {@code ObservableSource} completed, where the timing information is * provided by a given Scheduler. *

* @@ -13163,8 +13175,8 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni * the time unit of {@code time} * @param scheduler * the {@link Scheduler} that provides the timestamps for the observed items - * @return an Observable that emits at most {@code count} items from the source ObservableSource that were emitted - * in a specified window of time before the ObservableSource completed, where the timing information is + * @return an {@code Observable} that emits at most {@code count} items from the current {@code Observable} that were emitted + * in a specified window of time before the {@code ObservableSource} completed, where the timing information is * provided by the given {@code scheduler} * @throws IndexOutOfBoundsException * if {@code count} is less than zero @@ -13178,8 +13190,8 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni } /** - * Returns an Observable that emits at most a specified number of items from the source ObservableSource that were - * emitted in a specified window of time before the ObservableSource completed, where the timing information is + * Returns an {@code Observable} that emits at most a specified number of items from the current {@code Observable} that were + * emitted in a specified window of time before the {@code ObservableSource} completed, where the timing information is * provided by a given Scheduler. *

* @@ -13197,12 +13209,12 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni * @param scheduler * the {@link Scheduler} that provides the timestamps for the observed items * @param delayError - * if true, an exception signalled by the current Observable is delayed until the regular elements are consumed - * by the downstream; if false, an exception is immediately signalled and all regular elements dropped + * if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed + * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped * @param bufferSize * the hint about how many elements to expect to be last - * @return an Observable that emits at most {@code count} items from the source ObservableSource that were emitted - * in a specified window of time before the ObservableSource completed, where the timing information is + * @return an {@code Observable} that emits at most {@code count} items from the current {@code Observable} that were emitted + * in a specified window of time before the {@code ObservableSource} completed, where the timing information is * provided by the given {@code scheduler} * @throws IndexOutOfBoundsException * if {@code count} is less than zero @@ -13222,8 +13234,8 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni } /** - * Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified - * window of time before the ObservableSource completed. + * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified + * window of time before the {@code ObservableSource} completed. *

* *

@@ -13235,8 +13247,8 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni * the length of the time window * @param unit * the time unit of {@code time} - * @return an Observable that emits the items from the source ObservableSource that were emitted in the window of - * time before the ObservableSource completed specified by {@code time} + * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of + * time before the {@code ObservableSource} completed specified by {@code time} * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13247,8 +13259,8 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit) { } /** - * Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified - * window of time before the ObservableSource completed. + * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified + * window of time before the {@code ObservableSource} completed. *

* *

@@ -13261,10 +13273,10 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit) { * @param unit * the time unit of {@code time} * @param delayError - * if true, an exception signalled by the current Observable is delayed until the regular elements are consumed - * by the downstream; if false, an exception is immediately signalled and all regular elements dropped - * @return an Observable that emits the items from the source ObservableSource that were emitted in the window of - * time before the ObservableSource completed specified by {@code time} + * if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed + * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped + * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of + * time before the {@code ObservableSource} completed specified by {@code time} * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13275,8 +13287,8 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, boolean d } /** - * Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified - * window of time before the ObservableSource completed, where the timing information is provided by a specified + * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified + * window of time before the {@code ObservableSource} completed, where the timing information is provided by a specified * Scheduler. *

* @@ -13291,8 +13303,8 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, boolean d * the time unit of {@code time} * @param scheduler * the Scheduler that provides the timestamps for the Observed items - * @return an Observable that emits the items from the source ObservableSource that were emitted in the window of - * time before the ObservableSource completed specified by {@code time}, where the timing information is + * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of + * time before the {@code ObservableSource} completed specified by {@code time}, where the timing information is * provided by {@code scheduler} * @see ReactiveX operators documentation: TakeLast */ @@ -13304,8 +13316,8 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull } /** - * Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified - * window of time before the ObservableSource completed, where the timing information is provided by a specified + * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified + * window of time before the {@code ObservableSource} completed, where the timing information is provided by a specified * Scheduler. *

* @@ -13321,10 +13333,10 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull * @param scheduler * the Scheduler that provides the timestamps for the Observed items * @param delayError - * if true, an exception signalled by the current Observable is delayed until the regular elements are consumed - * by the downstream; if false, an exception is immediately signalled and all regular elements dropped - * @return an Observable that emits the items from the source ObservableSource that were emitted in the window of - * time before the ObservableSource completed specified by {@code time}, where the timing information is + * if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed + * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped + * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of + * time before the {@code ObservableSource} completed specified by {@code time}, where the timing information is * provided by {@code scheduler} * @see ReactiveX operators documentation: TakeLast */ @@ -13336,8 +13348,8 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull } /** - * Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified - * window of time before the ObservableSource completed, where the timing information is provided by a specified + * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified + * window of time before the {@code ObservableSource} completed, where the timing information is provided by a specified * Scheduler. *

* @@ -13353,12 +13365,12 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull * @param scheduler * the Scheduler that provides the timestamps for the Observed items * @param delayError - * if true, an exception signalled by the current Observable is delayed until the regular elements are consumed - * by the downstream; if false, an exception is immediately signalled and all regular elements dropped + * if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed + * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped * @param bufferSize * the hint about how many elements to expect to be last - * @return an Observable that emits the items from the source ObservableSource that were emitted in the window of - * time before the ObservableSource completed specified by {@code time}, where the timing information is + * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of + * time before the {@code ObservableSource} completed specified by {@code time}, where the timing information is * provided by {@code scheduler} * @see ReactiveX operators documentation: TakeLast */ @@ -13370,7 +13382,7 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull } /** - * Returns an Observable that emits the items emitted by the source Observable until a second ObservableSource + * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} until a second {@code ObservableSource} * emits an item. *

* @@ -13380,11 +13392,11 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull *

* * @param other - * the ObservableSource whose first emitted item will cause {@code takeUntil} to stop emitting items - * from the source Observable + * the {@code ObservableSource} whose first emitted item will cause {@code takeUntil} to stop emitting items + * from the current {@code Observable} * @param * the type of items emitted by {@code other} - * @return an Observable that emits the items emitted by the source Observable until such time as {@code other} emits its first item + * @return an {@code Observable} that emits the items emitted by the current {@code Observable} until such time as {@code other} emits its first item * @see ReactiveX operators documentation: TakeUntil */ @CheckReturnValue @@ -13396,7 +13408,7 @@ public final Observable takeUntil(@NonNull ObservableSource other) { } /** - * Returns an Observable that emits items emitted by the source Observable, checks the specified predicate + * Returns an {@code Observable} that emits items emitted by the current {@code Observable}, checks the specified predicate * for each item, and then completes when the condition is satisfied. *

* @@ -13410,8 +13422,8 @@ public final Observable takeUntil(@NonNull ObservableSource other) { *

* * @param stopPredicate - * a function that evaluates an item emitted by the source Observable and returns a Boolean - * @return an Observable that first emits items emitted by the source Observable, checks the specified + * a function that evaluates an item emitted by the current {@code Observable} and returns a Boolean + * @return an {@code Observable} that first emits items emitted by the current {@code Observable}, checks the specified * condition after each item, and then completes when the condition is satisfied. * @see ReactiveX operators documentation: TakeUntil * @see Observable#takeWhile(Predicate) @@ -13426,7 +13438,7 @@ public final Observable takeUntil(@NonNull Predicate stopPredicate } /** - * Returns an Observable that emits items emitted by the source ObservableSource so long as each item satisfied a + * Returns an {@code Observable} that emits items emitted by the current {@code Observable} so long as each item satisfied a * specified condition, and then completes as soon as this condition is not satisfied. *

* @@ -13436,8 +13448,8 @@ public final Observable takeUntil(@NonNull Predicate stopPredicate *

* * @param predicate - * a function that evaluates an item emitted by the source ObservableSource and returns a Boolean - * @return an Observable that emits the items from the source ObservableSource so long as each item satisfies the + * a function that evaluates an item emitted by the current {@code Observable} and returns a Boolean + * @return an {@code Observable} that emits the items from the current {@code Observable} so long as each item satisfies the * condition defined by {@code predicate}, then completes * @see ReactiveX operators documentation: TakeWhile * @see Observable#takeUntil(Predicate) @@ -13451,7 +13463,7 @@ public final Observable takeWhile(@NonNull Predicate predicate) { } /** - * Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential + * Returns an {@code Observable} that emits only the first item emitted by the current {@code Observable} during sequential * time windows of a specified duration. *

* This differs from {@link #throttleLast} in that this only tracks passage of time whereas @@ -13467,7 +13479,7 @@ public final Observable takeWhile(@NonNull Predicate predicate) { * time to wait before emitting another item after emitting the last item * @param unit * the unit of time of {@code windowDuration} - * @return an Observable that performs the throttle operation + * @return an {@code Observable} that performs the throttle operation * @see ReactiveX operators documentation: Sample */ @CheckReturnValue @@ -13478,7 +13490,7 @@ public final Observable throttleFirst(long windowDuration, @NonNull TimeUnit } /** - * Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential + * Returns an {@code Observable} that emits only the first item emitted by the current {@code Observable} during sequential * time windows of a specified duration, where the windows are managed by a specified Scheduler. *

* This differs from {@link #throttleLast} in that this only tracks passage of time whereas @@ -13497,7 +13509,7 @@ public final Observable throttleFirst(long windowDuration, @NonNull TimeUnit * @param scheduler * the {@link Scheduler} to use internally to manage the timers that handle timeout for each * event - * @return an Observable that performs the throttle operation + * @return an {@code Observable} that performs the throttle operation * @see ReactiveX operators documentation: Sample */ @CheckReturnValue @@ -13510,7 +13522,7 @@ public final Observable throttleFirst(long skipDuration, @NonNull TimeUnit un } /** - * Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential + * Returns an {@code Observable} that emits only the last item emitted by the current {@code Observable} during sequential * time windows of a specified duration. *

* This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval whereas @@ -13523,11 +13535,11 @@ public final Observable throttleFirst(long skipDuration, @NonNull TimeUnit un *

* * @param intervalDuration - * duration of windows within which the last item emitted by the source ObservableSource will be + * duration of windows within which the last item emitted by the current {@code Observable} will be * emitted * @param unit * the unit of time of {@code intervalDuration} - * @return an Observable that performs the throttle operation + * @return an {@code Observable} that performs the throttle operation * @see ReactiveX operators documentation: Sample * @see #sample(long, TimeUnit) */ @@ -13539,7 +13551,7 @@ public final Observable throttleLast(long intervalDuration, @NonNull TimeUnit } /** - * Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential + * Returns an {@code Observable} that emits only the last item emitted by the current {@code Observable} during sequential * time windows of a specified duration, where the duration is governed by a specified Scheduler. *

* This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval whereas @@ -13552,14 +13564,14 @@ public final Observable throttleLast(long intervalDuration, @NonNull TimeUnit *

* * @param intervalDuration - * duration of windows within which the last item emitted by the source ObservableSource will be + * duration of windows within which the last item emitted by the current {@code Observable} will be * emitted * @param unit * the unit of time of {@code intervalDuration} * @param scheduler * the {@link Scheduler} to use internally to manage the timers that handle timeout for each * event - * @return an Observable that performs the throttle operation + * @return an {@code Observable} that performs the throttle operation * @see ReactiveX operators documentation: Sample * @see #sample(long, TimeUnit, Scheduler) */ @@ -13571,7 +13583,7 @@ public final Observable throttleLast(long intervalDuration, @NonNull TimeUnit } /** - * Throttles items from the upstream {@code Observable} by first emitting the next + * Throttles items from the current {@code Observable} by first emitting the next * item from upstream, then periodically emitting the latest item (if any) when * the specified timeout elapses between them. *

@@ -13590,7 +13602,7 @@ public final Observable throttleLast(long intervalDuration, @NonNull TimeUnit * @param timeout the time to wait after an item emission towards the downstream * before trying to emit the latest item from upstream again * @param unit the time unit - * @return the new Observable instance + * @return the new {@code Observable} instance * @see #throttleLatest(long, TimeUnit, boolean) * @see #throttleLatest(long, TimeUnit, Scheduler) * @since 2.2 @@ -13603,7 +13615,7 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit) } /** - * Throttles items from the upstream {@code Observable} by first emitting the next + * Throttles items from the current {@code Observable} by first emitting the next * item from upstream, then periodically emitting the latest item (if any) when * the specified timeout elapses between them. *

@@ -13623,7 +13635,7 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit) * immediately when the upstream completes, regardless if there is * a timeout window active or not. If {@code false}, the very last * upstream item is ignored and the flow terminates. - * @return the new Observable instance + * @return the new {@code Observable} instance * @see #throttleLatest(long, TimeUnit, Scheduler, boolean) * @since 2.2 */ @@ -13635,7 +13647,7 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, } /** - * Throttles items from the upstream {@code Observable} by first emitting the next + * Throttles items from the current {@code Observable} by first emitting the next * item from upstream, then periodically emitting the latest item (if any) when * the specified timeout elapses between them. *

@@ -13656,7 +13668,7 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, * @param unit the time unit * @param scheduler the {@link Scheduler} where the timed wait and latest item * emission will be performed - * @return the new Observable instance + * @return the new {@code Observable} instance * @see #throttleLatest(long, TimeUnit, Scheduler, boolean) * @since 2.2 */ @@ -13668,7 +13680,7 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, } /** - * Throttles items from the upstream {@code Observable} by first emitting the next + * Throttles items from the current {@code Observable} by first emitting the next * item from upstream, then periodically emitting the latest item (if any) when * the specified timeout elapses between them. *

@@ -13690,7 +13702,7 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, * immediately when the upstream completes, regardless if there is * a timeout window active or not. If {@code false}, the very last * upstream item is ignored and the flow terminates. - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 2.2 */ @CheckReturnValue @@ -13703,12 +13715,12 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, } /** - * Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the - * source ObservableSource that are followed by newer items before a timeout value expires. The timer resets on + * Returns an {@code Observable} that mirrors the current {@code Observable}, except that it drops items emitted by the + * current {@code Observable} that are followed by newer items before a timeout value expires. The timer resets on * each emission (alias to {@link #debounce(long, TimeUnit, Scheduler)}). *

- * Note: If items keep being emitted by the source ObservableSource faster than the timeout then no items - * will be emitted by the resulting ObservableSource. + * Note: If items keep being emitted by the current {@code Observable} faster than the timeout then no items + * will be emitted by the resulting {@code Observable}. *

* *

@@ -13717,12 +13729,12 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, *
* * @param timeout - * the length of the window of time that must pass after the emission of an item from the source - * ObservableSource in which that ObservableSource emits no items in order for the item to be emitted by the - * resulting ObservableSource + * the length of the window of time that must pass after the emission of an item from the current + * {@code Observable} in which that {@code ObservableSource} emits no items in order for the item to be emitted by the + * resulting {@code Observable} * @param unit * the unit of time for the specified {@code timeout} - * @return an Observable that filters out items from the source ObservableSource that are too quickly followed by + * @return an {@code Observable} that filters out items from the current {@code Observable} that are too quickly followed by * newer items * @see ReactiveX operators documentation: Debounce * @see #debounce(long, TimeUnit) @@ -13735,12 +13747,12 @@ public final Observable throttleWithTimeout(long timeout, @NonNull TimeUnit u } /** - * Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the - * source ObservableSource that are followed by newer items before a timeout value expires on a specified + * Returns an {@code Observable} that mirrors the current {@code Observable}, except that it drops items emitted by the + * current {@code Observable} that are followed by newer items before a timeout value expires on a specified * Scheduler. The timer resets on each emission (Alias to {@link #debounce(long, TimeUnit, Scheduler)}). *

- * Note: If items keep being emitted by the source ObservableSource faster than the timeout then no items - * will be emitted by the resulting ObservableSource. + * Note: If items keep being emitted by the current {@code Observable} faster than the timeout then no items + * will be emitted by the resulting {@code Observable}. *

* *

@@ -13749,15 +13761,15 @@ public final Observable throttleWithTimeout(long timeout, @NonNull TimeUnit u *
* * @param timeout - * the length of the window of time that must pass after the emission of an item from the source - * ObservableSource in which that ObservableSource emits no items in order for the item to be emitted by the - * resulting ObservableSource + * the length of the window of time that must pass after the emission of an item from the current + * {@code Observable} in which that {@code ObservableSource} emits no items in order for the item to be emitted by the + * resulting {@code Observable} * @param unit * the unit of time for the specified {@code timeout} * @param scheduler * the {@link Scheduler} to use internally to manage the timers that handle the timeout for each * item - * @return an Observable that filters out items from the source ObservableSource that are too quickly followed by + * @return an {@code Observable} that filters out items from the current {@code Observable} that are too quickly followed by * newer items * @see ReactiveX operators documentation: Debounce * @see #debounce(long, TimeUnit, Scheduler) @@ -13770,8 +13782,8 @@ public final Observable throttleWithTimeout(long timeout, @NonNull TimeUnit u } /** - * Returns an Observable that emits records of the time interval between consecutive items emitted by the - * source ObservableSource. + * Returns an {@code Observable} that emits records of the time interval between consecutive items emitted by the + * current {@code Observable}. *

* *

@@ -13780,7 +13792,7 @@ public final Observable throttleWithTimeout(long timeout, @NonNull TimeUnit u * from the {@code computation} {@link Scheduler}. *
* - * @return an Observable that emits time interval information items + * @return an {@code Observable} that emits time interval information items * @see ReactiveX operators documentation: TimeInterval */ @CheckReturnValue @@ -13791,8 +13803,8 @@ public final Observable> timeInterval() { } /** - * Returns an Observable that emits records of the time interval between consecutive items emitted by the - * source ObservableSource, where this interval is computed on a specified Scheduler. + * Returns an {@code Observable} that emits records of the time interval between consecutive items emitted by the + * current {@code Observable}, where this interval is computed on a specified {@link Scheduler}. *

* *

@@ -13803,7 +13815,7 @@ public final Observable> timeInterval() { * * @param scheduler * the {@link Scheduler} used to compute time intervals - * @return an Observable that emits time interval information items + * @return an {@code Observable} that emits time interval information items * @see ReactiveX operators documentation: TimeInterval */ @CheckReturnValue @@ -13814,8 +13826,8 @@ public final Observable> timeInterval(@NonNull Scheduler scheduler) { } /** - * Returns an Observable that emits records of the time interval between consecutive items emitted by the - * source ObservableSource. + * Returns an {@code Observable} that emits records of the time interval between consecutive items emitted by the + * current {@code Observable}. *

* *

@@ -13825,7 +13837,7 @@ public final Observable> timeInterval(@NonNull Scheduler scheduler) { *
* * @param unit the time unit for the current time - * @return an Observable that emits time interval information items + * @return an {@code Observable} that emits time interval information items * @see ReactiveX operators documentation: TimeInterval */ @CheckReturnValue @@ -13836,8 +13848,8 @@ public final Observable> timeInterval(@NonNull TimeUnit unit) { } /** - * Returns an Observable that emits records of the time interval between consecutive items emitted by the - * source ObservableSource, where this interval is computed on a specified Scheduler. + * Returns an {@code Observable} that emits records of the time interval between consecutive items emitted by the + * current {@code Observable}, where this interval is computed on a specified Scheduler. *

* *

@@ -13849,7 +13861,7 @@ public final Observable> timeInterval(@NonNull TimeUnit unit) { * @param unit the time unit for the current time * @param scheduler * the {@link Scheduler} used to compute time intervals - * @return an Observable that emits time interval information items + * @return an {@code Observable} that emits time interval information items * @see ReactiveX operators documentation: TimeInterval */ @CheckReturnValue @@ -13862,9 +13874,9 @@ public final Observable> timeInterval(@NonNull TimeUnit unit, @NonNull } /** - * Returns an Observable that mirrors the source ObservableSource, but notifies observers of a - * {@code TimeoutException} if an item emitted by the source ObservableSource doesn't arrive within a window of - * time after the emission of the previous item, where that period of time is measured by an ObservableSource that + * Returns an {@code Observable} that mirrors the current {@code Observable}, but notifies observers of a + * {@code TimeoutException} if an item emitted by the current {@code Observable} doesn't arrive within a window of + * time after the emission of the previous item, where that period of time is measured by an {@code ObservableSource} that * is a function of the previous item. *

* @@ -13878,10 +13890,10 @@ public final Observable> timeInterval(@NonNull TimeUnit unit, @NonNull * @param * the timeout value type (ignored) * @param itemTimeoutIndicator - * a function that returns an ObservableSource for each item emitted by the source - * ObservableSource and that determines the timeout window for the subsequent item - * @return an Observable that mirrors the source ObservableSource, but notifies observers of a - * {@code TimeoutException} if an item emitted by the source ObservableSource takes longer to arrive than + * a function that returns an {@code ObservableSource} for each item emitted by the current + * {@code Observable} and that determines the timeout window for the subsequent item + * @return an {@code Observable} that mirrors the current {@code Observable}, but notifies observers of a + * {@code TimeoutException} if an item emitted by the current {@code Observable} takes longer to arrive than * the time window defined by the selector for the previously emitted item * @see ReactiveX operators documentation: Timeout */ @@ -13893,9 +13905,9 @@ public final Observable timeout(@NonNull Function * @@ -13909,12 +13921,12 @@ public final Observable timeout(@NonNull Function * the timeout value type (ignored) * @param itemTimeoutIndicator - * a function that returns an ObservableSource, for each item emitted by the source ObservableSource, that + * a function that returns an {@code ObservableSource}, for each item emitted by the current {@code Observable}, that * determines the timeout window for the subsequent item * @param other - * the fallback ObservableSource to switch to if the source ObservableSource times out - * @return an Observable that mirrors the source ObservableSource, but switches to mirroring a fallback ObservableSource - * if an item emitted by the source ObservableSource takes longer to arrive than the time window defined + * the fallback {@code ObservableSource} to switch to if the current {@code Observable} times out + * @return an {@code Observable} that mirrors the current {@code Observable}, but switches to mirroring a fallback {@code ObservableSource} + * if an item emitted by the current {@code Observable} takes longer to arrive than the time window defined * by the selector for the previously emitted item * @see ReactiveX operators documentation: Timeout */ @@ -13928,9 +13940,9 @@ public final Observable timeout(@NonNull Function * *

@@ -13942,7 +13954,7 @@ public final Observable timeout(@NonNull FunctionReactiveX operators documentation: Timeout */ @@ -13954,9 +13966,9 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit) { } /** - * Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted + * Returns an {@code Observable} that mirrors the current {@code Observable} 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 source ObservableSource is disposed and resulting ObservableSource begins instead + * the current {@code Observable} is disposed and resulting {@code ObservableSource} begins instead * to mirror a fallback ObservableSource. *

* @@ -13970,8 +13982,8 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit) { * @param timeUnit * the unit of time that applies to the {@code timeout} argument * @param other - * the fallback ObservableSource to use in case of a timeout - * @return the source ObservableSource modified to switch to the fallback ObservableSource in case of a timeout + * the fallback {@code ObservableSource} to use in case of a timeout + * @return the current {@code Observable} modified to switch to the fallback {@code ObservableSource} in case of a timeout * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue @@ -13983,9 +13995,9 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No } /** - * Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted + * Returns an {@code Observable} that mirrors the current {@code Observable} 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 source ObservableSource is disposed and resulting ObservableSource + * starting from its predecessor, the current {@code Observable} is disposed and resulting {@code ObservableSource} * begins instead to mirror a fallback ObservableSource. *

* @@ -14001,8 +14013,8 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No * @param scheduler * the {@link Scheduler} to run the timeout timers on * @param other - * the ObservableSource to use as the fallback in case of a timeout - * @return the source ObservableSource modified so that it will switch to the fallback ObservableSource in case of a + * the {@code ObservableSource} to use as the fallback in case of a timeout + * @return the current {@code Observable} modified so that it will switch to the fallback {@code ObservableSource} in case of a * timeout * @see ReactiveX operators documentation: Timeout */ @@ -14015,9 +14027,9 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No } /** - * Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted + * Returns an {@code Observable} that mirrors the current {@code Observable} 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 ObservableSource terminates and + * specified timeout duration starting from its predecessor, the resulting {@code Observable} terminates and * notifies observers of a {@code TimeoutException}. *

* @@ -14032,7 +14044,7 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No * the unit of time that applies to the {@code timeout} argument * @param scheduler * the Scheduler to run the timeout timers on - * @return the source ObservableSource modified to notify observers of a {@code TimeoutException} in case of a + * @return the current {@code Observable} modified to notify observers of a {@code TimeoutException} in case of a * timeout * @see ReactiveX operators documentation: Timeout */ @@ -14044,9 +14056,9 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No } /** - * Returns an Observable that mirrors the source ObservableSource, but notifies observers of a - * {@code TimeoutException} if either the first item emitted by the source ObservableSource or any subsequent item - * doesn't arrive within time windows defined by other ObservableSources. + * Returns an {@code Observable} that mirrors the current {@code Observable}, but notifies observers of a + * {@code TimeoutException} if either the first item emitted by the current {@code Observable} or any subsequent item + * doesn't arrive within time windows defined by other {@code ObservableSource}s. *

* *

@@ -14059,13 +14071,13 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No * @param * the subsequent timeout value type (ignored) * @param firstTimeoutIndicator - * a function that returns an ObservableSource that determines the timeout window for the first source + * a function that returns an {@code ObservableSource} that determines the timeout window for the first source * item * @param itemTimeoutIndicator - * a function that returns an ObservableSource for each item emitted by the source ObservableSource and that + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable} and that * determines the timeout window in which the subsequent source item must arrive in order to * continue the sequence - * @return an Observable that mirrors the source ObservableSource, but notifies observers of a + * @return an {@code Observable} that mirrors the current {@code Observable}, but notifies observers of a * {@code TimeoutException} if either the first item or any subsequent item doesn't arrive within * the time windows specified by the timeout selectors * @see ReactiveX operators documentation: Timeout @@ -14080,9 +14092,9 @@ public final Observable timeout(@NonNull ObservableSource firstTime } /** - * Returns an Observable that mirrors the source ObservableSource, but switches to a fallback ObservableSource if either - * the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows - * defined by other ObservableSources. + * Returns an {@code Observable} that mirrors the current {@code Observable}, but switches to a fallback {@code ObservableSource} if either + * the first item emitted by the current {@code Observable} or any subsequent item doesn't arrive within time windows + * defined by other {@code ObservableSource}s. *

* *

@@ -14095,16 +14107,16 @@ public final Observable timeout(@NonNull ObservableSource firstTime * @param * the subsequent timeout value type (ignored) * @param firstTimeoutIndicator - * a function that returns an ObservableSource which determines the timeout window for the first source + * a function that returns an {@code ObservableSource} which determines the timeout window for the first source * item * @param itemTimeoutIndicator - * a function that returns an ObservableSource for each item emitted by the source ObservableSource and that + * a function that returns an {@code ObservableSource} for each item emitted by the current {@code Observable} and that * determines the timeout window in which the subsequent source item must arrive in order to * continue the sequence * @param other - * the fallback ObservableSource to switch to if the source ObservableSource times out - * @return an Observable that mirrors the source ObservableSource, but switches to the {@code other} ObservableSource if - * either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive + * the fallback {@code ObservableSource} to switch to if the current {@code Observable} times out + * @return an {@code Observable} that mirrors the current {@code Observable}, but switches to the {@code other} {@code ObservableSource} if + * either the first item emitted by the current {@code Observable} or any subsequent item doesn't arrive * within time windows defined by the timeout selectors * @throws NullPointerException * if {@code itemTimeoutIndicator} is null, or @@ -14142,7 +14154,7 @@ private Observable timeout0( } /** - * Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a + * Returns an {@code Observable} that emits each item emitted by the current {@code Observable}, wrapped in a * {@link Timed} object. *

* @@ -14152,7 +14164,7 @@ private Observable timeout0( * from the {@code computation} {@link Scheduler}. *

* - * @return an Observable that emits timestamped items from the source ObservableSource + * @return an {@code Observable} that emits timestamped items from the current {@code Observable} * @see ReactiveX operators documentation: Timestamp */ @CheckReturnValue @@ -14163,7 +14175,7 @@ public final Observable> timestamp() { } /** - * Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a + * Returns an {@code Observable} that emits each item emitted by the current {@code Observable}, wrapped in a * {@link Timed} object whose timestamps are provided by a specified Scheduler. *

* @@ -14175,7 +14187,7 @@ public final Observable> timestamp() { * * @param scheduler * the {@link Scheduler} to use as a time source - * @return an Observable that emits timestamped items from the source ObservableSource with timestamps provided by + * @return an {@code Observable} that emits timestamped items from the current {@code Observable} with timestamps provided by * the {@code scheduler} * @see ReactiveX operators documentation: Timestamp */ @@ -14187,7 +14199,7 @@ public final Observable> timestamp(@NonNull Scheduler scheduler) { } /** - * Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a + * Returns an {@code Observable} that emits each item emitted by the current {@code Observable}, wrapped in a * {@link Timed} object. *

* @@ -14198,7 +14210,7 @@ public final Observable> timestamp(@NonNull Scheduler scheduler) { *

* * @param unit the time unit for the current time - * @return an Observable that emits timestamped items from the source ObservableSource + * @return an {@code Observable} that emits timestamped items from the current {@code Observable} * @see ReactiveX operators documentation: Timestamp */ @CheckReturnValue @@ -14209,7 +14221,7 @@ public final Observable> timestamp(@NonNull TimeUnit unit) { } /** - * Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a + * Returns an {@code Observable} that emits each item emitted by the current {@code Observable}, wrapped in a * {@link Timed} object whose timestamps are provided by a specified Scheduler. *

* @@ -14222,7 +14234,7 @@ public final Observable> timestamp(@NonNull TimeUnit unit) { * @param unit the time unit for the current time * @param scheduler * the {@link Scheduler} to use as a time source - * @return an Observable that emits timestamped items from the source ObservableSource with timestamps provided by + * @return an {@code Observable} that emits timestamped items from the current {@code Observable} with timestamps provided by * the {@code scheduler} * @see ReactiveX operators documentation: Timestamp */ @@ -14245,7 +14257,7 @@ public final Observable> timestamp(@NonNull TimeUnit unit, @NonNull Sch *

*

History: 2.1.7 - experimental * @param the resulting object type - * @param converter the function that receives the current Observable instance and returns a value + * @param converter the function that receives the current {@code Observable} instance and returns a value * @return the converted value * @throws NullPointerException if converter is null * @since 2.2 @@ -14263,10 +14275,10 @@ public final R to(@NonNull ObservableConverter converter) { *

* *

- * Normally, an ObservableSource that returns multiple items will do so by invoking its {@link Observer}'s + * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the - * ObservableSource to compose a list of all of these items and then to invoke the Observer's {@code onNext} - * function once, passing it the entire list, by calling the ObservableSource's {@code toList} method prior to + * {@code ObservableSource} to compose a list of all of these items and then to invoke the Observer's {@code onNext} + * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to * calling its {@link #subscribe} method. *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulated list to @@ -14277,8 +14289,8 @@ public final R to(@NonNull ObservableConverter converter) { *

{@code toList} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a Single that emits a single item: a List containing all of the items emitted by the source - * ObservableSource + * @return a Single that emits a single item: a List containing all of the items emitted by the current + * {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14294,10 +14306,10 @@ public final R to(@NonNull ObservableConverter converter) { *

* *

- * Normally, an ObservableSource that returns multiple items will do so by invoking its {@link Observer}'s + * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the - * ObservableSource to compose a list of all of these items and then to invoke the Observer's {@code onNext} - * function once, passing it the entire list, by calling the ObservableSource's {@code toList} method prior to + * {@code ObservableSource} to compose a list of all of these items and then to invoke the Observer's {@code onNext} + * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to * calling its {@link #subscribe} method. *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulated list to @@ -14309,9 +14321,9 @@ public final R to(@NonNull ObservableConverter converter) { *

* * @param capacityHint - * the number of elements expected from the current Observable - * @return a Single that emits a single item: a List containing all of the items emitted by the source - * ObservableSource + * the number of elements expected from the current {@code Observable} + * @return a Single that emits a single item: a List containing all of the items emitted by the current + * {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14323,15 +14335,15 @@ public final R to(@NonNull ObservableConverter converter) { } /** - * Returns a Single that emits a single item, a list composed of all the items emitted by the - * finite source ObservableSource. + * Returns a {@link Single} that emits a single item, a list composed of all the items emitted by the + * finite upstream {@code Observable}. *

* *

- * Normally, an ObservableSource that returns multiple items will do so by invoking its {@link Observer}'s + * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the - * ObservableSource to compose a list of all of these items and then to invoke the Observer's {@code onNext} - * function once, passing it the entire list, by calling the ObservableSource's {@code toList} method prior to + * {@code ObservableSource} to compose a list of all of these items and then to invoke the Observer's {@code onNext} + * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to * calling its {@link #subscribe} method. *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulated collection to @@ -14345,8 +14357,8 @@ public final R to(@NonNull ObservableConverter converter) { * @param the subclass of a collection of Ts * @param collectionSupplier * the Supplier returning the collection (for each individual Observer) to be filled in - * @return a Single that emits a single item: a List containing all of the items emitted by the source - * ObservableSource + * @return a Single that emits a single item: a List containing all of the items emitted by the current + * {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14359,7 +14371,7 @@ public final R to(@NonNull ObservableConverter converter) { /** * Returns a Single that emits a single HashMap containing all items emitted by the - * finite source ObservableSource, mapped by the keys returned by a specified + * finite source {@code ObservableSource}, mapped by the keys returned by a specified * {@code keySelector} function. *

* @@ -14377,8 +14389,8 @@ public final R to(@NonNull ObservableConverter converter) { * @param the key type of the Map * @param keySelector * the function that extracts the key from a source item to be used in the HashMap - * @return a Single that emits a single item: a HashMap containing the mapped items from the source - * ObservableSource + * @return a Single that emits a single item: a HashMap containing the mapped items from the current + * {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14390,8 +14402,8 @@ public final R to(@NonNull ObservableConverter converter) { } /** - * Returns a Single that emits a single HashMap containing values corresponding to items emitted by the - * finite source ObservableSource, mapped by the keys returned by a specified {@code keySelector} function. + * Returns a {@link Single} that emits a single {@link HashMap} containing values corresponding to items emitted by the + * current and finite {@code Observable}, mapped by the keys returned by a specified {@code keySelector} function. *

* *

@@ -14409,11 +14421,11 @@ public final R to(@NonNull ObservableConverter converter) { * @param the key type of the Map * @param the value type of the Map * @param keySelector - * the function that extracts the key from a source item to be used in the HashMap + * the function that extracts the key from a source item to be used in the {@code HashMap} * @param valueSelector - * the function that extracts the value from a source item to be used in the HashMap - * @return a Single that emits a single item: a HashMap containing the mapped items from the source - * ObservableSource + * the function that extracts the value from a source item to be used in the {@code HashMap} + * @return a Single that emits a single item: a HashMap containing the mapped items from the current + * {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14450,7 +14462,7 @@ public final Single> toMap( * @param mapSupplier * the function that returns a Map instance to be used * @return a Single that emits a single item: a Map that contains the mapped items emitted by the - * source ObservableSource + * current {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14468,7 +14480,7 @@ public final Single> toMap( /** * Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the - * finite source ObservableSource keyed by a specified {@code keySelector} function. + * finite source {@code ObservableSource} keyed by a specified {@code keySelector} function. *

* *

@@ -14484,7 +14496,7 @@ public final Single> toMap( * @param keySelector * the function that extracts the key from the source items to be used as key in the HashMap * @return a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from - * the source ObservableSource + * the current {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14499,7 +14511,7 @@ public final Single> toMap( /** * Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a - * specified {@code valueSelector} function from items emitted by the finite source ObservableSource, + * specified {@code valueSelector} function from items emitted by the finite source {@code ObservableSource}, * keyed by a specified {@code keySelector} function. *

* @@ -14519,7 +14531,7 @@ public final Single> toMap( * @param valueSelector * the function that extracts a value from the source items to be used as value in the HashMap * @return a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from - * the source ObservableSource + * the current {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14534,7 +14546,7 @@ public final Single> toMap( /** * Returns a Single that emits a single Map, returned by a specified {@code mapFactory} function, that * contains a custom collection of values, extracted by a specified {@code valueSelector} function from - * items emitted by the source ObservableSource, and keyed by the {@code keySelector} function. + * items emitted by the current {@code Observable}, and keyed by the {@code keySelector} function. *

* *

@@ -14553,7 +14565,7 @@ public final Single> toMap( * @param collectionFactory * the function that returns a Collection instance for a particular key to be used in the Map * @return a Single that emits a single item: a Map that contains the collection of mapped items from - * the source ObservableSource + * the current {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14574,7 +14586,7 @@ public final Single> toMap( /** * Returns a Single that emits a single Map, returned by a specified {@code mapFactory} function, that * contains an ArrayList of values, extracted by a specified {@code valueSelector} function from items - * emitted by the finite source ObservableSource and keyed by the {@code keySelector} function. + * emitted by the finite source {@code ObservableSource} and keyed by the {@code keySelector} function. *

* *

@@ -14594,8 +14606,8 @@ public final Single> toMap( * the function that extracts a value from the source items to be used as the value in the Map * @param mapSupplier * the function that returns a Map instance to be used - * @return a Single that emits a single item: a Map that contains a list items mapped from the source - * ObservableSource + * @return a Single that emits a single item: a Map that contains a list items mapped from the current + * {@code Observable} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14610,7 +14622,7 @@ public final Single> toMap( } /** - * Converts the current Observable into a Flowable by applying the specified backpressure strategy. + * Converts the current {@code Observable} into a Flowable by applying the specified backpressure strategy. *

* Marble diagrams for the various backpressure strategies are as follows: *

    @@ -14667,12 +14679,12 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a - * sorted order. Each item emitted by the ObservableSource must implement {@link Comparable} with respect to all + * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a + * sorted order. Each item emitted by the {@code ObservableSource} must implement {@link Comparable} with respect to all * other items in the sequence. * - *

    If any item emitted by this Observable does not implement {@link Comparable} with respect to - * all other items emitted by this Observable, no items will be emitted and the + *

    If any item emitted by this {@code Observable} does not implement {@link Comparable} with respect to + * all other items emitted by this {@code Observable}, no items will be emitted and the * sequence is terminated with a {@link ClassCastException}. *

    * @@ -14684,7 +14696,7 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { *

    Scheduler:
    *
    {@code toSortedList} does not operate by default on a particular {@link Scheduler}.
    *
- * @return a Single that emits a list that contains the items emitted by the source ObservableSource in + * @return a Single that emits a list that contains the items emitted by the current {@code Observable} in * sorted order * @see ReactiveX operators documentation: To */ @@ -14696,7 +14708,7 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a + * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a * sorted order based on a specified comparison function. *

* @@ -14710,9 +14722,9 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { *

* * @param comparator - * a function that compares two items emitted by the source ObservableSource and returns an Integer + * a function that compares two items emitted by the current {@code Observable} and returns an Integer * that indicates their sort order - * @return a Single that emits a list that contains the items emitted by the source ObservableSource in + * @return a Single that emits a list that contains the items emitted by the current {@code Observable} in * sorted order * @see ReactiveX operators documentation: To */ @@ -14725,7 +14737,7 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a + * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a * sorted order based on a specified comparison function. *

* @@ -14739,11 +14751,11 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { * * * @param comparator - * a function that compares two items emitted by the source ObservableSource and returns an Integer + * a function that compares two items emitted by the current {@code Observable} and returns an Integer * that indicates their sort order * @param capacityHint * the initial capacity of the ArrayList used to accumulate items before sorting - * @return a Single that emits a list that contains the items emitted by the source ObservableSource in + * @return a Single that emits a list that contains the items emitted by the current {@code Observable} in * sorted order * @see ReactiveX operators documentation: To * @since 2.0 @@ -14757,12 +14769,12 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a - * sorted order. Each item emitted by the ObservableSource must implement {@link Comparable} with respect to all + * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a + * sorted order. Each item emitted by the {@code ObservableSource} must implement {@link Comparable} with respect to all * other items in the sequence. * - *

If any item emitted by this Observable does not implement {@link Comparable} with respect to - * all other items emitted by this Observable, no items will be emitted and the + *

If any item emitted by this {@code Observable} does not implement {@link Comparable} with respect to + * all other items emitted by this {@code Observable}, no items will be emitted and the * sequence is terminated with a {@link ClassCastException}. *

* @@ -14777,7 +14789,7 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { * * @param capacityHint * the initial capacity of the ArrayList used to accumulate items before sorting - * @return a Single that emits a list that contains the items emitted by the source ObservableSource in + * @return a Single that emits a list that contains the items emitted by the current {@code Observable} in * sorted order * @see ReactiveX operators documentation: To * @since 2.0 @@ -14790,7 +14802,7 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Modifies the source ObservableSource so that subscribers will dispose it on a specified + * Modifies the current {@code Observable} so that subscribers will dispose it on a specified * {@link Scheduler}. *

* @@ -14801,7 +14813,7 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { * * @param scheduler * the {@link Scheduler} to perform the call to dispose() of the upstream Disposable - * @return the source ObservableSource modified so that its dispose() calls happen on the specified + * @return the current {@code Observable} modified so that its dispose() calls happen on the specified * {@link Scheduler} * @see ReactiveX operators documentation: SubscribeOn */ @@ -14814,10 +14826,10 @@ public final Observable unsubscribeOn(@NonNull Scheduler scheduler) { } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping windows, each containing {@code count} items. When the source - * ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and - * propagates the notification from the source ObservableSource. + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping windows, each containing {@code count} items. When the current + * {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the current window and + * propagates the notification from the current {@code Observable}. *

* *

@@ -14827,8 +14839,8 @@ public final Observable unsubscribeOn(@NonNull Scheduler scheduler) { * * @param count * the maximum size of each window before it should be emitted - * @return an Observable that emits connected, non-overlapping windows, each containing at most - * {@code count} items from the source ObservableSource + * @return an {@code Observable} that emits connected, non-overlapping windows, each containing at most + * {@code count} items from the current {@code Observable} * @throws IllegalArgumentException if either count is non-positive * @see ReactiveX operators documentation: Window */ @@ -14840,10 +14852,10 @@ public final Observable> window(long count) { } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits windows every {@code skip} items, each containing no more than {@code count} items. When - * the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window - * and propagates the notification from the source ObservableSource. + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits windows every {@code skip} items, each containing no more than {@code count} items. When + * the current {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the current window + * and propagates the notification from the current {@code Observable}. *

* *

@@ -14856,8 +14868,8 @@ public final Observable> window(long count) { * @param skip * how many items need to be skipped before starting a new window. Note that if {@code skip} and * {@code count} are equal this is the same operation as {@link #window(long)}. - * @return an Observable that emits windows every {@code skip} items containing at most {@code count} items - * from the source ObservableSource + * @return an {@code Observable} that emits windows every {@code skip} items containing at most {@code count} items + * from the current {@code Observable} * @throws IllegalArgumentException if either count or skip is non-positive * @see ReactiveX operators documentation: Window */ @@ -14869,10 +14881,10 @@ public final Observable> window(long count, long skip) { } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits windows every {@code skip} items, each containing no more than {@code count} items. When - * the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window - * and propagates the notification from the source ObservableSource. + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits windows every {@code skip} items, each containing no more than {@code count} items. When + * the current {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the current window + * and propagates the notification from the current {@code Observable}. *

* *

@@ -14887,8 +14899,8 @@ public final Observable> window(long count, long skip) { * {@code count} are equal this is the same operation as {@link #window(long)}. * @param bufferSize * the capacity hint for the buffer in the inner windows - * @return an Observable that emits windows every {@code skip} items containing at most {@code count} items - * from the source ObservableSource + * @return an {@code Observable} that emits windows every {@code skip} items containing at most {@code count} items + * from the current {@code Observable} * @throws IllegalArgumentException if either count or skip is non-positive * @see ReactiveX operators documentation: Window */ @@ -14903,11 +14915,11 @@ public final Observable> window(long count, long skip, int bufferS } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource starts a new window periodically, as determined by the {@code timeskip} argument. It emits - * each window after a fixed timespan, specified by the {@code timespan} argument. When the source - * ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the - * current window and propagates the notification from the source ObservableSource. + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} starts a new window periodically, as determined by the {@code timeskip} argument. It emits + * each window after a fixed timespan, specified by the {@code timespan} argument. When the current + * {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the + * current window and propagates the notification from the current {@code Observable}. *

* *

@@ -14926,7 +14938,7 @@ public final Observable> window(long count, long skip, int bufferS * the period of time after which a new window will be created * @param unit * the unit of time that applies to the {@code timespan} and {@code timeskip} arguments - * @return an Observable that emits new windows periodically as a fixed timespan elapses + * @return an {@code Observable} that emits new windows periodically as a fixed timespan elapses * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -14937,11 +14949,11 @@ public final Observable> window(long timespan, long timeskip, @Non } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource starts a new window periodically, as determined by the {@code timeskip} argument. It emits - * each window after a fixed timespan, specified by the {@code timespan} argument. When the source - * ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the - * current window and propagates the notification from the source ObservableSource. + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} starts a new window periodically, as determined by the {@code timeskip} argument. It emits + * each window after a fixed timespan, specified by the {@code timespan} argument. When the current + * {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the + * current window and propagates the notification from the current {@code Observable}. *

* *

@@ -14962,7 +14974,7 @@ public final Observable> window(long timespan, long timeskip, @Non * the unit of time that applies to the {@code timespan} and {@code timeskip} arguments * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window - * @return an Observable that emits new windows periodically as a fixed timespan elapses + * @return an {@code Observable} that emits new windows periodically as a fixed timespan elapses * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -14973,11 +14985,11 @@ public final Observable> window(long timespan, long timeskip, @Non } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource starts a new window periodically, as determined by the {@code timeskip} argument. It emits - * each window after a fixed timespan, specified by the {@code timespan} argument. When the source - * ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the - * current window and propagates the notification from the source ObservableSource. + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} starts a new window periodically, as determined by the {@code timeskip} argument. It emits + * each window after a fixed timespan, specified by the {@code timespan} argument. When the current + * {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the + * current window and propagates the notification from the current {@code Observable}. *

* *

@@ -15000,7 +15012,7 @@ public final Observable> window(long timespan, long timeskip, @Non * the {@link Scheduler} to use when determining the end and start of a window * @param bufferSize * the capacity hint for the buffer in the inner windows - * @return an Observable that emits new windows periodically as a fixed timespan elapses + * @return an {@code Observable} that emits new windows periodically as a fixed timespan elapses * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15016,10 +15028,10 @@ public final Observable> window(long timespan, long timeskip, @Non } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by the - * {@code timespan} argument. When the source ObservableSource completes or encounters an error, the resulting - * ObservableSource emits the current window and propagates the notification from the source ObservableSource. + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping windows, each of a fixed duration specified by the + * {@code timespan} argument. When the current {@code Observable} completes or encounters an error, the resulting + * {@code Observable} emits the current window and propagates the notification from the current {@code Observable}. *

* *

@@ -15037,8 +15049,8 @@ public final Observable> window(long timespan, long timeskip, @Non * new window * @param unit * the unit of time that applies to the {@code timespan} argument - * @return an Observable that emits connected, non-overlapping windows representing items emitted by the - * source ObservableSource during fixed, consecutive durations + * @return an {@code Observable} that emits connected, non-overlapping windows representing items emitted by the + * current {@code Observable} during fixed, consecutive durations * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15049,11 +15061,11 @@ public final Observable> window(long timespan, @NonNull TimeUnit u } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping windows, each of a fixed duration as specified by the + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping windows, each of a fixed duration as specified by the * {@code timespan} argument or a maximum size as specified by the {@code count} argument (whichever is - * reached first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource - * emits the current window and propagates the notification from the source ObservableSource. + * reached first). When the current {@code Observable} completes or encounters an error, the resulting {@code Observable} + * emits the current window and propagates the notification from the current {@code Observable}. *

* *

@@ -15073,7 +15085,7 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * the unit of time that applies to the {@code timespan} argument * @param count * the maximum size of each window before it should be emitted - * @return an Observable that emits connected, non-overlapping windows of items from the source ObservableSource + * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) * @see ReactiveX operators documentation: Window @@ -15087,11 +15099,11 @@ public final Observable> window(long timespan, @NonNull TimeUnit u } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping windows, each of a fixed duration as specified by the + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping windows, each of a fixed duration as specified by the * {@code timespan} argument or a maximum size as specified by the {@code count} argument (whichever is - * reached first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource - * emits the current window and propagates the notification from the source ObservableSource. + * reached first). When the current {@code Observable} completes or encounters an error, the resulting {@code Observable} + * emits the current window and propagates the notification from the current {@code Observable}. *

* *

@@ -15112,8 +15124,8 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @param count * the maximum size of each window before it should be emitted * @param restart - * if true, when a window reaches the capacity limit, the timer is restarted as well - * @return an Observable that emits connected, non-overlapping windows of items from the source ObservableSource + * if {@code true}, when a window reaches the capacity limit, the timer is restarted as well + * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) * @see ReactiveX operators documentation: Window @@ -15127,10 +15139,10 @@ public final Observable> window(long timespan, @NonNull TimeUnit u } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping windows, each of a fixed duration as specified by the - * {@code timespan} argument. When the source ObservableSource completes or encounters an error, the resulting - * ObservableSource emits the current window and propagates the notification from the source ObservableSource. + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping windows, each of a fixed duration as specified by the + * {@code timespan} argument. When the current {@code Observable} completes or encounters an error, the resulting + * {@code Observable} emits the current window and propagates the notification from the current {@code Observable}. *

* *

@@ -15150,8 +15162,8 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * the unit of time which applies to the {@code timespan} argument * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window - * @return an Observable that emits connected, non-overlapping windows containing items emitted by the - * source ObservableSource within a fixed duration + * @return an {@code Observable} that emits connected, non-overlapping windows containing items emitted by the + * current {@code Observable} within a fixed duration * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15163,11 +15175,11 @@ public final Observable> window(long timespan, @NonNull TimeUnit u } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by the + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping windows, each of a fixed duration specified by the * {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached - * first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the - * current window and propagates the notification from the source ObservableSource. + * first). When the current {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the + * current window and propagates the notification from the current {@code Observable}. *

* *

@@ -15189,7 +15201,7 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * the maximum size of each window before it should be emitted * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window - * @return an Observable that emits connected, non-overlapping windows of items from the source ObservableSource + * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) * @see ReactiveX operators documentation: Window @@ -15203,11 +15215,11 @@ public final Observable> window(long timespan, @NonNull TimeUnit u } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by the + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping windows, each of a fixed duration specified by the * {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached - * first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the - * current window and propagates the notification from the source ObservableSource. + * first). When the current {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the + * current window and propagates the notification from the current {@code Observable}. *

* *

@@ -15230,8 +15242,8 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window * @param restart - * if true, when a window reaches the capacity limit, the timer is restarted as well - * @return an Observable that emits connected, non-overlapping windows of items from the source ObservableSource + * if {@code true}, when a window reaches the capacity limit, the timer is restarted as well + * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) * @see ReactiveX operators documentation: Window @@ -15245,11 +15257,11 @@ public final Observable> window(long timespan, @NonNull TimeUnit u } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by the + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits connected, non-overlapping windows, each of a fixed duration specified by the * {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached - * first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the - * current window and propagates the notification from the source ObservableSource. + * first). When the current {@code Observable} completes or encounters an error, the resulting {@code Observable} emits the + * current window and propagates the notification from the current {@code Observable}. *

* *

@@ -15272,10 +15284,10 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @param scheduler * the {@link Scheduler} to use when determining the end and start of a window * @param restart - * if true, when a window reaches the capacity limit, the timer is restarted as well + * if {@code true}, when a window reaches the capacity limit, the timer is restarted as well * @param bufferSize * the capacity hint for the buffer in the inner windows - * @return an Observable that emits connected, non-overlapping windows of items from the source ObservableSource + * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) * @see ReactiveX operators documentation: Window @@ -15294,7 +15306,7 @@ public final Observable> window( } /** - * Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource + * Returns an {@code Observable} that emits non-overlapping windows of items it collects from the current {@code Observable} * where the boundary of each window is determined by the items emitted from a specified boundary-governing * ObservableSource. *

@@ -15312,10 +15324,10 @@ public final Observable> window( * @param * the window element type (ignored) * @param boundary - * an ObservableSource whose emitted items close and open windows - * @return an Observable that emits non-overlapping windows of items it collects from the source ObservableSource + * an {@code ObservableSource} whose emitted items close and open windows + * @return an {@code Observable} that emits non-overlapping windows of items it collects from the current {@code Observable} * where the boundary of each window is determined by the items emitted from the {@code boundary} - * ObservableSource + * {@code ObservableSource} * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15326,7 +15338,7 @@ public final Observable> window(@NonNull ObservableSource b } /** - * Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource + * Returns an {@code Observable} that emits non-overlapping windows of items it collects from the current {@code Observable} * where the boundary of each window is determined by the items emitted from a specified boundary-governing * ObservableSource. *

@@ -15344,12 +15356,12 @@ public final Observable> window(@NonNull ObservableSource b * @param * the window element type (ignored) * @param boundary - * an ObservableSource whose emitted items close and open windows + * an {@code ObservableSource} whose emitted items close and open windows * @param bufferSize * the capacity hint for the buffer in the inner windows - * @return an Observable that emits non-overlapping windows of items it collects from the source ObservableSource + * @return an {@code Observable} that emits non-overlapping windows of items it collects from the current {@code Observable} * where the boundary of each window is determined by the items emitted from the {@code boundary} - * ObservableSource + * {@code ObservableSource} * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15362,9 +15374,9 @@ public final Observable> window(@NonNull ObservableSource b } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits windows that contain those items emitted by the source ObservableSource between the time when - * the {@code openingIndicator} ObservableSource emits an item and when the ObservableSource returned by + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits windows that contain those items emitted by the current {@code Observable} between the time when + * the {@code openingIndicator} {@code ObservableSource} emits an item and when the {@code ObservableSource} returned by * {@code closingIndicator} emits an item. *

* @@ -15378,15 +15390,15 @@ public final Observable> window(@NonNull ObservableSource b *

This version of {@code window} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the element type of the window-opening ObservableSource - * @param the element type of the window-closing ObservableSources + * @param the element type of the window-opening {@code ObservableSource} + * @param the element type of the window-closing {@code ObservableSource}s * @param openingIndicator - * an ObservableSource that, when it emits an item, causes another window to be created + * an {@code ObservableSource} that, when it emits an item, causes another window to be created * @param closingIndicator - * a {@link Function} that produces an ObservableSource for every window created. When this ObservableSource + * a {@link Function} that produces an {@code ObservableSource} for every window created. When this {@code ObservableSource} * emits an item, the associated window is closed and emitted - * @return an Observable that emits windows of items emitted by the source ObservableSource that are governed by - * the specified window-governing ObservableSources + * @return an {@code Observable} that emits windows of items emitted by the current {@code Observable} that are governed by + * the specified window-governing {@code ObservableSource}s * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15399,9 +15411,9 @@ public final Observable> window( } /** - * Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting - * ObservableSource emits windows that contain those items emitted by the source ObservableSource between the time when - * the {@code openingIndicator} ObservableSource emits an item and when the ObservableSource returned by + * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting + * {@code Observable} emits windows that contain those items emitted by the current {@code Observable} between the time when + * the {@code openingIndicator} {@code ObservableSource} emits an item and when the {@code ObservableSource} returned by * {@code closingIndicator} emits an item. *

* @@ -15415,17 +15427,17 @@ public final Observable> window( *

This version of {@code window} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the element type of the window-opening ObservableSource - * @param the element type of the window-closing ObservableSources + * @param the element type of the window-opening {@code ObservableSource} + * @param the element type of the window-closing {@code ObservableSource}s * @param openingIndicator - * an ObservableSource that, when it emits an item, causes another window to be created + * an {@code ObservableSource} that, when it emits an item, causes another window to be created * @param closingIndicator - * a {@link Function} that produces an ObservableSource for every window created. When this ObservableSource + * a {@link Function} that produces an {@code ObservableSource} for every window created. When this {@code ObservableSource} * emits an item, the associated window is closed and emitted * @param bufferSize * the capacity hint for the buffer in the inner windows - * @return an Observable that emits windows of items emitted by the source ObservableSource that are governed by - * the specified window-governing ObservableSources + * @return an {@code Observable} that emits windows of items emitted by the current {@code Observable} that are governed by + * the specified window-governing {@code ObservableSource}s * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15441,8 +15453,8 @@ public final Observable> window( } /** - * Merges the specified ObservableSource into this ObservableSource sequence by using the {@code resultSelector} - * function only when the source ObservableSource (this instance) emits an item. + * Merges the specified {@code ObservableSource} into this {@code ObservableSource} sequence by using the {@code resultSelector} + * function only when the current {@code Observable} (this instance) emits an item. *

* * @@ -15451,15 +15463,15 @@ public final Observable> window( *

This operator, by default, doesn't run any particular {@link Scheduler}.
*
* - * @param the element type of the other ObservableSource + * @param the element type of the other {@code ObservableSource} * @param the result type of the combination * @param other - * the other ObservableSource + * the other {@code ObservableSource} * @param combiner - * the function to call when this ObservableSource emits an item and the other ObservableSource has already - * emitted an item, to generate the item to be emitted by the resulting ObservableSource - * @return an Observable that merges the specified ObservableSource into this ObservableSource by using the - * {@code resultSelector} function only when the source ObservableSource sequence (this instance) emits an + * the function to call when this {@code ObservableSource} emits an item and the other {@code ObservableSource} has already + * emitted an item, to generate the item to be emitted by the resulting {@code Observable} + * @return an {@code Observable} that merges the specified {@code ObservableSource} into this {@code ObservableSource} by using the + * {@code resultSelector} function only when the current {@code Observable} sequence (this instance) emits an * item * @since 2.0 * @see ReactiveX operators documentation: CombineLatest @@ -15475,11 +15487,11 @@ public final Observable withLatestFrom(@NonNull ObservableSourceNote that this operator doesn't emit anything until all other sources have produced at - * least one value. The resulting emission only happens when this ObservableSource emits (and + * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and * not when any of the other sources emit, unlike combineLatest). * If a source doesn't produce any value and just completes, the sequence is completed immediately. *

@@ -15492,10 +15504,10 @@ public final Observable withLatestFrom(@NonNull ObservableSource the first other source's value type * @param the second other source's value type * @param the result value type - * @param source1 the first other ObservableSource - * @param source2 the second other ObservableSource - * @param combiner the function called with an array of values from each participating ObservableSource - * @return the new ObservableSource instance + * @param source1 the first other {@code ObservableSource} + * @param source2 the second other {@code ObservableSource} + * @param combiner the function called with an array of values from each participating {@code ObservableSource} + * @return the new {@code ObservableSource} instance * @since 2.0 */ @CheckReturnValue @@ -15512,11 +15524,11 @@ public final Observable withLatestFrom( } /** - * Combines the value emission from this ObservableSource with the latest emissions from the - * other ObservableSources via a function to produce the output item. + * Combines the value emission from this {@code ObservableSource} with the latest emissions from the + * other {@code ObservableSource}s via a function to produce the output item. * *

Note that this operator doesn't emit anything until all other sources have produced at - * least one value. The resulting emission only happens when this ObservableSource emits (and + * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and * not when any of the other sources emit, unlike combineLatest). * If a source doesn't produce any value and just completes, the sequence is completed immediately. *

@@ -15530,11 +15542,11 @@ public final Observable withLatestFrom( * @param the second other source's value type * @param the third other source's value type * @param the result value type - * @param source1 the first other ObservableSource - * @param source2 the second other ObservableSource - * @param source3 the third other ObservableSource - * @param combiner the function called with an array of values from each participating ObservableSource - * @return the new ObservableSource instance + * @param source1 the first other {@code ObservableSource} + * @param source2 the second other {@code ObservableSource} + * @param source3 the third other {@code ObservableSource} + * @param combiner the function called with an array of values from each participating {@code ObservableSource} + * @return the new {@code ObservableSource} instance * @since 2.0 */ @CheckReturnValue @@ -15553,11 +15565,11 @@ public final Observable withLatestFrom( } /** - * Combines the value emission from this ObservableSource with the latest emissions from the - * other ObservableSources via a function to produce the output item. + * Combines the value emission from this {@code ObservableSource} with the latest emissions from the + * other {@code ObservableSource}s via a function to produce the output item. * *

Note that this operator doesn't emit anything until all other sources have produced at - * least one value. The resulting emission only happens when this ObservableSource emits (and + * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and * not when any of the other sources emit, unlike combineLatest). * If a source doesn't produce any value and just completes, the sequence is completed immediately. *

@@ -15572,12 +15584,12 @@ public final Observable withLatestFrom( * @param the third other source's value type * @param the fourth other source's value type * @param the result value type - * @param source1 the first other ObservableSource - * @param source2 the second other ObservableSource - * @param source3 the third other ObservableSource - * @param source4 the fourth other ObservableSource - * @param combiner the function called with an array of values from each participating ObservableSource - * @return the new ObservableSource instance + * @param source1 the first other {@code ObservableSource} + * @param source2 the second other {@code ObservableSource} + * @param source3 the third other {@code ObservableSource} + * @param source4 the fourth other {@code ObservableSource} + * @param combiner the function called with an array of values from each participating {@code ObservableSource} + * @return the new {@code ObservableSource} instance * @since 2.0 */ @CheckReturnValue @@ -15597,11 +15609,11 @@ public final Observable withLatestFrom( } /** - * Combines the value emission from this ObservableSource with the latest emissions from the - * other ObservableSources via a function to produce the output item. + * Combines the value emission from this {@code ObservableSource} with the latest emissions from the + * other {@code ObservableSource}s via a function to produce the output item. * *

Note that this operator doesn't emit anything until all other sources have produced at - * least one value. The resulting emission only happens when this ObservableSource emits (and + * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and * not when any of the other sources emit, unlike combineLatest). * If a source doesn't produce any value and just completes, the sequence is completed immediately. *

@@ -15613,8 +15625,8 @@ public final Observable withLatestFrom( * * @param the result value type * @param others the array of other sources - * @param combiner the function called with an array of values from each participating ObservableSource - * @return the new ObservableSource instance + * @param combiner the function called with an array of values from each participating {@code ObservableSource} + * @return the new {@code ObservableSource} instance * @since 2.0 */ @CheckReturnValue @@ -15627,11 +15639,11 @@ public final Observable withLatestFrom(@NonNull ObservableSource[] oth } /** - * Combines the value emission from this ObservableSource with the latest emissions from the - * other ObservableSources via a function to produce the output item. + * Combines the value emission from this {@code ObservableSource} with the latest emissions from the + * other {@code ObservableSource}s via a function to produce the output item. * *

Note that this operator doesn't emit anything until all other sources have produced at - * least one value. The resulting emission only happens when this ObservableSource emits (and + * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and * not when any of the other sources emit, unlike combineLatest). * If a source doesn't produce any value and just completes, the sequence is completed immediately. *

@@ -15643,8 +15655,8 @@ public final Observable withLatestFrom(@NonNull ObservableSource[] oth * * @param the result value type * @param others the iterable of other sources - * @param combiner the function called with an array of values from each participating ObservableSource - * @return the new ObservableSource instance + * @param combiner the function called with an array of values from each participating {@code ObservableSource} + * @return the new {@code ObservableSource} instance * @since 2.0 */ @CheckReturnValue @@ -15657,12 +15669,12 @@ public final Observable withLatestFrom(@NonNull Iterable * *

- * Note that the {@code other} Iterable is evaluated as items are observed from the source ObservableSource; it is + * Note that the {@code other} Iterable is evaluated as items are observed from the current {@code Observable}; it is * not pre-consumed. This allows you to zip infinite streams on either side. *

*
Scheduler:
@@ -15672,13 +15684,13 @@ public final Observable withLatestFrom(@NonNull Iterable * the type of items in the {@code other} Iterable * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param other * the Iterable sequence * @param zipper - * a function that combines the pairs of items from the ObservableSource and the Iterable to generate - * the items to be emitted by the resulting ObservableSource - * @return an Observable that pairs up values from the source ObservableSource and the {@code other} Iterable + * a function that combines the pairs of items from the {@code ObservableSource} and the Iterable to generate + * the items to be emitted by the resulting {@code Observable} + * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} Iterable * sequence and emits the results of {@code zipFunction} applied to these pairs * @see ReactiveX operators documentation: Zip */ @@ -15692,8 +15704,8 @@ public final Observable zipWith(@NonNull Iterable other, @NonNull B } /** - * Returns an Observable that emits items that are the result of applying a specified function to pairs of - * values, one each from the source ObservableSource and another specified ObservableSource. + * Returns an {@code Observable} that emits items that are the result of applying a specified function to pairs of + * values, one each from the current {@code Observable} and another specified ObservableSource. *

* *

@@ -15714,15 +15726,15 @@ public final Observable zipWith(@NonNull Iterable other, @NonNull B *

* * @param - * the type of items emitted by the {@code other} ObservableSource + * the type of items emitted by the {@code other} {@code ObservableSource} * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param other - * the other ObservableSource + * the other {@code ObservableSource} * @param zipper - * a function that combines the pairs of items from the two ObservableSources to generate the items to - * be emitted by the resulting ObservableSource - * @return an Observable that pairs up values from the source ObservableSource and the {@code other} ObservableSource + * a function that combines the pairs of items from the two {@code ObservableSource}s to generate the items to + * be emitted by the resulting {@code Observable} + * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} {@code ObservableSource} * and emits the results of {@code zipFunction} applied to these pairs * @see ReactiveX operators documentation: Zip */ @@ -15736,8 +15748,8 @@ public final Observable zipWith(@NonNull ObservableSource } /** - * Returns an Observable that emits items that are the result of applying a specified function to pairs of - * values, one each from the source ObservableSource and another specified ObservableSource. + * Returns an {@code Observable} that emits items that are the result of applying a specified function to pairs of + * values, one each from the current {@code Observable} and another specified ObservableSource. *

* *

@@ -15758,17 +15770,17 @@ public final Observable zipWith(@NonNull ObservableSource * * * @param - * the type of items emitted by the {@code other} ObservableSource + * the type of items emitted by the {@code other} {@code ObservableSource} * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param other - * the other ObservableSource + * the other {@code ObservableSource} * @param zipper - * a function that combines the pairs of items from the two ObservableSources to generate the items to - * be emitted by the resulting ObservableSource + * a function that combines the pairs of items from the two {@code ObservableSource}s to generate the items to + * be emitted by the resulting {@code Observable} * @param delayError - * if true, errors from the current Observable or the other ObservableSource is delayed until both terminate - * @return an Observable that pairs up values from the source ObservableSource and the {@code other} ObservableSource + * if {@code true}, errors from the current {@code Observable} or the other {@code ObservableSource} is delayed until both terminate + * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} {@code ObservableSource} * and emits the results of {@code zipFunction} applied to these pairs * @see ReactiveX operators documentation: Zip * @since 2.0 @@ -15782,8 +15794,8 @@ public final Observable zipWith(@NonNull ObservableSource } /** - * Returns an Observable that emits items that are the result of applying a specified function to pairs of - * values, one each from the source ObservableSource and another specified ObservableSource. + * Returns an {@code Observable} that emits items that are the result of applying a specified function to pairs of + * values, one each from the current {@code Observable} and another specified ObservableSource. *

* *

@@ -15804,19 +15816,19 @@ public final Observable zipWith(@NonNull ObservableSource * * * @param - * the type of items emitted by the {@code other} ObservableSource + * the type of items emitted by the {@code other} {@code ObservableSource} * @param - * the type of items emitted by the resulting ObservableSource + * the type of items emitted by the resulting {@code Observable} * @param other - * the other ObservableSource + * the other {@code ObservableSource} * @param zipper - * a function that combines the pairs of items from the two ObservableSources to generate the items to - * be emitted by the resulting ObservableSource + * a function that combines the pairs of items from the two {@code ObservableSource}s to generate the items to + * be emitted by the resulting {@code Observable} * @param bufferSize * the capacity hint for the buffer in the inner windows * @param delayError - * if true, errors from the current Observable or the other ObservableSource is delayed until both terminate - * @return an Observable that pairs up values from the source ObservableSource and the {@code other} ObservableSource + * if {@code true}, errors from the current {@code Observable} or the other {@code ObservableSource} is delayed until both terminate + * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} {@code ObservableSource} * and emits the results of {@code zipFunction} applied to these pairs * @see ReactiveX operators documentation: Zip * @since 2.0 @@ -15834,7 +15846,7 @@ public final Observable zipWith(@NonNull ObservableSource // ------------------------------------------------------------------------- /** * Creates a TestObserver and subscribes - * it to this Observable. + * it to this {@code Observable}. *

*
Scheduler:
*
{@code test} does not operate by default on a particular {@link Scheduler}.
@@ -15853,7 +15865,7 @@ public final TestObserver test() { // NoPMD /** * Creates a TestObserver, optionally disposes it and then subscribes - * it to this Observable. + * it to this {@code Observable}. * *
*
Scheduler:
@@ -15897,7 +15909,7 @@ public final TestObserver test(boolean dispose) { // NoPMD *
* @param the element type of the optional value * @param optional the optional value to convert into an {@code Observable} - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 3.0.0 * @see #just(Object) * @see #empty() @@ -15931,8 +15943,8 @@ public final TestObserver test(boolean dispose) { // NoPMD *
{@code fromCompletionStage} does not operate by default on a particular {@link Scheduler}.
*
* @param the element type of the CompletionStage - * @param stage the CompletionStage to convert to Observable and signal its terminal value or error - * @return the new Observable instance + * @param stage the CompletionStage to convert to {@code Observable} and signal its terminal value or error + * @return the new {@code Observable} instance * @since 3.0.0 */ @CheckReturnValue @@ -15973,7 +15985,7 @@ public final TestObserver test(boolean dispose) { // NoPMD * * @param the element type of the source {@code Stream} * @param stream the {@code Stream} of values to emit - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 3.0.0 * @see #fromIterable(Iterable) */ @@ -15997,7 +16009,7 @@ public final TestObserver test(boolean dispose) { // NoPMD * @param the non-null output type * @param mapper the function that receives the upstream item and should return a non-empty {@code Optional} * to emit as the output or an empty {@code Optional} to skip to the next upstream value - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 3.0.0 * @see #map(Function) * @see #filter(Predicate) @@ -16316,7 +16328,7 @@ public final Stream blockingStream(int capacityHint) { * @param the element type of the {@code Stream}s and the result * @param mapper the function that receives an upstream item and should return a {@code Stream} whose elements * will be emitted to the downstream - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 3.0.0 * @see #concatMap(Function) * @see #concatMapIterable(Function) @@ -16363,7 +16375,7 @@ public final Stream blockingStream(int capacityHint) { * @param the element type of the {@code Stream}s and the result * @param mapper the function that receives an upstream item and should return a {@code Stream} whose elements * will be emitted to the downstream - * @return the new Observable instance + * @return the new {@code Observable} instance * @since 3.0.0 * @see #flatMap(Function) * @see #flatMapIterable(Function) diff --git a/src/test/java/io/reactivex/rxjava3/validators/JavadocCodesAndLinks.java b/src/test/java/io/reactivex/rxjava3/validators/JavadocCodesAndLinks.java index 222409ef3c..30dc074813 100644 --- a/src/test/java/io/reactivex/rxjava3/validators/JavadocCodesAndLinks.java +++ b/src/test/java/io/reactivex/rxjava3/validators/JavadocCodesAndLinks.java @@ -50,8 +50,13 @@ public void checkMaybe() throws Exception { checkSource("Maybe", "io.reactivex.rxjava3.core"); } + @Test + public void checkObservable() throws Exception { + checkSource("Observable", "io.reactivex.rxjava3.core"); + } + static void checkSource(String baseClassName, String packageName) throws Exception { - File f = TestHelper.findSource(baseClassName); + File f = TestHelper.findSource(baseClassName, packageName); if (f == null) { return; } diff --git a/src/test/java/io/reactivex/rxjava3/validators/JavadocWording.java b/src/test/java/io/reactivex/rxjava3/validators/JavadocWording.java index e5746cc69b..4bcb1c41c1 100644 --- a/src/test/java/io/reactivex/rxjava3/validators/JavadocWording.java +++ b/src/test/java/io/reactivex/rxjava3/validators/JavadocWording.java @@ -990,5 +990,5 @@ static void backpressureMentionedWithoutAnnotation(StringBuilder e, RxMethod m, } } - static final String[] AT_RETURN_WORDS = { "@return a ", "@return the new ", "@return a new " }; + static final String[] AT_RETURN_WORDS = { "@return a ", "@return an ", "@return the new ", "@return a new " }; } diff --git a/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java b/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java index 12b0d43dc4..51db4406d6 100644 --- a/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java +++ b/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java @@ -223,7 +223,8 @@ static void processFile(Class clazz) throws Exception { // FIXME enable for other types in separate PR! if (!baseClassName.equals("Completable") && !baseClassName.equals("Single") - && !baseClassName.equals("Maybe")) { + && !baseClassName.equals("Maybe") + && !baseClassName.equals("Observable")) { continue; } From ceb226d7dc42e89c90ca03dd1333dc81b4df88b1 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Wed, 8 Jan 2020 17:07:00 +0100 Subject: [PATCH 2/3] Another set of cleanups (too many things to fix at once) --- .../io/reactivex/rxjava3/core/Flowable.java | 42 +- .../io/reactivex/rxjava3/core/Observable.java | 1036 +++++++++-------- .../validators/ParamValidationNaming.java | 3 +- 3 files changed, 553 insertions(+), 528 deletions(-) diff --git a/src/main/java/io/reactivex/rxjava3/core/Flowable.java b/src/main/java/io/reactivex/rxjava3/core/Flowable.java index eb740f161b..66d0b26a8d 100644 --- a/src/main/java/io/reactivex/rxjava3/core/Flowable.java +++ b/src/main/java/io/reactivex/rxjava3/core/Flowable.java @@ -4457,7 +4457,7 @@ public static Flowable using( * @param resourceDisposer * the function that will dispose of the resource * @param eager - * If {@code true} then resource disposal will happen either on a {@code cancel()} call before the upstream is disposed + * If {@code true}, the resource disposal will happen either on a {@code cancel()} call before the upstream is disposed * or just before the emission of a terminal event ({@code onComplete} or {@code onError}). * If {@code false} the resource disposal will happen either on a {@code cancel()} call after the upstream is disposed * or just after the emission of a terminal event ({@code onComplete} or {@code onError}). @@ -10144,8 +10144,8 @@ public final Completable flatMapCompletable(@NonNull Function * *
@@ -10158,12 +10158,11 @@ public final Completable flatMapCompletable(@NonNull Function * * @param - * the type of item emitted by the resulting {@code Iterable} + * the output type and the element type of the {@code Iterable}s * @param mapper * a function that returns an {@code Iterable} sequence of values for when given an item emitted by the * source {@code Publisher} - * @return a {@code Flowable} that emits the results of merging the items emitted by the source {@code Publisher} with - * the values in the {@code Iterable}s corresponding to those items, as generated by {@code collectionSelector} + * @return the new {@code Flowable} instance * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -10175,8 +10174,8 @@ public final Flowable flatMapIterable(@NonNull Function * *
@@ -10195,8 +10194,7 @@ public final Flowable flatMapIterable(@NonNull FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -10210,8 +10208,10 @@ public final Flowable flatMapIterable(@NonNull Function * *
@@ -10223,9 +10223,9 @@ public final Flowable flatMapIterable(@NonNull Function * * @param - * the collection element type + * the element type of the {@code Iterable}s * @param - * the type of item emitted by the resulting {@code Iterable} + * the output type as determined by the {@code resultSelector} function * @param mapper * a function that returns an {@code Iterable} sequence of values for each item emitted by the source * {@code Publisher} @@ -10248,9 +10248,10 @@ public final Flowable flatMapIterable(@NonNull Function * *
@@ -10274,8 +10275,7 @@ public final Flowable flatMapIterable(@NonNull FunctionReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -11622,7 +11622,7 @@ public final Flowable observeOn(@NonNull Scheduler scheduler) { * the {@code Scheduler} to notify {@link Subscriber}s on * @param delayError * indicates if the {@code onError} notification may not cut ahead of {@code onNext} notification on the other side of the - * scheduling boundary. If {@code true} a sequence ending in {@code onError} will be replayed in the same order as was received + * scheduling boundary. If {@code true}, a sequence ending in {@code onError} will be replayed in the same order as was received * from upstream * @return the source {@code Publisher} modified so that its {@code Subscriber}s are notified on the specified * {@code Scheduler} @@ -11674,7 +11674,7 @@ public final Flowable observeOn(@NonNull Scheduler scheduler, boolean delayEr * the {@code Scheduler} to notify {@link Subscriber}s on * @param delayError * indicates if the {@code onError} notification may not cut ahead of {@code onNext} notification on the other side of the - * scheduling boundary. If {@code true} a sequence ending in {@code onError} will be replayed in the same order as was received + * scheduling boundary. If {@code true}, a sequence ending in {@code onError} will be replayed in the same order as was received * from upstream * @param bufferSize the size of the buffer. * @return the source {@code Publisher} modified so that its {@code Subscriber}s are notified on the specified diff --git a/src/main/java/io/reactivex/rxjava3/core/Observable.java b/src/main/java/io/reactivex/rxjava3/core/Observable.java index 81c121bc3e..ba46947bbe 100644 --- a/src/main/java/io/reactivex/rxjava3/core/Observable.java +++ b/src/main/java/io/reactivex/rxjava3/core/Observable.java @@ -1262,7 +1262,7 @@ public static Observable concatArrayDelayError(@NonNull ObservableSource< *
* @param the value type * @param sources an array of {@code ObservableSource}s that need to be eagerly concatenated - * @return the new {@code ObservableSource} instance with the specified concatenation behavior + * @return the new {@code Observable} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -1290,7 +1290,7 @@ public static Observable concatArrayEager(@NonNull ObservableSource Observable concatArrayEagerDelayError(int maxConcurrency, i } /** - * Concatenates the {@link Iterable} sequence of {@link ObservableSource}s into a single sequence by subscribing to each {@code ObservableSource}, - * one after the other, one at a time and delays any errors till the all inner {@code ObservableSource}s terminate. + * Concatenates the {@link Iterable} sequence of {@link ObservableSource}s into a single {@code Observable} sequence + * by subscribing to each {@code ObservableSource}, one after the other, one at a time and delays any errors till + * the all inner {@code ObservableSource}s terminate. *

* *

@@ -1370,7 +1371,7 @@ public static Observable concatArrayEagerDelayError(int maxConcurrency, i * * @param the common element base type * @param sources the {@code Iterable} sequence of {@code ObservableSource}s - * @return the new {@code ObservableSource} with the concatenating behavior + * @return the new {@code Observable} with the concatenating behavior */ @CheckReturnValue @NonNull @@ -1381,8 +1382,9 @@ public static Observable concatDelayError(@NonNull Iterable * *
@@ -1392,7 +1394,7 @@ public static Observable concatDelayError(@NonNull Iterable the common element base type * @param sources the {@code ObservableSource} sequence of {@code ObservableSource}s - * @return the new {@code ObservableSource} with the concatenating behavior + * @return the new {@code Observable} with the concatenating behavior */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -1414,9 +1416,9 @@ public static Observable concatDelayError(@NonNull ObservableSource the common element base type * @param sources the {@code ObservableSource} sequence of {@code ObservableSource}s * @param prefetch the number of elements to prefetch from the outer {@code ObservableSource} - * @param tillTheEnd if {@code true} exceptions from the outer and all inner {@code ObservableSource}s are delayed to the end + * @param tillTheEnd if {@code true}, exceptions from the outer and all inner {@code ObservableSource}s are delayed to the end * if {@code false}, exception from the outer {@code ObservableSource} is delayed till the active {@code ObservableSource} terminates - * @return the new {@code ObservableSource} with the concatenating behavior + * @return the new {@code Observable} with the concatenating behavior */ @SuppressWarnings({ "rawtypes", "unchecked" }) @CheckReturnValue @@ -1442,7 +1444,7 @@ public static Observable concatDelayError(@NonNull ObservableSource * @param the value type * @param sources a sequence of {@code ObservableSource}s that need to be eagerly concatenated - * @return the new {@code ObservableSource} instance with the specified concatenation behavior + * @return the new {@code Observable} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -1469,7 +1471,7 @@ public static Observable concatEager(@NonNull ObservableSource Observable concatEager(@NonNull ObservableSource * @param the value type * @param sources a sequence of {@code ObservableSource}s that need to be eagerly concatenated - * @return the new {@code ObservableSource} instance with the specified concatenation behavior + * @return the new {@code Observable} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -1521,7 +1523,7 @@ public static Observable concatEager(@NonNull Iterable Observable fromArray(@NonNull T... items) { *
Error handling:
*
If the {@link Callable} throws an exception, the respective {@link Throwable} is * delivered to the downstream via {@link Observer#onError(Throwable)}, - * except when the downstream has disposed this {@code Observable} source. + * except when the downstream has disposed the current {@code Observable} source. * In this latter case, the {@code Throwable} is delivered to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} as an {@link io.reactivex.rxjava3.exceptions.UndeliverableException UndeliverableException}. + * {@link RxJavaPlugins#onError(Throwable)} as an {@link UndeliverableException}. *
*
* @param supplier @@ -1922,9 +1924,9 @@ public static Observable fromPublisher(@NonNull Publisher pu *
Error handling:
*
If the {@link Supplier} throws an exception, the respective {@link Throwable} is * delivered to the downstream via {@link Observer#onError(Throwable)}, - * except when the downstream has disposed this {@code Observable} source. + * except when the downstream has disposed the current {@code Observable} source. * In this latter case, the {@code Throwable} is delivered to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} as an {@link io.reactivex.rxjava3.exceptions.UndeliverableException UndeliverableException}. + * {@link RxJavaPlugins#onError(Throwable)} as an {@link UndeliverableException}. *
*
* @param supplier @@ -3521,7 +3523,7 @@ public static Observable mergeArrayDelayError(@NonNull ObservableSource * *

- * This {@code Observable} is useful primarily for testing purposes. + * The returned {@code Observable} is useful primarily for testing purposes. *

*
Scheduler:
*
{@code never} does not operate by default on a particular {@link Scheduler}.
@@ -3754,7 +3756,7 @@ public static Single sequenceEqual(@NonNull ObservableSource * {@code switchOnNext} subscribes to an {@code ObservableSource} that emits {@code ObservableSource}s. Each time it observes one of * these emitted {@code ObservableSource}s, the {@code ObservableSource} returned by {@code switchOnNext} begins emitting the items - * emitted by that {@code ObservableSource}. When a new {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items + * emitted by that {@code ObservableSource}. When a new inner {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items * from the earlier-emitted {@code ObservableSource} and begins emitting items from the new one. *

* The resulting {@code Observable} completes if both the outer {@code ObservableSource} and the last inner {@code ObservableSource}, if any, complete. @@ -3791,7 +3793,7 @@ public static Observable switchOnNext(@NonNull ObservableSource * {@code switchOnNext} subscribes to an {@code ObservableSource} that emits {@code ObservableSource}s. Each time it observes one of * these emitted {@code ObservableSource}s, the {@code ObservableSource} returned by {@code switchOnNext} begins emitting the items - * emitted by that {@code ObservableSource}. When a new {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items + * emitted by that {@code ObservableSource}. When a new inner {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items * from the earlier-emitted {@code ObservableSource} and begins emitting items from the new one. *

* The resulting {@code Observable} completes if both the outer {@code ObservableSource} and the last inner {@code ObservableSource}, if any, complete. @@ -3823,7 +3825,7 @@ public static Observable switchOnNext(@NonNull ObservableSource * {@code switchOnNext} subscribes to an {@code ObservableSource} that emits {@code ObservableSource}s. Each time it observes one of * these emitted {@code ObservableSource}s, the {@code ObservableSource} returned by {@code switchOnNext} begins emitting the items - * emitted by that {@code ObservableSource}. When a new {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items + * emitted by that {@code ObservableSource}. When a new inner {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items * from the earlier-emitted {@code ObservableSource} and begins emitting items from the new one. *

* The resulting {@code Observable} completes if both the main {@code ObservableSource} and the last inner {@code ObservableSource}, if any, complete. @@ -3857,7 +3859,7 @@ public static Observable switchOnNextDelayError(@NonNull ObservableSource *

* {@code switchOnNext} subscribes to an {@code ObservableSource} that emits {@code ObservableSource}s. Each time it observes one of * these emitted {@code ObservableSource}s, the {@code ObservableSource} returned by {@code switchOnNext} begins emitting the items - * emitted by that {@code ObservableSource}. When a new {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items + * emitted by that {@code ObservableSource}. When a new inner {@code ObservableSource} is emitted, {@code switchOnNext} stops emitting items * from the earlier-emitted {@code ObservableSource} and begins emitting items from the new one. *

* The resulting {@code Observable} completes if both the main {@code ObservableSource} and the last inner {@code ObservableSource}, if any, complete. @@ -4021,9 +4023,9 @@ public static Observable using( * @param resourceDisposer * the function that will dispose of the resource * @param eager - * If {@code true} then resource disposal will happen either on a {@code dispose()} call before the upstream is disposed + * If {@code true}, the resource disposal will happen either on a {@code dispose()} call before the upstream is disposed * or just before the emission of a terminal event ({@code onComplete} or {@code onError}). - * If {@code false} the resource disposal will happen either on a {@code dispose()} call after the upstream is disposed + * If {@code false}, the resource disposal will happen either on a {@code dispose()} call after the upstream is disposed * or just after the emission of a terminal event ({@code onComplete} or {@code onError}). * @return the {@code ObservableSource} whose lifetime controls the lifetime of the dependent resource object * @see ReactiveX operators documentation: Using @@ -4070,9 +4072,9 @@ public static Observable wrap(@NonNull ObservableSource source) { * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of * items emitted, in sequence, by an {@link Iterable} of other {@link ObservableSource}s. *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by each of the {@code ObservableSource}s; - * the second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second + * the second item emitted by the resulting {@code Observable} will be the result of the function applied to the second * item emitted by each of those {@code ObservableSource}s; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as @@ -4124,9 +4126,9 @@ public static Observable zip(@NonNull Iterable - * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by each of the {@code ObservableSource}s; - * the second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second + * the second item emitted by the resulting {@code Observable} will be the result of the function applied to the second * item emitted by each of those {@code ObservableSource}s; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as @@ -4188,9 +4190,9 @@ public static Observable zip(@NonNull Iterable * *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by {@code o1} and the first item - * emitted by {@code o2}; the second item emitted by the new {@code ObservableSource} will be the result of the function + * emitted by {@code o2}; the second item emitted by the resulting {@code Observable} will be the result of the function * applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4244,9 +4246,9 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by {@code o1} and the first item - * emitted by {@code o2}; the second item emitted by the new {@code ObservableSource} will be the result of the function + * emitted by {@code o2}; the second item emitted by the resulting {@code Observable} will be the result of the function * applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4301,9 +4303,9 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by {@code o1} and the first item - * emitted by {@code o2}; the second item emitted by the new {@code ObservableSource} will be the result of the function + * emitted by {@code o2}; the second item emitted by the resulting {@code Observable} will be the result of the function * applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4359,10 +4361,10 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by {@code o1}, the first item - * emitted by {@code o2}, and the first item emitted by {@code o3}; the second item emitted by the new - * {@code ObservableSource} will be the result of the function applied to the second item emitted by {@code o1}, the + * emitted by {@code o2}, and the first item emitted by {@code o3}; the second item emitted by the resulting + * {@code Observable} will be the result of the function applied to the second item emitted by {@code o1}, the * second item emitted by {@code o2}, and the second item emitted by {@code o3}; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4421,10 +4423,10 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by {@code o1}, the first item * emitted by {@code o2}, the first item emitted by {@code o3}, and the first item emitted by {@code 04}; - * the second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second + * the second item emitted by the resulting {@code Observable} will be the result of the function applied to the second * item emitted by each of those {@code ObservableSource}s; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4487,10 +4489,10 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by {@code o1}, the first item * emitted by {@code o2}, the first item emitted by {@code o3}, the first item emitted by {@code o4}, and - * the first item emitted by {@code o5}; the second item emitted by the new {@code ObservableSource} will be the result of + * the first item emitted by {@code o5}; the second item emitted by the resulting {@code Observable} will be the result of * the function applied to the second item emitted by each of those {@code ObservableSource}s; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4557,9 +4559,9 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by each source {@code ObservableSource}, the - * second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second item + * second item emitted by the resulting {@code Observable} will be the result of the function applied to the second item * emitted by each of those {@code ObservableSource}s, and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4630,9 +4632,9 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by each source {@code ObservableSource}, the - * second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second item + * second item emitted by the resulting {@code Observable} will be the result of the function applied to the second item * emitted by each of those {@code ObservableSource}s, and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4708,9 +4710,9 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by each source {@code ObservableSource}, the - * second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second item + * second item emitted by the resulting {@code Observable} will be the result of the function applied to the second item * emitted by each of those {@code ObservableSource}s, and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4790,9 +4792,9 @@ public static Observable zip( *

* *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by each source {@code ObservableSource}, the - * second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second item + * second item emitted by the resulting {@code Observable} will be the result of the function applied to the second item * emitted by each of those {@code ObservableSource}s, and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@link Observer#onNext onNext} @@ -4874,9 +4876,9 @@ public static Observable zip( * Returns an {@code Observable} that emits the results of a specified combiner function applied to combinations of * items emitted, in sequence, by an array of other {@link ObservableSource}s. *

- * {@code zip} applies this function in strict sequence, so the first item emitted by the new {@code ObservableSource} + * {@code zip} applies this function in strict sequence, so the first item emitted by the resulting {@code Observable} * will be the result of the function applied to the first item emitted by each of the {@code ObservableSource}s; - * the second item emitted by the new {@code ObservableSource} will be the result of the function applied to the second + * the second item emitted by the resulting {@code Observable} will be the result of the function applied to the second * item emitted by each of those {@code ObservableSource}s; and so forth. *

* The resulting {@code Observable} returned from {@code zip} will invoke {@code onNext} as many times as @@ -5018,7 +5020,7 @@ public final Single any(@NonNull Predicate predicate) { } /** - * Returns the first item emitted by this {@code Observable}, or throws + * Returns the first item emitted by the current {@code Observable}, or throws * {@link NoSuchElementException} if it emits no items. *

* @@ -5027,9 +5029,9 @@ public final Single any(@NonNull Predicate predicate) { *

{@code blockingFirst} does not operate by default on a particular {@link Scheduler}.
*
* - * @return the first item emitted by this {@code Observable} + * @return the first item emitted by the current {@code Observable} * @throws NoSuchElementException - * if this {@code Observable} emits no items + * if the current {@code Observable} emits no items * @see ReactiveX documentation: First */ @CheckReturnValue @@ -5046,7 +5048,7 @@ public final T blockingFirst() { } /** - * Returns the first item emitted by this {@code Observable}, or a default value if it emits no + * Returns the first item emitted by the current {@code Observable}, or a default value if it emits no * items. *

* @@ -5056,8 +5058,8 @@ public final T blockingFirst() { *

* * @param defaultItem - * a default value to return if this {@code Observable} emits no items - * @return the first item emitted by this {@code Observable}, or the default value if it emits no + * a default value to return if the current {@code Observable} emits no items + * @return the first item emitted by the current {@code Observable}, or the default value if it emits no * items * @see ReactiveX documentation: First */ @@ -5155,7 +5157,9 @@ public final void blockingForEach(@NonNull Consumer onNext, int capac } /** - * Converts this {@code Observable} into an {@link Iterable}. + * Exposes the current {@code Observable} as an {@link Iterable} which, when iterated, + * subscribes to the current {@code Observable} and blocks + * until the current {@code Observable} emits items or terminates. *

* *

@@ -5163,7 +5167,7 @@ public final void blockingForEach(@NonNull Consumer onNext, int capac *
{@code blockingIterable} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an {@code Iterable} version of this {@code Observable} + * @return the new {@code Iterable} instance * @see ReactiveX documentation: To */ @CheckReturnValue @@ -5174,7 +5178,9 @@ public final Iterable blockingIterable() { } /** - * Converts this {@code Observable} into an {@link Iterable}. + * Exposes the current {@code Observable} as an {@link Iterable} which, when iterated, + * subscribes to the current {@code Observable} and blocks + * until the current {@code Observable} emits items or terminates. *

* *

@@ -5183,7 +5189,7 @@ public final Iterable blockingIterable() { *
* * @param capacityHint the expected number of items to be buffered - * @return an {@code Iterable} version of this {@code Observable} + * @return the new {@code Iterable} instance * @see ReactiveX documentation: To */ @CheckReturnValue @@ -5195,8 +5201,8 @@ public final Iterable blockingIterable(int capacityHint) { } /** - * Returns the last item emitted by this {@code Observable}, or throws - * {@link NoSuchElementException} if this {@code Observable} emits no items. + * Returns the last item emitted by the current {@code Observable}, or throws + * {@link NoSuchElementException} if the current {@code Observable} emits no items. *

* *

@@ -5208,9 +5214,9 @@ public final Iterable blockingIterable(int capacityHint) { * {@link Error}s are rethrown as they are. *
* - * @return the last item emitted by this {@code Observable} + * @return the last item emitted by the current {@code Observable} * @throws NoSuchElementException - * if this {@code Observable} emits no items + * if the current {@code Observable} emits no items * @see ReactiveX documentation: Last */ @CheckReturnValue @@ -5227,7 +5233,7 @@ public final T blockingLast() { } /** - * Returns the last item emitted by this {@code Observable}, or a default value if it emits no + * Returns the last item emitted by the current {@code Observable}, or a default value if it emits no * items. *

* @@ -5241,7 +5247,7 @@ public final T blockingLast() { *

* * @param defaultItem - * a default value to return if this {@code Observable} emits no items + * a default value to return if the current {@code Observable} emits no items * @return the last item emitted by the {@code Observable}, or the default value if it emits no * items * @see ReactiveX documentation: Last @@ -5257,12 +5263,12 @@ public final T blockingLast(@NonNull T defaultItem) { } /** - * Returns an {@link Iterable} that returns the latest item emitted by this {@code Observable}, + * Returns an {@link Iterable} that returns the latest item emitted by the current {@code Observable}, * waiting if necessary for one to become available. *

* *

- * If this {@code Observable} produces items faster than {@code Iterator.next} takes them, + * If the current {@code Observable} produces items faster than {@code Iterator.next} takes them, * {@code onNext} events might be skipped, but {@code onError} or {@code onComplete} events are not. *

* Note also that an {@code onNext} directly followed by {@code onComplete} might hide the {@code onNext} @@ -5272,7 +5278,7 @@ public final T blockingLast(@NonNull T defaultItem) { *

{@code blockingLatest} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an {@code Iterable} that always returns the latest item emitted by this {@code Observable} + * @return an {@code Iterable} that always returns the latest item emitted by the current {@code Observable} * @see ReactiveX documentation: First */ @CheckReturnValue @@ -5283,7 +5289,7 @@ public final Iterable blockingLatest() { } /** - * Returns an {@link Iterable} that always returns the item most recently emitted by this + * Returns an {@link Iterable} that always returns the item most recently emitted by the current * {@code Observable}. *

* @@ -5293,9 +5299,9 @@ public final Iterable blockingLatest() { * * * @param initialValue - * the initial value that the {@code Iterable} sequence will yield if this + * the initial value that the {@code Iterable} sequence will yield if the current * {@code Observable} has not yet emitted an item - * @return an {@code Iterable} that on each iteration returns the item that this {@code Observable} + * @return an {@code Iterable} that on each iteration returns the item that the current {@code Observable} * has most recently emitted * @see ReactiveX documentation: First */ @@ -5307,7 +5313,7 @@ public final Iterable blockingMostRecent(@NonNull T initialValue) { } /** - * Returns an {@link Iterable} that blocks until this {@code Observable} emits another item, then + * Returns an {@link Iterable} that blocks until the current {@code Observable} emits another item, then * returns that item. *

* @@ -5316,7 +5322,7 @@ public final Iterable blockingMostRecent(@NonNull T initialValue) { *

{@code blockingNext} does not operate by default on a particular {@link Scheduler}.
* * - * @return an {@code Iterable} that blocks upon each iteration until this {@code Observable} emits + * @return an {@code Iterable} that blocks upon each iteration until the current {@code Observable} emits * a new item, whereupon the {@code Iterable} returns that item * @see ReactiveX documentation: TakeLast */ @@ -5328,7 +5334,7 @@ public final Iterable blockingNext() { } /** - * If this {@code Observable} completes after emitting a single item, return that item, otherwise + * If the current {@code Observable} completes after emitting a single item, return that item, otherwise * throw a {@link NoSuchElementException}. *

* @@ -5341,7 +5347,7 @@ public final Iterable blockingNext() { * {@link Error}s are rethrown as they are. * * - * @return the single item emitted by this {@code Observable} + * @return the single item emitted by the current {@code Observable} * @see ReactiveX documentation: First */ @CheckReturnValue @@ -5356,7 +5362,7 @@ public final T blockingSingle() { } /** - * If this {@code Observable} completes after emitting a single item, return that item; if it emits + * If the current {@code Observable} completes after emitting a single item, return that item; if it emits * more than one item, throw an {@link IllegalArgumentException}; if it emits no items, return a default * value. *

@@ -5371,8 +5377,8 @@ public final T blockingSingle() { * * * @param defaultItem - * a default value to return if this {@code Observable} emits no items - * @return the single item emitted by this {@code Observable}, or the default value if it emits no + * a default value to return if the current {@code Observable} emits no items + * @return the single item emitted by the current {@code Observable}, or the default value if it emits no * items * @see ReactiveX documentation: First */ @@ -5384,7 +5390,7 @@ public final T blockingSingle(@NonNull T defaultItem) { } /** - * Returns a {@link Future} representing the only value emitted by this {@code Observable}. + * Returns a {@link Future} representing the only value emitted by the current {@code Observable}. *

* *

@@ -5399,7 +5405,7 @@ public final T blockingSingle(@NonNull T defaultItem) { *

{@code toFuture} does not operate by default on a particular {@link Scheduler}.
* * - * @return a {@code Future} that expects a single item to be emitted by this {@code Observable} + * @return a {@code Future} that expects a single item to be emitted by the current {@code Observable} * @see ReactiveX documentation: To */ @CheckReturnValue @@ -5437,7 +5443,7 @@ public final void blockingSubscribe() { * *

* If the {@code Observable} emits an error, it is wrapped into an - * {@link io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException} + * {@link OnErrorNotImplementedException} * and routed to the {@link RxJavaPlugins#onError(Throwable)} handler. * Using the overloads {@link #blockingSubscribe(Consumer, Consumer)} * or {@link #blockingSubscribe(Consumer, Consumer, Action)} instead is recommended. @@ -5881,7 +5887,7 @@ public final > Observable buffer(int count, i * @param bufferSupplier * a factory function that returns an instance of the collection subclass to be used and returned * as the buffer - * @param restartTimerOnMaxSize if {@code true} the time window is restarted when the max capacity of the current buffer + * @param restartTimerOnMaxSize if {@code true}, the time window is restarted when the max capacity of the current buffer * is reached * @return an {@code Observable} that emits connected, non-overlapping buffers of items emitted by the current * {@code Observable} after a fixed duration or when the buffer reaches maximum capacity (whichever occurs @@ -5953,7 +5959,7 @@ public final > Observable buffer(int count, i * @param openingIndicator * the {@code ObservableSource} that, when it emits an item, causes a new buffer to be created * @param closingIndicator - * the {@link Function} that is used to produce an {@code ObservableSource} for every buffer created. When this + * the {@link Function} that is used to produce an {@code ObservableSource} for every buffer created. When this indicator * {@code ObservableSource} emits an item, the associated buffer is emitted. * @return an {@code Observable} that emits buffers, containing items from the current {@code Observable}, that are created * and closed when the specified {@code ObservableSource}s emit items @@ -5987,7 +5993,7 @@ public final > Observable buffer(int count, i * @param openingIndicator * the {@code ObservableSource} that, when it emits an item, causes a new buffer to be created * @param closingIndicator - * the {@link Function} that is used to produce an {@code ObservableSource} for every buffer created. When this + * the {@link Function} that is used to produce an {@code ObservableSource} for every buffer created. When this indicator * {@code ObservableSource} emits an item, the associated buffer is emitted. * @param bufferSupplier * a factory function that returns an instance of the collection subclass to be used and returned @@ -6112,7 +6118,7 @@ public final > Observable buffer(int count, i } /** - * Returns an {@code Observable} that subscribes to this {@code Observable} lazily, caches all of its events + * Returns an {@code Observable} that subscribes to the current {@code Observable} lazily, caches all of its events * and replays them, in the same order as received, to all the downstream observers. *

* @@ -6121,7 +6127,7 @@ public final > Observable buffer(int count, i * subscribe/dispose behavior of all the {@link Observer}s. *

* The operator subscribes only when the first downstream observer subscribes and maintains - * a single subscription towards this {@code Observable}. In contrast, the operator family of {@link #replay()} + * a single subscription towards the current {@code Observable}. In contrast, the operator family of {@link #replay()} * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}. *

* Note: You sacrifice the ability to dispose the origin when you use the {@code cache} @@ -6169,7 +6175,7 @@ public final Observable cache() { } /** - * Returns an {@code Observable} that subscribes to this {@code Observable} lazily, caches all of its events + * Returns an {@code Observable} that subscribes to the current {@code Observable} lazily, caches all of its events * and replays them, in the same order as received, to all the downstream observers. *

* @@ -6178,7 +6184,7 @@ public final Observable cache() { * subscribe/dispose behavior of all the {@link Observer}s. *

* The operator subscribes only when the first downstream observer subscribes and maintains - * a single subscription towards this {@code Observable}. In contrast, the operator family of {@link #replay()} + * a single subscription towards the current {@code Observable}. In contrast, the operator family of {@link #replay()} * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}. *

* Note: You sacrifice the ability to dispose the origin when you use the {@code cache} @@ -6276,7 +6282,7 @@ public final Observable cast(@NonNull Class clazz) { * @param initialValueSupplier * the mutable data structure that will collect the items * @param collector - * a function that accepts the {@code state} and an emitted item, and modifies {@code state} + * a function that accepts the {@code state} and an emitted item, and modifies the accumulator accordingly * accordingly * @return a {@code Single} that emits the result of collecting the values emitted by the current {@code Observable} * into a single mutable data structure @@ -6311,7 +6317,7 @@ public final Single collect(@NonNull Supplier initialValueSu * @param initialValue * the mutable data structure that will collect the items * @param collector - * a function that accepts the {@code state} and an emitted item, and modifies {@code state} + * a function that accepts the {@code state} and an emitted item, and modifies the accumulator accordingly * accordingly * @return a {@code Single} that emits the result of collecting the values emitted by the current {@code Observable} * into a single mutable data structure @@ -6326,7 +6332,7 @@ public final Single collectInto(@NonNull U initialValue, @NonNull BiConsu } /** - * Transform this {@code Observable} by applying a particular {@link ObservableTransformer} function to it. + * Transform the current {@code Observable} by applying a particular {@link ObservableTransformer} function to it. *

* This method operates on the {@code Observable} itself whereas {@link #lift} operates on the {@link ObservableSource}'s * {@link Observer}s. @@ -6355,7 +6361,7 @@ public final Observable compose(@NonNull ObservableTransformer * *

@@ -6386,7 +6392,7 @@ public final Observable concatMap(@NonNull Function * *

@@ -6429,7 +6435,7 @@ public final Observable concatMap(@NonNull Function * *

@@ -6480,8 +6486,8 @@ public final Observable concatMap(@NonNull Function * * @param the result value type - * @param mapper the function that maps the items of this {@code ObservableSource} into the inner {@code ObservableSource}s. - * @return the new {@code ObservableSource} instance with the concatenation behavior + * @param mapper the function that maps the items of the current {@code Observable} into the inner {@code ObservableSource}s. + * @return the new {@code Observable} instance with the concatenation behavior * @see #concatMapDelayError(Function, boolean, int, Scheduler) */ @CheckReturnValue @@ -6508,13 +6514,13 @@ public final Observable concatMapDelayError(@NonNull Function * * @param the result value type - * @param mapper the function that maps the items of this {@code ObservableSource} into the inner {@code ObservableSource}s. + * @param mapper the function that maps the items of the current {@code Observable} into the inner {@code ObservableSource}s. * @param tillTheEnd * if {@code true}, all errors from the outer and inner {@code ObservableSource} sources are delayed until the end, * if {@code false}, an error from the main source is signaled when the current {@code Observable} source terminates * @param prefetch * the number of elements to prefetch from the current {@code Observable} - * @return the new {@code ObservableSource} instance with the concatenation behavior + * @return the new {@code Observable} instance with the concatenation behavior * @see #concatMapDelayError(Function, boolean, int, Scheduler) */ @CheckReturnValue @@ -6548,7 +6554,7 @@ public final Observable concatMapDelayError(@NonNull Function * * @param the result value type - * @param mapper the function that maps the items of this {@code ObservableSource} into the inner {@code ObservableSource}s. + * @param mapper the function that maps the items of the current {@code Observable} into the inner {@code ObservableSource}s. * @param tillTheEnd * if {@code true}, all errors from the outer and inner {@code ObservableSource} sources are delayed until the end, * if {@code false}, an error from the main source is signaled when the current {@code Observable} source terminates @@ -6556,7 +6562,7 @@ public final Observable concatMapDelayError(@NonNull Function Observable concatMapDelayError(@NonNull Function the value type * @param mapper the function that maps a sequence of values into a sequence of {@code ObservableSource}s that will be * eagerly concatenated - * @return the new {@code ObservableSource} instance with the specified concatenation behavior + * @return the new {@code Observable} instance with the specified concatenation behavior * @since 2.0 */ @CheckReturnValue @@ -6615,7 +6621,7 @@ public final Observable concatMapEager(@NonNull Function Observable concatMapEager(@NonNull Function Observable concatMapEagerDelayError(@NonNull Function * @@ -6773,7 +6779,7 @@ public final Completable concatMapCompletableDelayError(@NonNull Function * @@ -6785,9 +6791,9 @@ public final Completable concatMapCompletableDelayError(@NonNull Function * @@ -6816,9 +6822,9 @@ public final Completable concatMapCompletableDelayError(@NonNull Function Observable concatMapIterable(@NonNull Function * *

@@ -6928,7 +6934,7 @@ public final Observable concatMapMaybe(@NonNull Function * *
@@ -6961,7 +6967,7 @@ public final Observable concatMapMaybe(@NonNull Function * *
@@ -6988,7 +6994,7 @@ public final Observable concatMapMaybeDelayError(@NonNull Function * *
@@ -7000,9 +7006,9 @@ public final Observable concatMapMaybeDelayError(@NonNull Function Observable concatMapMaybeDelayError(@NonNull Function * *
@@ -7033,9 +7039,9 @@ public final Observable concatMapMaybeDelayError(@NonNull Function Observable concatMapMaybeDelayError(@NonNull Function * *
@@ -7086,7 +7092,7 @@ public final Observable concatMapSingle(@NonNull Function * *
@@ -7119,7 +7125,7 @@ public final Observable concatMapSingle(@NonNull Function * *
@@ -7146,7 +7152,7 @@ public final Observable concatMapSingleDelayError(@NonNull Function * *
@@ -7158,9 +7164,9 @@ public final Observable concatMapSingleDelayError(@NonNull Function Observable concatMapSingleDelayError(@NonNull Function * *
@@ -7191,9 +7197,9 @@ public final Observable concatMapSingleDelayError(@NonNull Function concatWith(@NonNull ObservableSource oth } /** - * Returns an {@code Observable} that emits the items from this {@code Observable} followed by the success item or error event + * Returns an {@code Observable} that emits the items from the current {@code Observable} followed by the success item or error event * of the {@code other} {@link SingleSource}. *

* @@ -7248,7 +7254,7 @@ public final Observable concatWith(@NonNull ObservableSource oth *

{@code concatWith} does not operate by default on a particular {@link Scheduler}.
*
*

History: 2.1.10 - experimental - * @param other the {@code SingleSource} whose signal should be emitted after this {@code Observable} completes normally. + * @param other the {@code SingleSource} whose signal should be emitted after the current {@code Observable} completes normally. * @return the new {@code Observable} instance * @since 2.2 */ @@ -7261,7 +7267,7 @@ public final Observable concatWith(@NonNull SingleSource other) } /** - * Returns an {@code Observable} that emits the items from this {@code Observable} followed by the success item or terminal events + * Returns an {@code Observable} that emits the items from the current {@code Observable} followed by the success item or terminal events * of the other {@link MaybeSource}. *

* @@ -7270,7 +7276,7 @@ public final Observable concatWith(@NonNull SingleSource other) *

{@code concatWith} does not operate by default on a particular {@link Scheduler}.
*
*

History: 2.1.10 - experimental - * @param other the {@code MaybeSource} whose signal should be emitted after this {@code Observable} completes normally. + * @param other the {@code MaybeSource} whose signal should be emitted after the current {@code Observable} completes normally. * @return the new {@code Observable} instance * @since 2.2 */ @@ -7283,7 +7289,7 @@ public final Observable concatWith(@NonNull MaybeSource other) { } /** - * Returns an {@code Observable} that emits items from this {@code Observable} and when it completes normally, the + * Returns an {@code Observable} that emits items from the current {@code Observable} and when it completes normally, the * other {@link CompletableSource} is subscribed to and the returned {@code Observable} emits its terminal events. *

* @@ -7394,7 +7400,7 @@ public final Observable debounce(@NonNull Function * *

- * Delivery of the item after the grace period happens on the {@code computation} {@code Scheduler}'s + * Delivery of the item after the grace period happens on the {@code computation} {@link Scheduler}'s * {@code Worker} which if takes too long, a newer item may arrive from the upstream, causing the * {@code Worker}'s task to get disposed, which may also interrupt any downstream blocking operation * (yielding an {@code InterruptedException}). It is recommended processing items @@ -7402,12 +7408,12 @@ public final Observable debounce(@NonNull Function *

Scheduler:
- *
{@code debounce} operates by default on the {@code computation} {@link Scheduler}.
+ *
{@code debounce} operates by default on the {@code computation} {@code Scheduler}.
*
* * @param timeout * the length of the window of time that must pass after the emission of an item from the current - * {@code Observable} in which that {@code ObservableSource} emits no items in order for the item to be emitted by the + * {@code Observable} in which the {@code Observable} emits no items in order for the item to be emitted by the * resulting {@code Observable} * @param unit * the unit of time for the specified {@code timeout} @@ -7426,7 +7432,7 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit) { /** * Returns an {@code Observable} that mirrors the current {@code Observable}, except that it drops items emitted by the * current {@code Observable} that are followed by newer items before a timeout value expires on a specified - * Scheduler. The timer resets on each emission. + * {@link Scheduler}. The timer resets on each emission. *

* Note: If items keep being emitted by the current {@code Observable} faster than the timeout then no items * will be emitted by the resulting {@code Observable}. @@ -7441,7 +7447,7 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit) { * {@code debounce} itself. *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param timeout @@ -7450,7 +7456,7 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit) { * @param unit * the unit of time for the specified {@code timeout} * @param scheduler - * the {@link Scheduler} to use internally to manage the timers that handle the timeout for each + * the {@code Scheduler} to use internally to manage the timers that handle the timeout for each * item * @return an {@code Observable} that filters out items from the current {@code Observable} that are too quickly followed by * newer items @@ -7491,8 +7497,8 @@ public final Observable defaultIfEmpty(@NonNull T defaultItem) { } /** - * Returns an {@code Observable} that delays the emissions of the current {@code Observable} via another {@code ObservableSource} on a - * per-item basis. + * Returns an {@code Observable} that delays the emissions of the current {@code Observable} via + * a per-item derived {@link ObservableSource}'s item emission or termination, on a per source item basis. *

* *

@@ -7523,7 +7529,7 @@ public final Observable delay(@NonNull Function * *

@@ -7537,6 +7543,8 @@ public final Observable delay(@NonNull FunctionReactiveX operators documentation: Delay + * @see #delay(long, TimeUnit, boolean) + * @see #delay(long, TimeUnit, Scheduler) */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) @@ -7564,6 +7572,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit) { * if {@code false}, the upstream exception is signaled immediately * @return the current {@code Observable} shifted in time by the specified delay * @see ReactiveX operators documentation: Delay + * @see #delay(long, TimeUnit, Scheduler, boolean) */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) @@ -7574,7 +7583,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, boolean del /** * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} shifted forward in time by a - * specified delay. Error notifications from the current {@code Observable} are not delayed. + * specified delay. An error notification from the current {@code Observable} is not delayed. *

* *

@@ -7587,7 +7596,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, boolean del * @param unit * the time unit of {@code delay} * @param scheduler - * the {@link Scheduler} to use for delaying + * the {@code Scheduler} to use for delaying * @return the current {@code Observable} shifted in time by the specified delay * @see ReactiveX operators documentation: Delay */ @@ -7613,7 +7622,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, @NonNull Sc * @param unit * the time unit of {@code delay} * @param scheduler - * the {@link Scheduler} to use for delaying + * the {@code Scheduler} to use for delaying * @param delayError * if {@code true}, the upstream exception is signaled with the given delay, after all preceding normal elements, * if {@code false}, the upstream exception is signaled immediately @@ -7631,8 +7640,8 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, @NonNull Sc } /** - * Returns an {@code Observable} that delays the subscription to and emissions from the current {@code Observable} via another - * {@code ObservableSource} on a per-item basis. + * Returns an {@code Observable} that delays the subscription to and emissions from the current {@code Observable} via + * {@link ObservableSource}s for the subscription itself and on a per-item basis. *

* *

@@ -7667,8 +7676,8 @@ public final Observable delay(@NonNull ObservableSource subscriptio } /** - * Returns an {@code Observable} that delays the subscription to this {@code Observable} - * until the other {@code Observable} emits an element or completes normally. + * Returns an {@code Observable} that delays the subscription to the current {@code Observable} + * until the other {@link ObservableSource} emits an element or completes normally. *

* *

@@ -7677,10 +7686,10 @@ public final Observable delay(@NonNull ObservableSource subscriptio *
* * @param the value type of the other {@code Observable}, irrelevant - * @param other the other {@code Observable} that should trigger the subscription - * to this {@code Observable}. - * @return an {@code Observable} that delays the subscription to this {@code Observable} - * until the other {@code Observable} emits an element or completes normally. + * @param other the other {@code ObservableSource} that should trigger the subscription + * to the current {@code Observable}. + * @return an {@code Observable} that delays the subscription to the current {@code Observable} + * until the other {@code ObservableSource} emits an element or completes normally. * @since 2.0 */ @CheckReturnValue @@ -7716,12 +7725,12 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit) /** * Returns an {@code Observable} that delays the subscription to the current {@code Observable} by a given amount of time, - * both waiting and subscribing on a given Scheduler. + * both waiting and subscribing on a given {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param delay @@ -7729,9 +7738,9 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit) * @param unit * the time unit of {@code delay} * @param scheduler - * the Scheduler on which the waiting and subscription will happen + * the {@code Scheduler} on which the waiting and subscription will happen * @return an {@code Observable} that delays the subscription to the current {@code Observable} by a given - * amount, waiting and subscribing on the given Scheduler + * amount, waiting and subscribing on the given {@code Scheduler} * @see ReactiveX operators documentation: Delay */ @CheckReturnValue @@ -7744,7 +7753,7 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit, /** * Returns an {@code Observable} that reverses the effect of {@link #materialize materialize} by transforming the * {@link Notification} objects extracted from the source items via a selector function - * into their respective {@code Observer} signal types. + * into their respective {@link Observer} signal types. *

* *

@@ -7781,9 +7790,9 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit, *

History: 2.2.4 - experimental * * @param the output value type - * @param selector function that returns the upstream item and should return a Notification to signal + * @param selector function that returns the upstream item and should return a {@code Notification} to signal * the corresponding {@code Observer} event to the downstream. - * @return an {@code Observable} that emits the items and notifications embedded in the {@link Notification} objects + * @return an {@code Observable} that emits the items and notifications embedded in the {@code Notification} objects * selected from the items emitted by the current {@code Observable} * @see ReactiveX operators documentation: Dematerialize * @since 3.0.0 @@ -7806,13 +7815,13 @@ public final Observable dematerialize(@NonNull Function - * By default, {@code distinct()} uses an internal {@link java.util.HashSet} per {@code Observer} to remember + * By default, {@code distinct()} uses an internal {@link HashSet} per {@link Observer} to remember * previously seen items and uses {@link java.util.Set#add(Object)} returning {@code false} as the * indicator for duplicates. *

* Note that this internal {@code HashSet} may grow unbounded as items won't be removed from it by * the operator. Therefore, using very long or infinite upstream (with very distinct elements) may lead - * to {@code OutOfMemoryError}. + * to {@link OutOfMemoryError}. *

* Customizing the retention policy can happen only by providing a custom {@link java.util.Collection} implementation * to the {@link #distinct(Function, Supplier)} overload. @@ -7845,13 +7854,13 @@ public final Observable distinct() { * and {@link Object#hashCode()} to provide meaningful comparison between the key objects as the default * Java implementation only considers reference equivalence. *

- * By default, {@code distinct()} uses an internal {@link java.util.HashSet} per {@code Observer} to remember + * By default, {@code distinct()} uses an internal {@link HashSet} per {@link Observer} to remember * previously seen keys and uses {@link java.util.Set#add(Object)} returning {@code false} as the * indicator for duplicates. *

* Note that this internal {@code HashSet} may grow unbounded as keys won't be removed from it by * the operator. Therefore, using very long or infinite upstream (with very distinct keys) may lead - * to {@code OutOfMemoryError}. + * to {@link OutOfMemoryError}. *

* Customizing the retention policy can happen only by providing a custom {@link java.util.Collection} implementation * to the {@link #distinct(Function, Supplier)} overload. @@ -7895,8 +7904,8 @@ public final Observable distinct(@NonNull Function keySelec * a function that projects an emitted item to a key value that is used to decide whether an item * is distinct from another one or not * @param collectionSupplier - * function called for each individual {@code Observer} to return a Collection subtype for holding the extracted - * keys and whose add() method's return indicates uniqueness. + * function called for each individual {@link Observer} to return a {@link Collection} subtype for holding the extracted + * keys and whose {@code add()} method's return indicates uniqueness. * @return an {@code Observable} that emits those items emitted by the current {@code Observable} that have distinct keys * @see ReactiveX operators documentation: Distinct */ @@ -7926,7 +7935,7 @@ public final Observable distinct(@NonNull Function keySelec *

* Note that if element type {@code T} in the flow is mutable, the comparison of the previous and current * item may yield unexpected results if the items are mutated externally. Common cases are mutable - * {@code CharSequence}s or {@code List}s where the objects will actually have the same + * {@link CharSequence}s or {@link List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. @@ -7966,7 +7975,7 @@ public final Observable distinctUntilChanged() { *

* Note that if element type {@code T} in the flow is mutable, the comparison of the previous and current * item may yield unexpected results if the items are mutated externally. Common cases are mutable - * {@code CharSequence}s or {@code List}s where the objects will actually have the same + * {@link CharSequence}s or {@link List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. @@ -8002,7 +8011,7 @@ public final Observable distinctUntilChanged(@NonNull Function * Note that if element type {@code T} in the flow is mutable, the comparison of the previous and current * item may yield unexpected results if the items are mutated externally. Common cases are mutable - * {@code CharSequence}s or {@code List}s where the objects will actually have the same + * {@link CharSequence}s or {@link List}s where the objects will actually have the same * references when they are modified and {@code distinctUntilChanged} will evaluate subsequent items as same. * To avoid such situation, it is recommended that mutable data is converted to an immutable one, * for example using {@code map(CharSequence::toString)} or {@code map(list -> Collections.unmodifiableList(new ArrayList<>(list)))}. @@ -8012,7 +8021,7 @@ public final Observable distinctUntilChanged(@NonNull Function * * @param comparer the function that receives the previous item and the current item and is - * expected to return true if the two are equal, thus skipping the current value. + * expected to return {@code true} if the two are equal, thus skipping the current value. * @return an {@code Observable} that emits those items from the current {@code Observable} that are distinct from their * immediate predecessors * @see ReactiveX operators documentation: Distinct @@ -8027,8 +8036,9 @@ public final Observable distinctUntilChanged(@NonNull BiPredicateNote that the {@code onAfterNext} action is shared between subscriptions and as such + * Calls the specified {@link Consumer} with the current item after this item has been emitted to the downstream. + *

+ * Note that the {@code onAfterNext} action is shared between subscriptions and as such * should be thread-safe. *

* @@ -8039,7 +8049,7 @@ public final Observable distinctUntilChanged(@NonNull BiPredicateThis operator supports boundary-limited synchronous or asynchronous queue-fusion. *

*

History: 2.0.1 - experimental - * @param onAfterNext the Consumer that will be called after emitting an item from upstream to the downstream + * @param onAfterNext the {@code Consumer} that will be called after emitting an item from upstream to the downstream * @return the new {@code Observable} instance * @since 2.1 */ @@ -8052,7 +8062,7 @@ public final Observable doAfterNext(@NonNull Consumer onAfterNext) } /** - * Registers an {@link Action} to be called when this {@code ObservableSource} invokes either + * Registers an {@link Action} to be called when the current {@code Observable} invokes either * {@link Observer#onComplete onComplete} or {@link Observer#onError onError}. *

* @@ -8062,9 +8072,9 @@ public final Observable doAfterNext(@NonNull Consumer onAfterNext) *

* * @param onFinally - * an {@link Action} to be invoked when the current {@code Observable} finishes + * an {@code Action} to be invoked when the current {@code Observable} finishes * @return an {@code Observable} that emits the same items as the current {@code Observable}, then invokes the - * {@link Action} + * {@code Action} * @see ReactiveX operators documentation: Do * @see #doOnTerminate(Action) */ @@ -8077,7 +8087,7 @@ public final Observable doAfterTerminate(@NonNull Action onFinally) { } /** - * Calls the specified action after this {@code Observable} signals onError or onCompleted or gets disposed by + * Calls the specified action after the current {@code Observable} signals {@code onError} or {@code onCompleted} or gets disposed by * the downstream. *

In case of a race between a terminal event and a dispose call, the provided {@code onFinally} action * is executed once per subscription. @@ -8092,7 +8102,7 @@ public final Observable doAfterTerminate(@NonNull Action onFinally) { *

This operator supports boundary-limited synchronous or asynchronous queue-fusion.
*
*

History: 2.0.1 - experimental - * @param onFinally the action called when this {@code Observable} terminates or gets disposed + * @param onFinally the action called when the current {@code Observable} terminates or gets disposed * @return the new {@code Observable} instance * @since 2.1 */ @@ -8105,13 +8115,13 @@ public final Observable doFinally(@NonNull Action onFinally) { } /** - * Calls the dispose {@code Action} if the downstream disposes the sequence. + * Calls the given shared {@link Action} if the downstream disposes the sequence. *

* The action is shared between subscriptions and thus may be called concurrently from multiple * threads; the action must be thread safe. *

* If the action throws a runtime exception, that exception is rethrown by the {@code dispose()} call, - * sometimes as a {@code CompositeException} if there were multiple exceptions along the way. + * sometimes as a {@link CompositeException} if there were multiple exceptions along the way. *

* *

@@ -8120,9 +8130,9 @@ public final Observable doFinally(@NonNull Action onFinally) { *
* * @param onDispose - * the action that gets called when the current {@code Observable}'s Disposable is disposed - * @return the current {@code Observable} modified so as to call this Action when appropriate - * @throws NullPointerException if onDispose is null + * the action that gets called when the current {@code Observable}'s {@link Disposable} is disposed + * @return the current {@code Observable} modified so as to call this {@code Action} when appropriate + * @throws NullPointerException if {@code onDispose} is {@code null} * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8133,7 +8143,7 @@ public final Observable doOnDispose(@NonNull Action onDispose) { } /** - * Modifies the current {@code Observable} so that it invokes an action when it calls {@code onComplete}. + * Returns an {@code Observable} that invokes an {@link Action} when the current {@code Observable} calls {@code onComplete}. *

* *

@@ -8154,8 +8164,8 @@ public final Observable doOnComplete(@NonNull Action onComplete) { } /** - * Calls the appropriate onXXX consumer (shared between all subscribers) whenever a signal with the same type - * passes through, before forwarding them to downstream. + * Calls the appropriate {@code onXXX} consumer (shared between all {@link Observer}s) whenever a signal with the same type + * passes through, before forwarding them to the downstream. *

* *

@@ -8178,7 +8188,8 @@ private Observable doOnEach(@NonNull Consumer onNext, @NonNull Con } /** - * Modifies the current {@code Observable} so that it invokes an action for each item it emits. + * Returns an {@code Observable} that invokes a {@link Consumer} with the appropriate {@link Notification} + * object when the current {@code Observable} signals an item or terminates. *

* *

@@ -8205,7 +8216,8 @@ public final Observable doOnEach(@NonNull Consumer> o } /** - * Modifies the current {@code Observable} so that it notifies an {@code Observer} for each item and terminal event it emits. + * Returns an {@code Observable} that forwards the items and terminal events of the current + * {@code Observable} to its {@link Observer}s and to the given shared {@code Observer} instance. *

* In case the {@code onError} of the supplied observer throws, the downstream will receive a composite * exception containing the original exception and the exception thrown by {@code onError}. If either the @@ -8219,7 +8231,7 @@ public final Observable doOnEach(@NonNull Consumer> o *

* * @param observer - * the observer to be notified about onNext, onError and onComplete events on its + * the observer to be notified about {@code onNext}, {@code onError} and {@code onComplete} events on its * respective methods before the actual downstream {@code Observer} gets notified. * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do @@ -8261,7 +8273,7 @@ public final Observable doOnError(@NonNull Consumer onErro } /** - * Calls the appropriate onXXX method (shared between all Observer) for the lifecycle events of + * Calls the appropriate {@code onXXX} method (shared between all {@link Observer}s) for the lifecycle events of * the sequence (subscription, disposal). *

* @@ -8271,9 +8283,9 @@ public final Observable doOnError(@NonNull Consumer onErro *

* * @param onSubscribe - * a Consumer called with the Disposable sent via Observer.onSubscribe() + * a {@link Consumer} called with the {@link Disposable} sent via {@link Observer#onSubscribe(Disposable)} * @param onDispose - * called when the downstream disposes the Disposable via dispose() + * called when the downstream disposes the {@code Disposable} via {@code dispose()} * @return the current {@code Observable} with the side-effecting behavior applied * @see ReactiveX operators documentation: Do */ @@ -8308,8 +8320,8 @@ public final Observable doOnNext(@NonNull Consumer onNext) { } /** - * Modifies the current {@code Observable} so that it invokes the given action when it is subscribed from - * its subscribers. Each subscription will result in an invocation of the given action except when the + * Returns an {@code Observable} so that it invokes the given {@link Consumer} when the current {@code Observable} is subscribed from + * its {@link Observer}s. Each subscription will result in an invocation of the given action except when the * current {@code Observable} is reference counted, in which case the current {@code Observable} will invoke * the given action for the first subscription. *

@@ -8320,8 +8332,8 @@ public final Observable doOnNext(@NonNull Consumer onNext) { *

* * @param onSubscribe - * the Consumer that gets called when an {@code Observer} subscribes to the current {@code Observable} - * @return the current {@code Observable} modified so as to call this Consumer when appropriate + * the {@code Consumer} that gets called when an {@code Observer} subscribes to the current {@code Observable} + * @return the current {@code Observable} modified so as to call this {@code Consumer} whenever it gets subscribed * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8332,7 +8344,7 @@ public final Observable doOnSubscribe(@NonNull Consumer o } /** - * Modifies the current {@code Observable} so that it invokes an action when it calls {@code onComplete} or + * Returns an {@code Observable} so that it invokes an action when the current {@code Observable} calls {@code onComplete} or * {@code onError}. *

* @@ -8361,8 +8373,8 @@ public final Observable doOnTerminate(@NonNull Action onTerminate) { } /** - * Returns a Maybe that emits the single item at a specified index in a sequence of emissions from - * this {@code Observable} or completes if this {@code Observable} signals fewer elements than index. + * Returns a {@link Maybe} that emits the single item at a specified index in a sequence of emissions from + * the current {@code Observable} or completes if the current {@code Observable} signals fewer elements than index. *

* *

@@ -8372,7 +8384,7 @@ public final Observable doOnTerminate(@NonNull Action onTerminate) { * * @param index * the zero-based index of the item to retrieve - * @return a Maybe that emits a single item: the item at the specified position in the sequence of + * @return a {@code Maybe} that emits a single item: the item at the specified position in the sequence of * those emitted by the current {@code Observable} * @throws IndexOutOfBoundsException * if {@code index} is less than 0 @@ -8389,7 +8401,7 @@ public final Maybe elementAt(long index) { } /** - * Returns a Single that emits the item found at a specified index in a sequence of emissions from + * Returns a {@link Single} that emits the item found at a specified index in a sequence of emissions from * the current {@code Observable}, or a default item if that index is out of range. *

* @@ -8402,7 +8414,7 @@ public final Maybe elementAt(long index) { * the zero-based index of the item to retrieve * @param defaultItem * the default item - * @return a Single that emits the item at the specified position in the sequence emitted by the current + * @return a {@code Single} that emits the item at the specified position in the sequence emitted by the current * {@code Observable}, or the default item if that index is outside the bounds of the source sequence * @throws IndexOutOfBoundsException * if {@code index} is less than 0 @@ -8420,8 +8432,8 @@ public final Single elementAt(long index, @NonNull T defaultItem) { } /** - * Returns a Single that emits the item found at a specified index in a sequence of emissions from this {@code Observable} - * or signals a {@link NoSuchElementException} if this {@code Observable} signals fewer elements than index. + * Returns a {@link Single} that emits the item found at a specified index in a sequence of emissions from the current {@code Observable} + * or signals a {@link NoSuchElementException} if the current {@code Observable} signals fewer elements than index. *

* *

@@ -8431,7 +8443,7 @@ public final Single elementAt(long index, @NonNull T defaultItem) { * * @param index * the zero-based index of the item to retrieve - * @return a Single that emits the item at the specified position in the sequence emitted by the current + * @return a {@code Single} that emits the item at the specified position in the sequence emitted by the current * {@code Observable}, or the default item if that index is outside the bounds of the source sequence * @throws IndexOutOfBoundsException * if {@code index} is less than 0 @@ -8448,7 +8460,7 @@ public final Single elementAtOrError(long index) { } /** - * Filters items emitted by an {@code ObservableSource} by only emitting those that satisfy a specified predicate. + * Filters items emitted by the current {@code Observable} by only emitting those that satisfy a specified {@link Predicate}. *

* *

@@ -8472,7 +8484,7 @@ public final Observable filter(@NonNull Predicate predicate) { } /** - * Returns a Maybe that emits only the very first item emitted by the current {@code Observable}, or + * Returns a {@link Maybe} that emits only the very first item emitted by the current {@code Observable}, or * completes if the current {@code Observable} is empty. *

* @@ -8481,7 +8493,7 @@ public final Observable filter(@NonNull Predicate predicate) { *

{@code firstElement} does not operate by default on a particular {@link Scheduler}.
*
* - * @return the new Maybe instance + * @return the new {@code Maybe} instance * @see ReactiveX operators documentation: First */ @CheckReturnValue @@ -8492,7 +8504,7 @@ public final Maybe firstElement() { } /** - * Returns a Single that emits only the very first item emitted by the current {@code Observable}, or a default item + * Returns a {@link Single} that emits only the very first item emitted by the current {@code Observable}, or a default item * if the current {@code Observable} completes without emitting any items. *

* @@ -8503,7 +8515,7 @@ public final Maybe firstElement() { * * @param defaultItem * the default item to emit if the current {@code Observable} doesn't emit anything - * @return the new Single instance + * @return the new {@code Single} instance * @see ReactiveX operators documentation: First */ @CheckReturnValue @@ -8514,8 +8526,8 @@ public final Single first(@NonNull T defaultItem) { } /** - * Returns a Single that emits only the very first item emitted by this {@code Observable} or - * signals a {@link NoSuchElementException} if this {@code Observable} is empty. + * Returns a {@link Single} that emits only the very first item emitted by the current {@code Observable} or + * signals a {@link NoSuchElementException} if the current {@code Observable} is empty. *

* *

@@ -8523,7 +8535,7 @@ public final Single first(@NonNull T defaultItem) { *
{@code firstOrError} does not operate by default on a particular {@link Scheduler}.
*
* - * @return the new Single instance + * @return the new {@code Single} instance * @see ReactiveX operators documentation: First */ @CheckReturnValue @@ -8535,7 +8547,7 @@ public final Single firstOrError() { /** * Returns an {@code Observable} that emits items based on applying a function that you supply to each item emitted - * by the current {@code Observable}, where that function returns an {@code ObservableSource}, and then merging those resulting + * by the current {@code Observable}, where that function returns an {@link ObservableSource}, and then merging those returned * {@code ObservableSource}s and emitting the results of this merger. *

* @@ -8562,7 +8574,7 @@ public final Observable flatMap(@NonNull Function * @@ -8592,7 +8604,7 @@ public final Observable flatMap(@NonNull Function @@ -8626,7 +8638,7 @@ public final Observable flatMap(@NonNull Function @@ -8674,7 +8686,7 @@ public final Observable flatMap(@NonNull Function * *

@@ -8687,10 +8699,10 @@ public final Observable flatMap(@NonNull Function Observable flatMap( /** * Returns an {@code Observable} that applies a function to each item emitted or notification raised by the current - * {@code Observable} and then flattens the {@code ObservableSource}s returned from these functions and emits the resulting items, + * {@code Observable} and then flattens the {@link ObservableSource}s returned from these functions and emits the resulting items, * while limiting the maximum number of concurrent subscriptions to these {@code ObservableSource}s. *

* @@ -8725,10 +8737,10 @@ public final Observable flatMap( * @param onNextMapper * a function that returns an {@code ObservableSource} to merge for each item emitted by the current {@code Observable} * @param onErrorMapper - * a function that returns an {@code ObservableSource} to merge for an onError notification from the current + * a function that returns an {@code ObservableSource} to merge for an {@code onError} notification from the current * {@code Observable} * @param onCompleteSupplier - * a function that returns an {@code ObservableSource} to merge for an onComplete notification from the current + * a function that returns an {@code ObservableSource} to merge for an {@code onComplete} notification from the current * {@code Observable} * @param maxConcurrency * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently @@ -8753,7 +8765,7 @@ public final Observable flatMap( /** * Returns an {@code Observable} that emits items based on applying a function that you supply to each item emitted - * by the current {@code Observable}, where that function returns an {@code ObservableSource}, and then merging those resulting + * by the current {@code Observable}, where that function returns an {@link ObservableSource}, and then merging those returned * {@code ObservableSource}s and emitting the results of this merger, while limiting the maximum number of concurrent * subscriptions to these {@code ObservableSource}s. *

@@ -8929,7 +8941,7 @@ public final Observable flatMap(@NonNull Function * @@ -8971,8 +8983,8 @@ public final Observable flatMap(@NonNull FunctionScheduler: *

{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.
*
- * @param mapper the function that received each source value and transforms them into CompletableSources. - * @return the new Completable instance + * @param mapper the function that received each source value and transforms them into {@code CompletableSource}s. + * @return the new {@link Completable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -8982,18 +8994,18 @@ public final Completable flatMapCompletable(@NonNull Function * *
*
Scheduler:
*
{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.
*
- * @param mapper the function that received each source value and transforms them into CompletableSources. - * @param delayErrors if true errors from the upstream and inner CompletableSources are delayed until each of them - * terminates. - * @return the new Completable instance + * @param mapper the function that received each source value and transforms them into {@code CompletableSource}s. + * @param delayErrors if {@code true}, errors from the upstream and inner {@code CompletableSource}s are delayed until all of them + * terminate. + * @return the new {@link Completable} instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -9004,8 +9016,8 @@ public final Completable flatMapCompletable(@NonNull Function * *
@@ -9014,12 +9026,11 @@ public final Completable flatMapCompletable(@NonNull Function * * @param - * the type of item emitted by the resulting {@code Iterable} + * the output type and the element type of the {@code Iterable}s * @param mapper * a function that returns an {@code Iterable} sequence of values for when given an item emitted by the * current {@code Observable} - * @return an {@code Observable} that emits the results of merging the items emitted by the current {@code Observable} with - * the values in the Iterables corresponding to those items, as generated by {@code collectionSelector} + * @return the new {@code Observable} instance * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -9031,8 +9042,10 @@ public final Observable flatMapIterable(@NonNull Function * *
@@ -9041,17 +9054,16 @@ public final Observable flatMapIterable(@NonNull Function * * @param - * the collection element type + * the element type of the {@code Iterable}s * @param - * the type of item emitted by the resulting Iterable + * the output type as determined by the {@code resultSelector} function * @param mapper - * a function that returns an Iterable sequence of values for each item emitted by the current + * a function that returns an {@code Iterable} sequence of values for each item emitted by the current * {@code Observable} * @param resultSelector * a function that returns an item based on the item emitted by the current {@code Observable} and the - * Iterable returned for that item by the {@code collectionSelector} - * @return an {@code Observable} that emits the items returned by {@code resultSelector} for each item in the current - * {@code Observable} + * next item of the {@code Iterable} returned for that original item by the {@code mapper} + * @return the new {@code Observable} instance * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -9066,7 +9078,7 @@ public final Observable flatMapIterable(@NonNull Function * *
@@ -9074,7 +9086,7 @@ public final Observable flatMapIterable(@NonNull Function{@code flatMapMaybe} does not operate by default on a particular {@link Scheduler}. *
* @param the result value type - * @param mapper the function that received each source value and transforms them into MaybeSources. + * @param mapper the function that received each source value and transforms them into {@code MaybeSource}s. * @return the new {@code Observable} instance */ @CheckReturnValue @@ -9085,8 +9097,8 @@ public final Observable flatMapMaybe(@NonNull Function * @@ -9095,9 +9107,9 @@ public final Observable flatMapMaybe(@NonNull Function{@code flatMapMaybe} does not operate by default on a particular {@link Scheduler}. *
* @param the result value type - * @param mapper the function that received each source value and transforms them into MaybeSources. - * @param delayErrors if true errors from the upstream and inner MaybeSources are delayed until each of them - * terminates. + * @param mapper the function that received each source value and transforms them into {@code MaybeSource}s. + * @param delayErrors if {@code true}, errors from the upstream and inner {@code MaybeSource}s are delayed until all of them + * terminate. * @return the new {@code Observable} instance */ @CheckReturnValue @@ -9109,8 +9121,8 @@ public final Observable flatMapMaybe(@NonNull Function * *
@@ -9118,7 +9130,7 @@ public final Observable flatMapMaybe(@NonNull Function{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}. *
* @param the result value type - * @param mapper the function that received each source value and transforms them into SingleSources. + * @param mapper the function that received each source value and transforms them into {@code SingleSource}s. * @return the new {@code Observable} instance */ @CheckReturnValue @@ -9129,8 +9141,8 @@ public final Observable flatMapSingle(@NonNull Function * @@ -9139,8 +9151,8 @@ public final Observable flatMapSingle(@NonNull Function{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}. *
* @param the result value type - * @param mapper the function that received each source value and transforms them into SingleSources. - * @param delayErrors if true errors from the upstream and inner SingleSources are delayed until each of them + * @param mapper the function that received each source value and transforms them into {@code SingleSource}s. + * @param delayErrors if {@code true}, errors from the upstream and inner {@code SingleSource}s are delayed until each of them * terminates. * @return the new {@code Observable} instance */ @@ -9153,7 +9165,8 @@ public final Observable flatMapSingle(@NonNull Function * *

@@ -9164,11 +9177,11 @@ public final Observable flatMapSingle(@NonNull Function * * @param onNext - * {@link Consumer} to execute for each item. + * the {@code Consumer} to execute for each item. * @return - * a Disposable that allows disposing of an asynchronous sequence + * a {@link Disposable} that allows disposing the sequence if the current {@code Observable} runs asynchronously * @throws NullPointerException - * if {@code onNext} is null + * if {@code onNext} is {@code null} * @see ReactiveX operators documentation: Subscribe */ @CheckReturnValue @@ -9179,25 +9192,25 @@ public final Disposable forEach(@NonNull Consumer onNext) { } /** - * Subscribes to the {@link ObservableSource} and receives notifications for each element until the - * onNext Predicate returns false. + * Subscribes to the {@link ObservableSource} and calls a {@link Predicate} for each item of the current {@code Observable}, + * on its emission thread, until the predicate returns {@code false}. *

* *

* If the {@code Observable} emits an error, it is wrapped into an - * {@link io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException} - * and routed to the RxJavaPlugins.onError handler. + * {@link OnErrorNotImplementedException} + * and routed to the {@link RxJavaPlugins#onError(Throwable)} handler. *

*
Scheduler:
*
{@code forEachWhile} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext - * {@link Predicate} to execute for each item. + * the {@code Predicate} to execute for each item. * @return - * a Disposable that allows disposing of an asynchronous sequence + * a {@link Disposable} that allows disposing the sequence if the current {@code Observable} runs asynchronously * @throws NullPointerException - * if {@code onNext} is null + * if {@code onNext} is {@code null} * @see ReactiveX operators documentation: Subscribe */ @CheckReturnValue @@ -9208,22 +9221,21 @@ public final Disposable forEachWhile(@NonNull Predicate onNext) { } /** - * Subscribes to the {@link ObservableSource} and receives notifications for each element and error events until the - * onNext Predicate returns false. + * Subscribes to the {@link ObservableSource} and calls a {@link Predicate} for each item or a {@link Consumer} with the error + * of the current {@code Observable}, on their original emission threads, until the predicate returns {@code false}. *
*
Scheduler:
*
{@code forEachWhile} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext - * {@link Predicate} to execute for each item. + * the {@code Predicate} to execute for each item. * @param onError - * {@link Consumer} to execute when an error is emitted. + * the {@code Consumer} to execute when an error is emitted. * @return - * a Disposable that allows disposing of an asynchronous sequence + * a {@link Disposable} that allows disposing the sequence if the current {@code Observable} runs asynchronously * @throws NullPointerException - * if {@code onNext} is null, or - * if {@code onError} is null + * if {@code onNext} or {@code onError} is {@code null} * @see ReactiveX operators documentation: Subscribe */ @CheckReturnValue @@ -9234,25 +9246,24 @@ public final Disposable forEachWhile(@NonNull Predicate onNext, @NonN } /** - * Subscribes to the {@link ObservableSource} and receives notifications for each element and the terminal events until the - * onNext Predicate returns false. + * Subscribes to the {@link ObservableSource} and calls a {@link Predicate} for each item, a {@link Consumer} with the error + * or an {@link Action} upon completion of the current {@code Observable}, on their original emission threads, + * until the predicate returns {@code false}. *
*
Scheduler:
*
{@code forEachWhile} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext - * {@link Predicate} to execute for each item. + * the {@code Predicate} to execute for each item. * @param onError - * {@link Consumer} to execute when an error is emitted. + * the {@code Consumer} to execute when an error is emitted. * @param onComplete - * {@link Action} to execute when completion is signaled. + * the {@code Action} to execute when completion is signaled. * @return - * a Disposable that allows disposing of an asynchronous sequence + * a {@link Disposable} that allows disposing the sequence if the current {@code Observable} runs asynchronously * @throws NullPointerException - * if {@code onNext} is null, or - * if {@code onError} is null, or - * if {@code onComplete} is null + * if {@code onNext} or {@code onError} or {@code onComplete} is {@code null} * @see ReactiveX operators documentation: Subscribe */ @CheckReturnValue @@ -9270,17 +9281,19 @@ public final Disposable forEachWhile(@NonNull Predicate onNext, @NonN } /** - * Groups the items emitted by an {@code ObservableSource} according to a specified criterion, and emits these - * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservableSource} allows only a single - * {@link Observer} during its lifetime and if this {@code Observer} calls dispose() before the - * source terminates, the next emission by the source having the same key will trigger a new - * {@code GroupedObservableSource} emission. + * Groups the items emitted by the current {@code Observable} according to a specified criterion, and emits these + * grouped items as {@link GroupedObservable}s. *

* *

- * Note: A {@link GroupedObservable} will cache the items it is to emit until such time as it + * Each emitted {@code GroupedObservable} allows only a single {@link Observer} to subscribe to it during its + * lifetime and if this {@code Observer} calls {@code dispose()} before the + * source terminates, the next emission by the source having the same key will trigger a new + * {@code GroupedObservable} emission. + *

+ * Note: A {@code GroupedObservable} will cache the items it is to emit until such time as it * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those - * {@code GroupedObservableSource}s that do not concern you. Instead, you can signal to them that they may + * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may * discard their buffers by applying an operator like {@link #ignoreElements} to them. *

* Note also that ignoring groups or subscribing later (i.e., on another thread) will result in @@ -9297,7 +9310,7 @@ public final Disposable forEachWhile(@NonNull Predicate onNext, @NonN * a function that extracts the key for each item * @param * the key type - * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a + * @return an {@code Observable} that emits {@code GroupedObservable}s, each of which corresponds to a * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy @@ -9311,17 +9324,19 @@ public final Observable> groupBy(@NonNull Function * *

- * Note: A {@link GroupedObservable} will cache the items it is to emit until such time as it + * Each emitted {@code GroupedObservable} allows only a single {@link Observer} to subscribe to it during its + * lifetime and if this {@code Observer} calls {@code dispose()} before the + * source terminates, the next emission by the source having the same key will trigger a new + * {@code GroupedObservable} emission. + *

+ * Note: A {@code GroupedObservable} will cache the items it is to emit until such time as it * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those - * {@code GroupedObservableSource}s that do not concern you. Instead, you can signal to them that they may + * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may * discard their buffers by applying an operator like {@link #ignoreElements} to them. *

* Note also that ignoring groups or subscribing later (i.e., on another thread) will result in @@ -9341,7 +9356,7 @@ public final Observable> groupBy(@NonNull FunctionReactiveX operators documentation: GroupBy @@ -9355,17 +9370,19 @@ public final Observable> groupBy(@NonNull Function * *

- * Note: A {@link GroupedObservable} will cache the items it is to emit until such time as it + * Each emitted {@code GroupedObservable} allows only a single {@link Observer} to subscribe to it during its + * lifetime and if this {@code Observer} calls {@code dispose()} before the + * source terminates, the next emission by the source having the same key will trigger a new + * {@code GroupedObservable} emission. + *

+ * Note: A {@code GroupedObservable} will cache the items it is to emit until such time as it * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those - * {@code GroupedObservableSource}s that do not concern you. Instead, you can signal to them that they may + * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may * discard their buffers by applying an operator like {@link #ignoreElements} to them. *

* Note also that ignoring groups or subscribing later (i.e., on another thread) will result in @@ -9386,7 +9403,7 @@ public final Observable> groupBy(@NonNull Function * the element type - * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a + * @return an {@code Observable} that emits {@code GroupedObservable}s, each of which corresponds to a * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy @@ -9400,17 +9417,19 @@ public final Observable> groupBy(@NonNull Functio } /** - * Groups the items emitted by an {@code ObservableSource} according to a specified criterion, and emits these - * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservableSource} allows only a single - * {@link Observer} during its lifetime and if this {@code Observer} calls dispose() before the - * source terminates, the next emission by the source having the same key will trigger a new - * {@code GroupedObservableSource} emission. + * Groups the items emitted by the current {@code Observable} according to a specified criterion, and emits these + * grouped items as {@link GroupedObservable}s. *

* *

- * Note: A {@link GroupedObservable} will cache the items it is to emit until such time as it + * Each emitted {@code GroupedObservable} allows only a single {@link Observer} to subscribe to it during its + * lifetime and if this {@code Observer} calls {@code dispose()} before the + * source terminates, the next emission by the source having the same key will trigger a new + * {@code GroupedObservable} emission. + *

+ * Note: A {@code GroupedObservable} will cache the items it is to emit until such time as it * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those - * {@code GroupedObservableSource}s that do not concern you. Instead, you can signal to them that they may + * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may * discard their buffers by applying an operator like {@link #ignoreElements} to them. *

* Note also that ignoring groups or subscribing later (i.e., on another thread) will result in @@ -9434,7 +9453,7 @@ public final Observable> groupBy(@NonNull Functio * @param delayError * if {@code true}, the exception from the current {@code Observable} is delayed in each group until that specific group emitted * the normal values; if {@code false}, the exception bypasses values in the groups and is reported immediately. - * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a + * @return an {@code Observable} that emits {@code GroupedObservable}s, each of which corresponds to a * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy @@ -9448,17 +9467,19 @@ public final Observable> groupBy(@NonNull Functio } /** - * Groups the items emitted by an {@code ObservableSource} according to a specified criterion, and emits these - * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservableSource} allows only a single - * {@link Observer} during its lifetime and if this {@code Observer} calls dispose() before the - * source terminates, the next emission by the source having the same key will trigger a new - * {@code GroupedObservableSource} emission. + * Groups the items emitted by the current {@code Observable} according to a specified criterion, and emits these + * grouped items as {@link GroupedObservable}s. *

* *

- * Note: A {@link GroupedObservable} will cache the items it is to emit until such time as it + * Each emitted {@code GroupedObservable} allows only a single {@link Observer} to subscribe to it during its + * lifetime and if this {@code Observer} calls {@code dispose()} before the + * source terminates, the next emission by the source having the same key will trigger a new + * {@code GroupedObservable} emission. + *

+ * Note: A {@code GroupedObservable} will cache the items it is to emit until such time as it * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those - * {@code GroupedObservableSource}s that do not concern you. Instead, you can signal to them that they may + * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may * discard their buffers by applying an operator like {@link #ignoreElements} to them. *

* Note also that ignoring groups or subscribing later (i.e., on another thread) will result in @@ -9479,12 +9500,12 @@ public final Observable> groupBy(@NonNull Functio * if {@code true}, the exception from the current {@code Observable} is delayed in each group until that specific group emitted * the normal values; if {@code false}, the exception bypasses values in the groups and is reported immediately. * @param bufferSize - * the hint for how many {@link GroupedObservable}s and element in each {@link GroupedObservable} should be buffered + * the hint for how many {@code GroupedObservable}s and element in each {@code GroupedObservable} should be buffered * @param * the key type * @param * the element type - * @return an {@code ObservableSource} that emits {@link GroupedObservable}s, each of which corresponds to a + * @return an {@code Observable} that emits {@code GroupedObservable}s, each of which corresponds to a * unique key value and each of which emits those items from the current {@code Observable} that share that * key value * @see ReactiveX operators documentation: GroupBy @@ -9503,7 +9524,7 @@ public final Observable> groupBy(@NonNull Functio } /** - * Returns an {@code Observable} that correlates two {@code ObservableSource}s when they overlap in time and groups the results. + * Returns an {@code Observable} that correlates two {@link ObservableSource}s when they overlap in time and groups the results. *

* There are no guarantees in what order the items get combined when multiple * items from one or both source {@code ObservableSource}s overlap. @@ -9551,8 +9572,9 @@ public final Observable groupJoin( } /** - * Hides the identity of this {@code Observable} and its Disposable. - *

Allows hiding extra features such as {@link io.reactivex.rxjava3.subjects.Subject}'s + * Hides the identity of the current {@code Observable} and its {@link Disposable}. + *

+ * Allows hiding extra features such as {@link io.reactivex.rxjava3.subjects.Subject}'s * {@link Observer} methods or preventing certain identity-based * optimizations (fusion). *

@@ -9581,7 +9603,7 @@ public final Observable hide() { *

{@code ignoreElements} does not operate by default on a particular {@link Scheduler}.
*
* - * @return the new Completable instance + * @return the new {@link Completable} instance * @see ReactiveX operators documentation: IgnoreElements */ @CheckReturnValue @@ -9592,9 +9614,9 @@ public final Completable ignoreElements() { } /** - * Returns a Single that emits {@code true} if the current {@code Observable} is empty, otherwise {@code false}. + * Returns a {@link Single} that emits {@code true} if the current {@code Observable} is empty, otherwise {@code false}. *

- * In Rx.Net this is negated as the {@code any} {@code Observer} but we renamed this in RxJava to better match Java + * In Rx.Net this is negated as the {@code any} {@link Observer} but we renamed this in RxJava to better match Java * naming idioms. *

* @@ -9603,7 +9625,7 @@ public final Completable ignoreElements() { *

{@code isEmpty} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a Single that emits a Boolean + * @return a {@code Single} that emits a {@link Boolean} * @see ReactiveX operators documentation: Contains */ @CheckReturnValue @@ -9614,7 +9636,7 @@ public final Single isEmpty() { } /** - * Correlates the items emitted by two {@code ObservableSource}s based on overlapping durations. + * Correlates the items emitted by two {@link ObservableSource}s based on overlapping durations. *

* There are no guarantees in what order the items get combined when multiple * items from one or both source {@code ObservableSource}s overlap. @@ -9662,8 +9684,8 @@ public final Observable join( } /** - * Returns a Maybe that emits the last item emitted by this {@code Observable} or - * completes if this {@code Observable} is empty. + * Returns a {@link Maybe} that emits the last item emitted by the current {@code Observable} or + * completes if the current {@code Observable} is empty. *

* *

@@ -9671,7 +9693,7 @@ public final Observable join( *
{@code lastElement} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a Maybe that emits the last item from the current {@code Observable} or notifies observers of an + * @return a {@code Maybe} that emits the last item from the current {@code Observable} or notifies observers of an * error * @see ReactiveX operators documentation: Last */ @@ -9683,8 +9705,8 @@ public final Maybe lastElement() { } /** - * Returns a Single that emits only the last item emitted by this {@code Observable}, or a default item - * if this {@code Observable} completes without emitting any items. + * Returns a {@link Single} that emits only the last item emitted by the current {@code Observable}, or a default item + * if the current {@code Observable} completes without emitting any items. *

* *

@@ -9694,7 +9716,7 @@ public final Maybe lastElement() { * * @param defaultItem * the default item to emit if the current {@code Observable} is empty - * @return a Single that emits only the last item emitted by the current {@code Observable}, or a default item + * @return a {@code Single} that emits only the last item emitted by the current {@code Observable}, or a default item * if the current {@code Observable} is empty * @see ReactiveX operators documentation: Last */ @@ -9707,8 +9729,8 @@ public final Single last(@NonNull T defaultItem) { } /** - * Returns a Single that emits only the last item emitted by this {@code Observable} or - * signals a {@link NoSuchElementException} if this {@code Observable} is empty. + * Returns a {@link Single} that emits only the last item emitted by the current {@code Observable} or + * signals a {@link NoSuchElementException} if the current {@code Observable} is empty. *

* *

@@ -9716,8 +9738,8 @@ public final Single last(@NonNull T defaultItem) { *
{@code lastOrError} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a Single that emits only the last item emitted by the current {@code Observable}. - * If the current {@code Observable} completes without emitting any items a {@link NoSuchElementException} will be thrown. + * @return a {@code Single} that emits only the last item emitted by the current {@code Observable}. + * If the current {@code Observable} completes without emitting any items a {@code NoSuchElementException} will be thrown. * @see ReactiveX operators documentation: Last */ @CheckReturnValue @@ -9732,7 +9754,7 @@ public final Single lastOrError() { * other standard composition methods first; * Returns an {@code Observable} which, when subscribed to, invokes the {@link ObservableOperator#apply(Observer) apply(Observer)} method * of the provided {@link ObservableOperator} for each individual downstream {@link Observer} and allows the - * insertion of a custom operator by accessing the downstream's {@link Observer} during this subscription phase + * insertion of a custom operator by accessing the downstream's {@code Observer} during this subscription phase * and providing a new {@code Observer}, containing the custom operator's intended business logic, that will be * used in the subscription process going further upstream. *

@@ -9849,20 +9871,20 @@ public final Single lastOrError() { * class and creating an {@link ObservableTransformer} with it is recommended. *

* Note also that it is not possible to stop the subscription phase in {@code lift()} as the {@code apply()} method - * requires a non-null {@code Observer} instance to be returned, which is then unconditionally subscribed to + * requires a non-{@code null} {@code Observer} instance to be returned, which is then unconditionally subscribed to * the current {@code Observable}. For example, if the operator decided there is no reason to subscribe to the * upstream source because of some optimization possibility or a failure to prepare the operator, it still has to - * return an {@code Observer} that should immediately dispose the upstream's {@code Disposable} in its + * return an {@code Observer} that should immediately dispose the upstream's {@link Disposable} in its * {@code onSubscribe} method. Again, using an {@code ObservableTransformer} and extending the {@code Observable} is * a better option as {@link #subscribeActual} can decide to not subscribe to its upstream after all. *

*
Scheduler:
*
{@code lift} does not operate by default on a particular {@link Scheduler}, however, the - * {@link ObservableOperator} may use a {@code Scheduler} to support its own asynchronous behavior.
+ * {@code ObservableOperator} may use a {@code Scheduler} to support its own asynchronous behavior. *
* * @param the output value type - * @param lifter the {@link ObservableOperator} that receives the downstream's {@code Observer} and should return + * @param lifter the {@code ObservableOperator} that receives the downstream's {@code Observer} and should return * an {@code Observer} with custom behavior to be used as the consumer for the current * {@code Observable}. * @return the new {@code Observable} instance @@ -9889,7 +9911,7 @@ public final Observable lift(@NonNull ObservableOperator the output type * @param mapper - * a function to apply to each item emitted by the {@code ObservableSource} + * a function to apply to each item emitted by the current {@code Observable} * @return an {@code Observable} that emits the items from the current {@code Observable}, transformed by the specified * function * @see ReactiveX operators documentation: Map @@ -9925,7 +9947,7 @@ public final Observable> materialize() { } /** - * Flattens this and another {@code ObservableSource} into a single {@code ObservableSource}, without any transformation. + * Flattens the current {@code Observable} and another {@link ObservableSource} into a single {@code Observable} sequence, without any transformation. *

* *

@@ -9950,11 +9972,11 @@ public final Observable mergeWith(@NonNull ObservableSource othe } /** - * Merges the sequence of items of this {@code Observable} with the success value of the other SingleSource. + * Merges the sequence of items of the current {@code Observable} with the success value of the other {@link SingleSource}. *

* *

- * The success value of the other {@code SingleSource} can get interleaved at any point of this + * The success value of the other {@code SingleSource} can get interleaved at any point of the current * {@code Observable} sequence. *

*
Scheduler:
@@ -9974,12 +9996,12 @@ public final Observable mergeWith(@NonNull SingleSource other) { } /** - * Merges the sequence of items of this {@code Observable} with the success value of the other MaybeSource - * or waits both to complete normally if the MaybeSource is empty. + * Merges the sequence of items of the current {@code Observable} with the success value of the other {@link MaybeSource} + * or waits both to complete normally if the {@code MaybeSource} is empty. *

* *

- * The success value of the other {@code MaybeSource} can get interleaved at any point of this + * The success value of the other {@code MaybeSource} can get interleaved at any point of the current * {@code Observable} sequence. *

*
Scheduler:
@@ -9999,7 +10021,7 @@ public final Observable mergeWith(@NonNull MaybeSource other) { } /** - * Relays the items of this {@code Observable} and completes only when the other CompletableSource completes + * Relays the items of the current {@code Observable} and completes only when the other {@link CompletableSource} completes * as well. *

* @@ -10021,29 +10043,29 @@ public final Observable mergeWith(@NonNull CompletableSource other) { } /** - * Modifies an {@code ObservableSource} to perform its emissions and notifications on a specified {@link Scheduler}, + * Returns an {@code Observable} to perform the current {@code Observable}'s emissions and notifications on a specified {@link Scheduler}, * asynchronously with an unbounded buffer with {@link Flowable#bufferSize()} "island size". * - *

Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly + *

Note that {@code onError} notifications will cut ahead of {@code onNext} notifications on the emission thread if {@code Scheduler} is truly * asynchronous. If strict event ordering is required, consider using the {@link #observeOn(Scheduler, boolean)} overload. *

* *

- * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, + * This operator keeps emitting as many signals as it can on the given {@code Scheduler}'s worker thread, * which may result in a longer than expected occupation of this thread. In other terms, * it does not allow per-signal fairness in case the worker runs on a shared underlying thread. * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead. *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
*

"Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed * on the other side of the asynchronous boundary. * * @param scheduler - * the {@link Scheduler} to notify {@link Observer}s on - * @return the current {@code Observable} modified so that its {@link Observer}s are notified on the specified - * {@link Scheduler} + * the {@code Scheduler} to notify {@link Observer}s on + * @return the current {@code Observable} modified so that its {@code Observer}s are notified on the specified + * {@code Scheduler} * @see ReactiveX operators documentation: ObserveOn * @see RxJava Threading Examples * @see #subscribeOn @@ -10059,30 +10081,30 @@ public final Observable observeOn(@NonNull Scheduler scheduler) { } /** - * Modifies an {@code ObservableSource} to perform its emissions and notifications on a specified {@link Scheduler}, - * asynchronously with an unbounded buffer with {@link Flowable#bufferSize()} "island size" and optionally delays onError notifications. + * Returns an {@code Observable} to perform the current {@code Observable}'s emissions and notifications on a specified {@link Scheduler}, + * asynchronously with an unbounded buffer with {@link Flowable#bufferSize()} "island size" and optionally delays {@code onError} notifications. *

* *

- * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, + * This operator keeps emitting as many signals as it can on the given {@code Scheduler}'s worker thread, * which may result in a longer than expected occupation of this thread. In other terms, * it does not allow per-signal fairness in case the worker runs on a shared underlying thread. * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead. *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
*

"Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed * on the other side of the asynchronous boundary. * * @param scheduler - * the {@link Scheduler} to notify {@link Observer}s on + * the {@code Scheduler} to notify {@link Observer}s on * @param delayError - * indicates if the onError notification may not cut ahead of onNext notification on the other side of the - * scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received - * from upstream - * @return the current {@code Observable} modified so that its {@link Observer}s are notified on the specified - * {@link Scheduler} + * indicates if the {@code onError} notification may not cut ahead of {@code onNext} notification on the other side of the + * scheduling boundary. If {@code true}, a sequence ending in {@code onError} will be replayed in the same order as was received + * from the current {@code Observable} + * @return the current {@code Observable} modified so that its {@code Observer}s are notified on the specified + * {@code Scheduler} * @see ReactiveX operators documentation: ObserveOn * @see RxJava Threading Examples * @see #subscribeOn @@ -10098,31 +10120,31 @@ public final Observable observeOn(@NonNull Scheduler scheduler, boolean delay } /** - * Modifies an {@code ObservableSource} to perform its emissions and notifications on a specified {@link Scheduler}, - * asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications. + * Returns an {@code Observable} to perform the current {@code Observable}'s emissions and notifications on a specified {@link Scheduler}, + * asynchronously with an unbounded buffer of configurable "island size" and optionally delays {@code onError} notifications. *

* *

- * This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, + * This operator keeps emitting as many signals as it can on the given {@code Scheduler}'s worker thread, * which may result in a longer than expected occupation of this thread. In other terms, * it does not allow per-signal fairness in case the worker runs on a shared underlying thread. * If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead. *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
*

"Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed * on the other side of the asynchronous boundary. Values below 16 are not recommended in performance sensitive scenarios. * * @param scheduler - * the {@link Scheduler} to notify {@link Observer}s on + * the {@code Scheduler} to notify {@link Observer}s on * @param delayError - * indicates if the onError notification may not cut ahead of onNext notification on the other side of the - * scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received + * indicates if the {@code onError} notification may not cut ahead of {@code onNext} notification on the other side of the + * scheduling boundary. If {@code true} a sequence ending in {@code onError} will be replayed in the same order as was received * from upstream * @param bufferSize the size of the buffer. - * @return the current {@code Observable} modified so that its {@link Observer}s are notified on the specified - * {@link Scheduler} + * @return the current {@code Observable} modified so that its {@code Observer}s are notified on the specified + * {@code Scheduler} * @see ReactiveX operators documentation: ObserveOn * @see RxJava Threading Examples * @see #subscribeOn @@ -10140,7 +10162,7 @@ public final Observable observeOn(@NonNull Scheduler scheduler, boolean delay } /** - * Filters the items emitted by an {@code ObservableSource}, only emitting those of the specified type. + * Filters the items emitted by the current {@code Observable}, only emitting those of the specified type. *

* *

@@ -10163,19 +10185,19 @@ public final Observable ofType(@NonNull Class clazz) { } /** - * Instructs an {@code ObservableSource} to pass control to another {@code ObservableSource} rather than invoking + * Instructs the current {@code Observable} to pass control to another {@link ObservableSource} rather than invoking * {@link Observer#onError onError} if it encounters an error. *

* *

* By default, when an {@code ObservableSource} encounters an error that prevents it from emitting the expected item to - * its {@link Observer}, the {@code ObservableSource} invokes its Observer's {@code onError} method, and then quits - * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this + * its {@link Observer}, the {@code ObservableSource} invokes its {@code Observer}'s {@code onError} method, and then quits + * without invoking any more of its {@code Observer}'s methods. The {@code onErrorResumeNext} method changes this * behavior. If you pass a function that returns an {@code ObservableSource} ({@code resumeFunction}) to * {@code onErrorResumeNext}, if the original {@code ObservableSource} encounters an error, instead of invoking its - * Observer's {@code onError} method, it will instead relinquish control to the {@code ObservableSource} returned from - * {@code resumeFunction}, which will invoke the Observer's {@link Observer#onNext onNext} method if it is - * able to do so. In such a case, because no {@code ObservableSource} necessarily invokes {@code onError}, the Observer + * {@code Observer}'s {@code onError} method, it will instead relinquish control to the {@code ObservableSource} returned from + * {@code resumeFunction}, which will invoke the {@code Observer}'s {@link Observer#onNext onNext} method if it is + * able to do so. In such a case, because no {@code ObservableSource} necessarily invokes {@code onError}, the {@code Observer} * may never know that an error happened. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be @@ -10200,18 +10222,18 @@ public final Observable onErrorResumeNext(@NonNull Function * *

* By default, when an {@code ObservableSource} encounters an error that prevents it from emitting the expected item to - * its {@link Observer}, the {@code ObservableSource} invokes its Observer's {@code onError} method, and then quits - * without invoking any more of its Observer's methods. The {@code onErrorResumeWith} method changes this + * its {@link Observer}, the {@code ObservableSource} invokes its {@code Observer}'s {@code onError} method, and then quits + * without invoking any more of its {@code Observer}'s methods. The {@code onErrorResumeWith} method changes this * behavior. If you pass another {@code ObservableSource} ({@code next}) to an {@code ObservableSource}'s * {@code onErrorResumeWith} method, if the original {@code ObservableSource} encounters an error, instead of invoking its - * Observer's {@code onError} method, it will instead relinquish control to {@code next} which - * will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case, + * {@code Observer}'s {@code onError} method, it will instead relinquish control to {@code next} which + * will invoke the {@code Observer}'s {@link Observer#onNext onNext} method if it is able to do so. In such a case, * because no {@code ObservableSource} necessarily invokes {@code onError}, the {@code Observer} may never know that an error * happened. *

@@ -10237,16 +10259,16 @@ public final Observable onErrorResumeWith(@NonNull ObservableSource * *

- * By default, when an {@code ObservableSource} encounters an error that prevents it from emitting the expected item to - * its {@link Observer}, the {@code ObservableSource} invokes its Observer's {@code onError} method, and then quits - * without invoking any more of its Observer's methods. The {@code onErrorReturn} method changes this + * By default, when an {@link ObservableSource} encounters an error that prevents it from emitting the expected item to + * its {@link Observer}, the {@code ObservableSource} invokes its {@code Observer}'s {@code onError} method, and then quits + * without invoking any more of its {@code Observer}'s methods. The {@code onErrorReturn} method changes this * behavior. If you pass a function ({@code resumeFunction}) to an {@code ObservableSource}'s {@code onErrorReturn} - * method, if the original {@code ObservableSource} encounters an error, instead of invoking its Observer's + * method, if the original {@code ObservableSource} encounters an error, instead of invoking its {@code Observer}'s * {@code onError} method, it will instead emit the return value of {@code resumeFunction}. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be @@ -10257,8 +10279,8 @@ public final Observable onErrorResumeWith(@NonNull ObservableSource * * @param valueSupplier - * a function that returns a single value that will be emitted along with a regular onComplete in case - * the current {@code Observable} signals an onError event + * a function that returns a single value that will be emitted along with a regular {@code onComplete} in case + * the current {@code Observable} signals an {@code onError} event * @return the original {@code ObservableSource} with appropriately modified behavior * @see ReactiveX operators documentation: Catch */ @@ -10271,16 +10293,16 @@ public final Observable onErrorReturn(@NonNull Function * *

- * By default, when an {@code ObservableSource} encounters an error that prevents it from emitting the expected item to - * its {@link Observer}, the {@code ObservableSource} invokes its Observer's {@code onError} method, and then quits - * without invoking any more of its Observer's methods. The {@code onErrorReturn} method changes this + * By default, when an {@link ObservableSource} encounters an error that prevents it from emitting the expected item to + * its {@link Observer}, the {@code ObservableSource} invokes its {@code Observer}'s {@code onError} method, and then quits + * without invoking any more of its {@code Observer}'s methods. The {@code onErrorReturn} method changes this * behavior. If you pass a function ({@code resumeFunction}) to an {@code ObservableSource}'s {@code onErrorReturn} - * method, if the original {@code ObservableSource} encounters an error, instead of invoking its Observer's + * method, if the original {@code ObservableSource} encounters an error, instead of invoking its {@code Observer}'s * {@code onError} method, it will instead emit the return value of {@code resumeFunction}. *

* You can use this to prevent errors from propagating or to supply fallback data should errors be @@ -10291,7 +10313,7 @@ public final Observable onErrorReturn(@NonNull Function * * @param item - * the value that is emitted along with a regular onComplete in case the current + * the value that is emitted along with a regular {@code onComplete} in case the current * {@code Observable} signals an exception * @return the original {@code ObservableSource} with appropriately modified behavior * @see ReactiveX operators documentation: Catch @@ -10305,16 +10327,16 @@ public final Observable onErrorReturnItem(@NonNull T item) { } /** - * Nulls out references to the upstream producer and downstream {@code Observer} if - * the sequence is terminated or downstream calls dispose(). + * Nulls out references to the upstream producer and downstream {@link Observer} if + * the sequence is terminated or downstream calls {@code dispose()}. *

* *

*
Scheduler:
*
{@code onTerminateDetach} does not operate by default on a particular {@link Scheduler}.
*
- * @return an {@code Observable} which nulls out references to the upstream producer and downstream {@code Observer} if - * the sequence is terminated or downstream calls dispose() + * @return an {@code Observable} which {@code null}s out references to the upstream producer and downstream {@code Observer} if + * the sequence is terminated or downstream calls {@code dispose()} * @since 2.0 */ @CheckReturnValue @@ -10325,7 +10347,7 @@ public final Observable onTerminateDetach() { } /** - * Returns a {@link ConnectableObservable}, which is a variety of {@code ObservableSource} that waits until its + * Returns a {@link ConnectableObservable}, which is a variety of {@link ObservableSource} that waits until its * {@link ConnectableObservable#connect connect} method is called before it begins emitting items to those * {@link Observer}s that have subscribed to it. *

@@ -10335,8 +10357,8 @@ public final Observable onTerminateDetach() { *

{@code publish} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a {@link ConnectableObservable} that upon connection causes the current {@code Observable} to emit items - * to its {@link Observer}s + * @return a {@code ConnectableObservable} that upon connection causes the current {@code Observable} to emit items + * to its {@code Observer}s * @see ReactiveX operators documentation: Publish */ @CheckReturnValue @@ -10348,7 +10370,7 @@ public final ConnectableObservable publish() { /** * Returns an {@code Observable} that emits the results of invoking a specified selector on items emitted by a - * {@link ConnectableObservable} that shares a single subscription to the underlying sequence. + * {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} sequence. *

* *

@@ -10360,9 +10382,10 @@ public final ConnectableObservable publish() { * the type of items emitted by the resulting {@code Observable} * @param selector * a function that can use the multicasted source sequence as many times as needed, without - * causing multiple subscriptions to the source sequence. {@code Observer}s to the given source will + * causing multiple subscriptions to the source sequence. {@link Observer}s to the given source will * receive all notifications of the source from the time of the subscription forward. - * @return an {@code Observable} that emits the results of invoking the selector on the items emitted by a {@link ConnectableObservable} that shares a single subscription to the underlying sequence + * @return an {@code Observable} that emits the results of invoking the selector on the items + * emitted by a {@code ConnectableObservable} that shares a single subscription to the underlying sequence * @see ReactiveX operators documentation: Publish */ @CheckReturnValue @@ -10376,7 +10399,7 @@ public final Observable publish(@NonNull Function, /** * Returns a Maybe that applies a specified accumulator function to the first item emitted by the current * {@code Observable}, then feeds the result of that function along with the second item emitted by the current - * {@code Observable} into the same function, and so on until all items have been emitted by the finite source {@code ObservableSource}, + * {@code Observable} into the same function, and so on until all items have been emitted by the current and finite {@code Observable}, * and emits the final result from the final call to your function as its sole item. *

* @@ -11459,7 +11482,7 @@ public final Observable retryUntil(@NonNull BooleanSupplier stop) { * Note that the inner {@code ObservableSource} returned by the handler function should signal * either {@code onNext}, {@code onError} or {@code onComplete} in response to the received * {@code Throwable} to indicate the operator should retry or terminate. If the upstream to - * the operator is asynchronous, signaling onNext followed by onComplete immediately may + * the operator is asynchronous, signaling {@code onNext} followed by onComplete immediately may * result in the sequence to be completed immediately. Similarly, if this inner * {@code ObservableSource} signals {@code onError} or {@code onComplete} while the upstream is * active, the sequence is terminated with the same signal immediately. @@ -11662,7 +11685,7 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull * @param the element type of the sampler {@code ObservableSource} * @param sampler * the {@code ObservableSource} to use for sampling the current {@code Observable} - * @return an {@code Observable} that emits the results of sampling the items emitted by this {@code ObservableSource} whenever + * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} whenever * the {@code sampler} {@code ObservableSource} emits an item or completes * @see ReactiveX operators documentation: Sample */ @@ -11694,7 +11717,7 @@ public final Observable sample(@NonNull ObservableSource sampler) { * if true and the upstream completes while there is still an unsampled item available, * that item is emitted to downstream before completion * if {@code false}, an unsampled last item is ignored. - * @return an {@code Observable} that emits the results of sampling the items emitted by this {@code ObservableSource} whenever + * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} whenever * the {@code sampler} {@code ObservableSource} emits an item or completes * @see ReactiveX operators documentation: Sample * @since 2.1 @@ -11852,8 +11875,8 @@ public final Observable serialize() { /** * Returns a new {@link ObservableSource} that multicasts (and shares a single subscription to) the original {@link ObservableSource}. As long as - * there is at least one {@link Observer} this {@link ObservableSource} will be subscribed and emitting data. - * When all subscribers have disposed it will dispose the current {@code Observable}. + * there is at least one {@link Observer}, the current {@link Observable} will stay subscribed and keep emitting signals. + * When all observers have disposed, the operator will dispose the subscription to the current {@code Observable}. *

* This is an alias for {@link #publish()}.{@link ConnectableObservable#refCount() refCount()}. *

@@ -11875,8 +11898,9 @@ public final Observable share() { } /** - * Returns a Maybe that completes if this {@code Observable} is empty or emits the single item emitted by this {@code Observable}, - * or signals an {@code IllegalArgumentException} if this {@code Observable} emits more than one item. + * Returns a {@link Maybe} that completes if the current {@code Observable} is empty or emits the single item + * emitted by the current {@code Observable}, or signals an {@code IllegalArgumentException} if the current + * {@code Observable} emits more than one item. *

* *

@@ -11919,9 +11943,9 @@ public final Single single(@NonNull T defaultItem) { } /** - * Returns a Single that emits the single item emitted by this {@code Observable} if this {@code Observable} + * Returns a {@link Single} that emits the single item emitted by the current {@code Observable} if it * emits only a single item, otherwise - * if this {@code Observable} completes without emitting any items or emits more than one item a + * if the current {@code Observable} completes without emitting any items or emits more than one item a * {@link NoSuchElementException} or {@code IllegalArgumentException} will be signaled respectively. *

* @@ -12270,8 +12294,8 @@ public final Observable skipWhile(@NonNull Predicate predicate) { *

* *

- * If any item emitted by this {@code Observable} does not implement {@link Comparable} with respect to - * all other items emitted by this {@code Observable}, no items will be emitted and the + * If any item emitted by the current {@code Observable} does not implement {@link Comparable} with respect to + * all other items emitted by the current {@code Observable}, no items will be emitted and the * sequence is terminated with a {@link ClassCastException}. * *

Note that calling {@code sorted} with long, non-terminating or infinite sources @@ -12426,7 +12450,7 @@ public final Observable startWithArray(@NonNull T... items) { * Subscribes to an {@code ObservableSource} and ignores {@code onNext} and {@code onComplete} emissions. *

* If the {@code Observable} emits an error, it is wrapped into an - * {@link io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException} + * {@link OnErrorNotImplementedException} * and routed to the RxJavaPlugins.onError handler. *

*
Scheduler:
@@ -12447,7 +12471,7 @@ public final Disposable subscribe() { * Subscribes to an {@code ObservableSource} and provides a callback to handle the items it emits. *

* If the {@code Observable} emits an error, it is wrapped into an - * {@link io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException OnErrorNotImplementedException} + * {@link OnErrorNotImplementedException} * and routed to the RxJavaPlugins.onError handler. *

*
Scheduler:
@@ -12571,8 +12595,8 @@ public final void subscribe(@NonNull Observer observer) { protected abstract void subscribeActual(@NonNull Observer observer); /** - * Subscribes a given {@code Observer} (subclass) to this {@code Observable} and returns the given - * {@code Observer} as is. + * Subscribes a given {@link Observer} (subclass) to the current {@code Observable} and returns the given + * {@code Observer} instance as is. *

Usage example: * 


      * Observable<Integer> source = Observable.range(1, 10);
@@ -12591,7 +12615,7 @@ public final void subscribe(@NonNull Observer observer) {
      * @param  the type of the {@code Observer} to use and return
      * @param observer the {@code Observer} (subclass) to use and return, not null
      * @return the input {@code observer}
-     * @throws NullPointerException if {@code observer} is null
+     * @throws NullPointerException if {@code observer} is {@code null}
      * @since 2.0
      */
     @CheckReturnValue
@@ -12603,7 +12627,7 @@ public final void subscribe(@NonNull Observer observer) {
     }
 
     /**
-     * Asynchronously subscribes {@code Observer}s to this {@code ObservableSource} on the specified {@link Scheduler}.
+     * Asynchronously subscribes {@code Observer}s to the current {@code Observable} on the specified {@link Scheduler}.
      * 

      * 
      * 

@@ -12736,12 +12760,12 @@ public final  Observable switchMap(@NonNull FunctionScheduler:
      *  
{@code switchMapCompletable} does not operate by default on a particular {@link Scheduler}.

      *  
Error handling:

-     *  
If either this {@code Observable} or the active {@code CompletableSource} signals an {@code onError},
+     *  
If either the current {@code Observable} or the active {@code CompletableSource} signals an {@code onError},
      *  the resulting {@code Completable} is terminated immediately with that {@code Throwable}.
      *  Use the {@link #switchMapCompletableDelayError(Function)} to delay such inner failures until
      *  every inner {@code CompletableSource}s and the main {@code Observable} terminates in some fashion.
      *  If they fail concurrently, the operator may combine the {@code Throwable}s into a
-     *  {@link io.reactivex.rxjava3.exceptions.CompositeException CompositeException}
+     *  {@link CompositeException}
      *  and signal it to the downstream instead. If any inactivated (switched out) {@code CompletableSource}
      *  signals an {@code onError} late, the {@code Throwable}s will be signaled to the global error handler via
      *  {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors.
@@ -12779,11 +12803,11 @@ public final Completable switchMapCompletable(@NonNull FunctionScheduler:
      *  
{@code switchMapCompletableDelayError} does not operate by default on a particular {@link Scheduler}.

      *  
Error handling:

-     *  
Errors of this {@code Observable} and all the {@code CompletableSource}s, who had the chance
+     *  
Errors of the current {@code Observable} and all the {@code CompletableSource}s, who had the chance
      *  to run to their completion, are delayed until
      *  all of them terminate in some fashion. At this point, if there was only one failure, the respective
      *  {@code Throwable} is emitted to the downstream. It there were more than one failures, the
-     *  operator combines all {@code Throwable}s into a {@link io.reactivex.rxjava3.exceptions.CompositeException CompositeException}
+     *  operator combines all {@code Throwable}s into a {@link CompositeException}
      *  and signals that to the downstream.
      *  If any inactivated (switched out) {@code CompletableSource}
      *  signals an {@code onError} late, the {@code Throwable}s will be signaled to the global error handler via
@@ -12809,7 +12833,7 @@ public final Completable switchMapCompletableDelayError(@NonNull Function
      * 
@@ -12817,14 +12841,14 @@ public final Completable switchMapCompletableDelayError(@NonNull FunctionScheduler:
      *  
{@code switchMapMaybe} does not operate by default on a particular {@link Scheduler}.

      *  
Error handling:

-     *  
This operator terminates with an {@code onError} if this {@code Observable} or any of
+     *  
This operator terminates with an {@code onError} if the current {@code Observable} or any of
      *  the inner {@code MaybeSource}s fail while they are active. When this happens concurrently, their
      *  individual {@code Throwable} errors may get combined and emitted as a single
-     *  {@link io.reactivex.rxjava3.exceptions.CompositeException CompositeException}. Otherwise, a late
-     *  (i.e., inactive or switched out) {@code onError} from this {@code Observable} or from any of
+     *  {@link CompositeException}. Otherwise, a late
+     *  (i.e., inactive or switched out) {@code onError} from the current {@code Observable} or from any of
      *  the inner {@code MaybeSource}s will be forwarded to the global error handler via
-     *  {@link io.reactivex.rxjava3.plugins.RxJavaPlugins#onError(Throwable)} as
-     *  {@link io.reactivex.rxjava3.exceptions.UndeliverableException UndeliverableException}

+     *  {@link RxJavaPlugins#onError(Throwable)} as
+     *  {@link UndeliverableException}
      * 

      * 
History: 2.1.11 - experimental
      * @param  the output value type
@@ -12846,7 +12870,7 @@ public final  Observable switchMapMaybe(@NonNull Function
      * 
      * 

@@ -13968,8 +13992,8 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit) {
     /**
      * Returns an {@code Observable} that mirrors the current {@code Observable} 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 current {@code Observable} is disposed and resulting {@code ObservableSource} begins instead
-     * to mirror a fallback ObservableSource.
+     * the current {@code Observable} is disposed and the resulting {@code Observable} begins instead
+     * to mirror a fallback {@link ObservableSource}.
      * 

      * 
      * 

@@ -13996,9 +14020,9 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No
 
     /**
      * Returns an {@code Observable} that mirrors the current {@code Observable} 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 current {@code Observable} is disposed and resulting {@code ObservableSource}
-     * begins instead to mirror a fallback ObservableSource.
+     * item using a specified {@link Scheduler}. If the next item isn't emitted within the specified timeout duration
+     * starting from its predecessor, the current {@code Observable} is disposed and returned {@code Observable}
+     * begins instead to mirror a fallback {@link ObservableSource}.
      * 

      * 
      * 

@@ -14277,7 +14301,7 @@ public final  R to(@NonNull ObservableConverter converter) {
      * 

      * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s
      * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the
-     * {@code ObservableSource} to compose a list of all of these items and then to invoke the Observer's {@code onNext}
+     * {@code ObservableSource} to compose a list of all of these items and then to invoke the {@code Observer}'s {@code onNext}
      * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to
      * calling its {@link #subscribe} method.
      * 

@@ -14308,7 +14332,7 @@ public final  R to(@NonNull ObservableConverter converter) {
      * 

      * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s
      * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the
-     * {@code ObservableSource} to compose a list of all of these items and then to invoke the Observer's {@code onNext}
+     * {@code ObservableSource} to compose a list of all of these items and then to invoke the {@code Observer}'s {@code onNext}
      * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to
      * calling its {@link #subscribe} method.
      * 

@@ -14342,7 +14366,7 @@ public final  R to(@NonNull ObservableConverter converter) {
      * 

      * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s
      * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the
-     * {@code ObservableSource} to compose a list of all of these items and then to invoke the Observer's {@code onNext}
+     * {@code ObservableSource} to compose a list of all of these items and then to invoke the {@code Observer}'s {@code onNext}
      * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to
      * calling its {@link #subscribe} method.
      * 

@@ -14683,9 +14707,10 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) {
      * sorted order. Each item emitted by the {@code ObservableSource} must implement {@link Comparable} with respect to all
      * other items in the sequence.
      *
-     * 
If any item emitted by this {@code Observable} does not implement {@link Comparable} with respect to
-     *             all other items emitted by this {@code Observable}, no items will be emitted and the
-     *             sequence is terminated with a {@link ClassCastException}.
+     * 

+     * If any item emitted by the current {@code Observable} does not implement {@link Comparable} with respect to
+     * all other items emitted by the current {@code Observable}, no items will be emitted and the
+     * sequence is terminated with a {@link ClassCastException}.
      * 

      * 
      * 

@@ -14772,10 +14797,10 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) {
      * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a
      * sorted order. Each item emitted by the {@code ObservableSource} must implement {@link Comparable} with respect to all
      * other items in the sequence.
-     *
-     * 
If any item emitted by this {@code Observable} does not implement {@link Comparable} with respect to
-     *             all other items emitted by this {@code Observable}, no items will be emitted and the
-     *             sequence is terminated with a {@link ClassCastException}.
+     * 

+     * If any item emitted by the current {@code Observable} does not implement {@link Comparable} with respect to
+     * all other items emitted by the current {@code Observable}, no items will be emitted and the
+     * sequence is terminated with a {@link ClassCastException}.
      * 

      * 
      * 

@@ -14802,8 +14827,8 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) {
     }
 
     /**
-     * Modifies the current {@code Observable} so that subscribers will dispose it on a specified
-     * {@link Scheduler}.
+     * Return an {@code Observable} that schedules the downstream {@link Observer}s' {@code dispose} calls
+     * aimed at the current {@code Observable} on the given {@link Scheduler}.
      * 

      * 
      * 

@@ -14812,9 +14837,8 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) {
      * 

      *
      * @param scheduler
-     *            the {@link Scheduler} to perform the call to dispose() of the upstream Disposable
-     * @return the current {@code Observable} modified so that its dispose() calls happen on the specified
-     *         {@link Scheduler}
+     *            the {@link Scheduler} to perform the call to {@code dispose()} of the upstream {@link Disposable}
+     * @return the new {@code Observable} instance
      * @see ReactiveX operators documentation: SubscribeOn
      */
     @CheckReturnValue
@@ -15395,8 +15419,8 @@ public final  Observable> window(@NonNull ObservableSource b
      * @param openingIndicator
      *            an {@code ObservableSource} that, when it emits an item, causes another window to be created
      * @param closingIndicator
-     *            a {@link Function} that produces an {@code ObservableSource} for every window created. When this {@code ObservableSource}
-     *            emits an item, the associated window is closed and emitted
+     *            a {@link Function} that produces an {@code ObservableSource} for every window created. When this indicator {@code ObservableSource}
+     *            emits an item, the associated window is completed
      * @return an {@code Observable} that emits windows of items emitted by the current {@code Observable} that are governed by
      *         the specified window-governing {@code ObservableSource}s
      * @see ReactiveX operators documentation: Window
@@ -15432,8 +15456,8 @@ public final  Observable> window(
      * @param openingIndicator
      *            an {@code ObservableSource} that, when it emits an item, causes another window to be created
      * @param closingIndicator
-     *            a {@link Function} that produces an {@code ObservableSource} for every window created. When this {@code ObservableSource}
-     *            emits an item, the associated window is closed and emitted
+     *            a {@link Function} that produces an {@code ObservableSource} for every window created. When this indicator {@code ObservableSource}
+     *            emits an item, the associated window is completed
      * @param bufferSize
      *            the capacity hint for the buffer in the inner windows
      * @return an {@code Observable} that emits windows of items emitted by the current {@code Observable} that are governed by
@@ -15453,8 +15477,8 @@ public final  Observable> window(
     }
 
     /**
-     * Merges the specified {@code ObservableSource} into this {@code ObservableSource} sequence by using the {@code resultSelector}
-     * function only when the current {@code Observable} (this instance) emits an item.
+     * Merges the specified {@code ObservableSource} into the current {@code Observable} sequence by using the {@code resultSelector}
+     * function only when the current {@code Observable} emits an item.
      * 

      * 
      *
@@ -15468,9 +15492,9 @@ public final  Observable> window(
      * @param other
      *            the other {@code ObservableSource}
      * @param combiner
-     *            the function to call when this {@code ObservableSource} emits an item and the other {@code ObservableSource} has already
+     *            the function to call when the current {@code Observable} emits an item and the other {@code ObservableSource} has already
      *            emitted an item, to generate the item to be emitted by the resulting {@code Observable}
-     * @return an {@code Observable} that merges the specified {@code ObservableSource} into this {@code ObservableSource} by using the
+     * @return an {@code Observable} that merges the specified {@code ObservableSource} into the current {@code Observable} by using the
      *         {@code resultSelector} function only when the current {@code Observable} sequence (this instance) emits an
      *         item
      * @since 2.0
@@ -15487,12 +15511,12 @@ public final  Observable withLatestFrom(@NonNull ObservableSourceNote that this operator doesn't emit anything until all other sources have produced at
-     * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and
-     * not when any of the other sources emit, unlike combineLatest).
+     * least one value. The resulting emission only happens when the current {@code Observable} emits (and
+     * not when any of the other sources emit, unlike {@code combineLatest}).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 

      * 
@@ -15507,7 +15531,7 @@ public final  Observable withLatestFrom(@NonNull ObservableSource Observable withLatestFrom(
     }
 
     /**
-     * Combines the value emission from this {@code ObservableSource} with the latest emissions from the
+     * Combines the value emission from the current {@code Observable} with the latest emissions from the
      * other {@code ObservableSource}s via a function to produce the output item.
      *
      * 
Note that this operator doesn't emit anything until all other sources have produced at
-     * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and
+     * least one value. The resulting emission only happens when the current {@code Observable} emits (and
      * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 

@@ -15546,7 +15570,7 @@ public final  Observable withLatestFrom(
      * @param source2 the second other {@code ObservableSource}
      * @param source3 the third other {@code ObservableSource}
      * @param combiner the function called with an array of values from each participating {@code ObservableSource}
-     * @return the new {@code ObservableSource} instance
+     * @return the new {@code Observable} instance
      * @since 2.0
      */
     @CheckReturnValue
@@ -15565,11 +15589,11 @@ public final  Observable withLatestFrom(
     }
 
     /**
-     * Combines the value emission from this {@code ObservableSource} with the latest emissions from the
+     * Combines the value emission from the current {@code Observable} with the latest emissions from the
      * other {@code ObservableSource}s via a function to produce the output item.
      *
      * 
Note that this operator doesn't emit anything until all other sources have produced at
-     * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and
+     * least one value. The resulting emission only happens when the current {@code Observable} emits (and
      * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 

@@ -15589,7 +15613,7 @@ public final  Observable withLatestFrom(
      * @param source3 the third other {@code ObservableSource}
      * @param source4 the fourth other {@code ObservableSource}
      * @param combiner the function called with an array of values from each participating {@code ObservableSource}
-     * @return the new {@code ObservableSource} instance
+     * @return the new {@code Observable} instance
      * @since 2.0
      */
     @CheckReturnValue
@@ -15609,11 +15633,11 @@ public final  Observable withLatestFrom(
     }
 
     /**
-     * Combines the value emission from this {@code ObservableSource} with the latest emissions from the
+     * Combines the value emission from the current {@code Observable} with the latest emissions from the
      * other {@code ObservableSource}s via a function to produce the output item.
      *
      * 
Note that this operator doesn't emit anything until all other sources have produced at
-     * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and
+     * least one value. The resulting emission only happens when the current {@code Observable} emits (and
      * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 

@@ -15626,7 +15650,7 @@ public final  Observable withLatestFrom(
      * @param  the result value type
      * @param others the array of other sources
      * @param combiner the function called with an array of values from each participating {@code ObservableSource}
-     * @return the new {@code ObservableSource} instance
+     * @return the new {@code Observable} instance
      * @since 2.0
      */
     @CheckReturnValue
@@ -15639,11 +15663,11 @@ public final  Observable withLatestFrom(@NonNull ObservableSource[] oth
     }
 
     /**
-     * Combines the value emission from this {@code ObservableSource} with the latest emissions from the
+     * Combines the value emission from the current {@code Observable} with the latest emissions from the
      * other {@code ObservableSource}s via a function to produce the output item.
      *
      * 
Note that this operator doesn't emit anything until all other sources have produced at
-     * least one value. The resulting emission only happens when this {@code ObservableSource} emits (and
+     * least one value. The resulting emission only happens when the current {@code Observable} emits (and
      * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 

@@ -15656,7 +15680,7 @@ public final  Observable withLatestFrom(@NonNull ObservableSource[] oth
      * @param  the result value type
      * @param others the iterable of other sources
      * @param combiner the function called with an array of values from each participating {@code ObservableSource}
-     * @return the new {@code ObservableSource} instance
+     * @return the new {@code Observable} instance
      * @since 2.0
      */
     @CheckReturnValue
@@ -15845,8 +15869,7 @@ public final  Observable zipWith(@NonNull ObservableSource
     // Fluent test support, super handy and reduces test preparation boilerplate
     // -------------------------------------------------------------------------
     /**
-     * Creates a TestObserver and subscribes
-     * it to this {@code Observable}.
+     * Creates a {@link TestObserver} and subscribes it to the current {@code Observable}.
      * 

      *  
Scheduler:

      *  
{@code test} does not operate by default on a particular {@link Scheduler}.

@@ -15864,14 +15887,15 @@ public final TestObserver test() { // NoPMD
     }
 
     /**
-     * Creates a TestObserver, optionally disposes it and then subscribes
-     * it to this {@code Observable}.
+     * Creates a {@link TestObserver}, optionally disposes it and then subscribes
+     * it to the current {@code Observable}.
      *
      * 

      *  
Scheduler:

      *  
{@code test} does not operate by default on a particular {@link Scheduler}.

      * 

-     * @param dispose dispose the TestObserver before it is subscribed to this Observable?
+     * @param dispose indicates if the {@code TestObserver} should be disposed before
+     *                it is subscribed to the current {@code Observable}
      * @return the new TestObserver instance
      * @since 2.0
      */
@@ -16229,7 +16253,7 @@ public final CompletionStage lastOrErrorStage() {
     }
 
     /**
-     * Creates a sequential {@link Stream} to consume or process this {@code Observable} in a blocking manner via
+     * Creates a sequential {@link Stream} to consume or process the current {@code Observable} in a blocking manner via
      * the Java {@code Stream} API.
      * 

      * 
@@ -16261,7 +16285,7 @@ public final Stream blockingStream() {
     }
 
     /**
-     * Creates a sequential {@link Stream} to consume or process this {@code Observable} in a blocking manner via
+     * Creates a sequential {@link Stream} to consume or process the current {@code Observable} in a blocking manner via
      * the Java {@code Stream} API.
      * 

      * 
diff --git a/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java b/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java
index 51db4406d6..2b43746f15 100644
--- a/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java
+++ b/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java
@@ -224,7 +224,8 @@ static void processFile(Class clazz) throws Exception {
                     if (!baseClassName.equals("Completable")
                             && !baseClassName.equals("Single")
                             && !baseClassName.equals("Maybe")
-                            && !baseClassName.equals("Observable")) {
+                            && !baseClassName.equals("Observable")
+                    ) {
                         continue;
                     }
 

From 408a507aabdca9095af17981777edbf037ca9670 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Thu, 9 Jan 2020 16:38:27 +0100
Subject: [PATCH 3/3] 3.x: Improve JavaDocs of Observable and fix similar
 issues elsewhere

---
 .../reactivex/rxjava3/core/Completable.java   |    3 +-
 .../io/reactivex/rxjava3/core/Flowable.java   |  126 +-
 .../java/io/reactivex/rxjava3/core/Maybe.java |    9 +-
 .../io/reactivex/rxjava3/core/Observable.java | 1706 +++++++++++------
 .../io/reactivex/rxjava3/core/Single.java     |    2 +
 .../flowable/FlowableBlockingSubscribe.java   |   12 +-
 .../ObservableBlockingSubscribe.java          |    1 +
 .../rxjava3/parallel/ParallelFlowable.java    |   33 +-
 .../flowable/FlowableSkipLastTest.java        |    2 +-
 .../flowable/FlowableTakeLastTest.java        |    2 +-
 .../flowable/FlowableTakeLastTimedTest.java   |    2 +-
 .../ObservableConcatMapEagerTest.java         |    4 +-
 .../observable/ObservableSkipLastTest.java    |    2 +-
 .../observable/ObservableTakeLastTest.java    |    2 +-
 .../ObservableTakeLastTimedTest.java          |    2 +-
 .../ParamValidationCheckerTest.java           |    6 +
 .../validators/ParamValidationNaming.java     |   70 +-
 17 files changed, 1274 insertions(+), 710 deletions(-)

diff --git a/src/main/java/io/reactivex/rxjava3/core/Completable.java b/src/main/java/io/reactivex/rxjava3/core/Completable.java
index 1f24e413f5..a51bb7399f 100644
--- a/src/main/java/io/reactivex/rxjava3/core/Completable.java
+++ b/src/main/java/io/reactivex/rxjava3/core/Completable.java
@@ -336,6 +336,7 @@ public static Completable create(@NonNull CompletableOnSubscribe source) {
      * when the {@code Completable} is subscribed to.
      * @return the created {@code Completable} instance
      * @throws NullPointerException if {@code source} is {@code null}
+     * @throws IllegalArgumentException if {@code source} is a {@code Completable}
      */
     @CheckReturnValue
     @NonNull
@@ -364,7 +365,7 @@ public static Completable unsafeCreate(@NonNull CompletableSource source) {
     @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
     public static Completable defer(@NonNull Supplier completableSupplier) {
-        Objects.requireNonNull(completableSupplier, "completableSupplier");
+        Objects.requireNonNull(completableSupplier, "completableSupplier is null");
         return RxJavaPlugins.onAssembly(new CompletableDefer(completableSupplier));
     }
 
diff --git a/src/main/java/io/reactivex/rxjava3/core/Flowable.java b/src/main/java/io/reactivex/rxjava3/core/Flowable.java
index 66d0b26a8d..f11415e0de 100644
--- a/src/main/java/io/reactivex/rxjava3/core/Flowable.java
+++ b/src/main/java/io/reactivex/rxjava3/core/Flowable.java
@@ -1352,7 +1352,7 @@ public static  Flowable concat(
      * @param sources the array of source {@code Publisher}s
      * @param  the common base value type
      * @return the new {@code Publisher} instance
-     * @throws NullPointerException if sources is {@code null}
+     * @throws NullPointerException if {@code sources} is {@code null}
      */
     @CheckReturnValue
     @BackpressureSupport(BackpressureKind.FULL)
@@ -1360,6 +1360,7 @@ public static  Flowable concat(
     @SafeVarargs
     @NonNull
     public static  Flowable concatArray(@NonNull Publisher... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return empty();
         } else
@@ -1386,7 +1387,7 @@ public static  Flowable concatArray(@NonNull Publisher... sou
      * @param sources the array of source {@code Publisher}s
      * @param  the common base value type
      * @return the new {@code Flowable} instance
-     * @throws NullPointerException if sources is {@code null}
+     * @throws NullPointerException if {@code sources} is {@code null}
      */
     @CheckReturnValue
     @BackpressureSupport(BackpressureKind.FULL)
@@ -1394,6 +1395,7 @@ public static  Flowable concatArray(@NonNull Publisher... sou
     @SafeVarargs
     @NonNull
     public static  Flowable concatArrayDelayError(@NonNull Publisher... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return empty();
         } else
@@ -1981,7 +1983,7 @@ public static  Flowable error(@NonNull Throwable throwable) {
      *   
      * 

      *
-     * @param supplier
+     * @param callable
      *         a function, the execution of which should be deferred; {@code fromCallable} will invoke this
      *         function only when a {@code Subscriber} subscribes to the {@code Publisher} that {@code fromCallable} returns
      * @param 
@@ -1995,9 +1997,9 @@ public static  Flowable error(@NonNull Throwable throwable) {
     @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
-    public static <@NonNull T> Flowable fromCallable(@NonNull Callable supplier) {
-        Objects.requireNonNull(supplier, "supplier is null");
-        return RxJavaPlugins.onAssembly(new FlowableFromCallable<>(supplier));
+    public static <@NonNull T> Flowable fromCallable(@NonNull Callable callable) {
+        Objects.requireNonNull(callable, "callable is null");
+        return RxJavaPlugins.onAssembly(new FlowableFromCallable<>(callable));
     }
 
     /**
@@ -2020,7 +2022,7 @@ public static  Flowable error(@NonNull Throwable throwable) {
      *  
Backpressure:

      *  
The operator honors backpressure from downstream.

      *  
Scheduler:

-     *  
{@code fromFuture} does not operate by default on a particular {@link Scheduler}.

+     *  
{@code fromFuture} does not operate by default on a particular {@code Scheduler}.

      * 

      *
      * @param future
@@ -2061,7 +2063,7 @@ public static  Flowable error(@NonNull Throwable throwable) {
      *  
Backpressure:

      *  
The operator honors backpressure from downstream.

      *  
Scheduler:

-     *  
{@code fromFuture} does not operate by default on a particular {@link Scheduler}.

+     *  
{@code fromFuture} does not operate by default on a particular {@code Scheduler}.

      * 

      *
      * @param future
@@ -2538,6 +2540,9 @@ public static Flowable intervalRange(long start, long count, long initialD
      * @param unit the unit of measure of the {@code initialDelay} and {@code period} amounts
      * @param scheduler the target {@code Scheduler} where the values and terminal signals will be emitted
      * @return the new {@code Flowable} instance
+     * @throws IllegalArgumentException
+     *             if {@code count} is less than zero, or if {@code start} + {@code count} − 1 exceeds
+     *             {@link Long#MAX_VALUE}
      */
     @CheckReturnValue
     @NonNull
@@ -4435,7 +4440,7 @@ public static  Flowable using(
     }
 
     /**
-     * Constructs an {@code Flowable} that creates a dependent resource object, an {@link Publisher} with
+     * Constructs a {@code Flowable} that creates a dependent resource object, a {@link Publisher} with
      * that resource and calls the provided {@code resourceDisposer} function if this inner source terminates or the
      * downstream disposes the flow; doing it before these end-states have been reached if {@code eager == true}, after otherwise.
      * 

@@ -5381,6 +5386,8 @@ public static  Flowable zip(
      * @param bufferSize
      *            the number of elements to prefetch from each source {@code Publisher}
      * @return a {@code Flowable} that emits the zipped results
+     * @throws NullPointerException if {@code sources} or {@code zipper} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -5390,6 +5397,7 @@ public static  Flowable zip(
     @SafeVarargs
     public static  Flowable zipArray(@NonNull Function zipper,
             boolean delayError, int bufferSize, @NonNull Publisher... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return empty();
         }
@@ -5626,6 +5634,8 @@ public final void blockingForEach(@NonNull Consumer onNext) {
      *            the {@code Consumer} to invoke for each item emitted by the {@code Flowable}
      * @param bufferSize
      *            the number of items to prefetch upfront, then 75% of it after 75% received
+     * @throws NullPointerException if {@code onNext} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @throws RuntimeException
      *             if an error occurs; {@code Error}s and {@code RuntimeException}s are rethrown
      *             as they are, checked {@code Exception}s are wrapped into {@code RuntimeException}s
@@ -5635,6 +5645,7 @@ public final void blockingForEach(@NonNull Consumer onNext) {
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     public final void blockingForEach(@NonNull Consumer onNext, int bufferSize) {
+        Objects.requireNonNull(onNext, "onNext is null");
         Iterator it = blockingIterable(bufferSize).iterator();
         while (it.hasNext()) {
             try {
@@ -6141,11 +6152,13 @@ public final void blockingSubscribe(@NonNull Consumer onNext, @NonNul
      * 

      * The cancellation and backpressure is composed through.
      * @param subscriber the subscriber to forward events and calls to in the current thread
+     * @throws NullPointerException if {@code subscriber} is {@code null}
      * @since 2.0
      */
     @BackpressureSupport(BackpressureKind.SPECIAL)
     @SchedulerSupport(SchedulerSupport.NONE)
     public final void blockingSubscribe(@NonNull Subscriber subscriber) {
+        Objects.requireNonNull(subscriber, "subscriber is null");
         FlowableBlockingSubscribe.subscribe(this, subscriber);
     }
 
@@ -7203,7 +7216,7 @@ public final  Flowable concatMap(@NonNull Function Flowable concatMap(@NonNull Function> mapper, int prefetch, @NonNull Scheduler scheduler) {
         Objects.requireNonNull(mapper, "mapper is null");
         ObjectHelper.verifyPositive(prefetch, "prefetch");
-        Objects.requireNonNull(scheduler, "scheduler");
+        Objects.requireNonNull(scheduler, "scheduler is null");
         return RxJavaPlugins.onAssembly(new FlowableConcatMapScheduler<>(this, mapper, prefetch, ErrorMode.IMMEDIATE, scheduler));
     }
 
@@ -9414,6 +9427,7 @@ public final Flowable doOnTerminate(@NonNull Action onTerminate) {
      *            the zero-based index of the item to retrieve
      * @return a {@code Maybe} that emits a single item: the item at the specified position in the sequence of
      *         those emitted by the source {@code Publisher}
+     * @throws IndexOutOfBoundsException if {@code index} is negative
      * @see ReactiveX operators documentation: ElementAt
      */
     @CheckReturnValue
@@ -9446,7 +9460,7 @@ public final Maybe elementAt(long index) {
      * @return a {@code Single} that emits the item at the specified position in the sequence emitted by the source
      *         {@code Publisher}, or the default item if that index is outside the bounds of the source sequence
      * @throws IndexOutOfBoundsException
-     *             if {@code index} is less than 0
+     *             if {@code index} is negative
      * @see ReactiveX operators documentation: ElementAt
      */
     @CheckReturnValue
@@ -10150,8 +10164,8 @@ public final Completable flatMapCompletable(@NonNull Function
      * 

      *  
Backpressure:

-     *  
The operator honors backpressure from downstream. The source {@code Publisher}s is
-     *  expected to honor backpressure as well. If the source {@code Publisher} violates the rule, the operator will
+     *  
The operator honors backpressure from downstream. The current {@code Flowable}s is
+     *  expected to honor backpressure as well. If the current {@code Flowable} violates the rule, the operator will
      *  signal a {@link MissingBackpressureException}.

      *  
Scheduler:

      *  
{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.

@@ -10161,7 +10175,7 @@ public final Completable flatMapCompletable(@NonNull FunctionReactiveX operators documentation: FlatMap
      */
@@ -10180,8 +10194,8 @@ public final  Flowable flatMapIterable(@NonNull Function
      * 

      *  
Backpressure:

-     *  
The operator honors backpressure from downstream. The source {@code Publisher}s is
-     *  expected to honor backpressure as well. If the source {@code Publisher} violates the rule, the operator will
+     *  
The operator honors backpressure from downstream. The current {@code Flowable}s is
+     *  expected to honor backpressure as well. If the current {@code Flowable} violates the rule, the operator will
      *  signal a {@link MissingBackpressureException}.

      *  
Scheduler:

      *  
{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.

@@ -10191,7 +10205,7 @@ public final  Flowable flatMapIterable(@NonNull Function Flowable flatMapIterable(@NonNull Function
      * 

      *  
Backpressure:

-     *  
The operator honors backpressure from downstream and the source {@code Publisher}s is
-     *  consumed in an unbounded manner (i.e., no backpressure is applied to it).

+     *  
The operator honors backpressure from downstream and the current {@code Flowable}s is
+     *  consumed in a bounded manner (requesting {@link #bufferSize()} items upfront, then 75% of it after 75% received).

      *  
Scheduler:

      *  
{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.

      * 

@@ -10227,13 +10241,13 @@ public final  Flowable flatMapIterable(@NonNull Function
      *            the output type as determined by the {@code resultSelector} function
      * @param mapper
-     *            a function that returns an {@code Iterable} sequence of values for each item emitted by the source
-     *            {@code Publisher}
+     *            a function that returns an {@code Iterable} sequence of values for each item emitted by the current
+     *            {@code Flowable}
      * @param resultSelector
-     *            a function that returns an item based on the item emitted by the source {@code Publisher} and the
+     *            a function that returns an item based on the item emitted by the current {@code Flowable} and the
      *            {@code Iterable} returned for that item by the {@code collectionSelector}
-     * @return a {@code Flowable} that emits the items returned by {@code resultSelector} for each item in the source
-     *         {@code Publisher}
+     * @return a {@code Flowable} that emits the items returned by {@code resultSelector} for each item in the current
+     *         {@code Flowable}
      * @see ReactiveX operators documentation: FlatMap
      */
     @CheckReturnValue
@@ -10256,8 +10270,8 @@ public final  Flowable flatMapIterable(@NonNull Function
      * 

      *  
Backpressure:

-     *  
The operator honors backpressure from downstream. The source {@code Publisher}s is
-     *  expected to honor backpressure as well. If the source {@code Publisher} violates the rule, the operator will
+     *  
The operator honors backpressure from downstream. The current {@code Flowable}s is
+     *  expected to honor backpressure as well. If the current {@code Flowable} violates the rule, the operator will
      *  signal a {@link MissingBackpressureException}.

      *  
Scheduler:

      *  
{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.

@@ -10266,12 +10280,12 @@ public final  Flowable flatMapIterable(@NonNull Function
      *            the element type of the inner {@code Iterable} sequences
      * @param 
-     *            the type of item emitted by the resulting {@code Publisher}
+     *            the type of item emitted by the resulting {@code Flowable}
      * @param mapper
      *            a function that returns an {@code Iterable} sequence of values for when given an item emitted by the
-     *            source {@code Publisher}
+     *            current {@code Flowable}
      * @param resultSelector
-     *            a function that returns an item based on the item emitted by the source {@code Publisher} and the
+     *            a function that returns an item based on the item emitted by the current {@code Flowable} and the
      *            {@code Iterable} returned for that item by the {@code collectionSelector}
      * @param prefetch
      *            the number of elements to prefetch from the current {@code Flowable}
@@ -11187,7 +11201,7 @@ public final Maybe lastElement() {
     @BackpressureSupport(BackpressureKind.UNBOUNDED_IN)
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Single last(@NonNull T defaultItem) {
-        Objects.requireNonNull(defaultItem, "defaultItem");
+        Objects.requireNonNull(defaultItem, "defaultItem is null");
         return RxJavaPlugins.onAssembly(new FlowableLastSingle<>(this, defaultItem));
     }
 
@@ -13639,6 +13653,7 @@ public final Flowable retry(long count) {
      * 

      * @param times the number of times to resubscribe if the current {@code Flowable} fails
      * @param predicate the predicate called with the failure {@link Throwable} and should return {@code true} to trigger a retry.
+     * @throws IllegalArgumentException if {@code times} is negative
      * @return the new {@code Flowable} instance
      */
     @CheckReturnValue
@@ -14399,7 +14414,7 @@ public final Flowable skip(long time, @NonNull TimeUnit unit, @NonNull Schedu
      *            number of items to drop from the end of the source sequence
      * @return a {@code Flowable} that emits the items emitted by the source {@code Publisher} except for the dropped ones
      *         at the end
-     * @throws IndexOutOfBoundsException
+     * @throws IllegalArgumentException
      *             if {@code count} is less than zero
      * @see ReactiveX operators documentation: SkipLast
      */
@@ -14409,7 +14424,7 @@ public final Flowable skip(long time, @NonNull TimeUnit unit, @NonNull Schedu
     @NonNull
     public final Flowable skipLast(int count) {
         if (count < 0) {
-            throw new IndexOutOfBoundsException("count >= 0 required but it was " + count);
+            throw new IllegalArgumentException("count >= 0 required but it was " + count);
         }
         if (count == 0) {
             return RxJavaPlugins.onAssembly(this);
@@ -14707,7 +14722,7 @@ public final Flowable sorted() {
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Flowable sorted(@NonNull Comparator<@NonNull ? super T> sortFunction) {
-        Objects.requireNonNull(sortFunction, "sortFunction");
+        Objects.requireNonNull(sortFunction, "sortFunction is null");
         return toList().toFlowable().map(Functions.listSorter(sortFunction)).flatMapIterable(Functions.identity());
     }
 
@@ -15627,6 +15642,7 @@ public final  Flowable switchMapSingleDelayError(@NonNull FunctionReactiveX operators documentation: Take
      */
     @CheckReturnValue
@@ -15722,8 +15738,8 @@ public final Flowable take(long time, @NonNull TimeUnit unit, @NonNull Schedu
      *            the maximum number of items to emit from the end of the sequence of items emitted by the source
      *            {@code Publisher}
      * @return a {@code Flowable} that emits at most the last {@code count} items emitted by the source {@code Publisher}
-     * @throws IndexOutOfBoundsException
-     *             if {@code count} is less than zero
+     * @throws IllegalArgumentException
+     *             if {@code count} is negative
      * @see ReactiveX operators documentation: TakeLast
      */
     @CheckReturnValue
@@ -15732,7 +15748,7 @@ public final Flowable take(long time, @NonNull TimeUnit unit, @NonNull Schedu
     @NonNull
     public final Flowable takeLast(int count) {
         if (count < 0) {
-            throw new IndexOutOfBoundsException("count >= 0 required but it was " + count);
+            throw new IllegalArgumentException("count >= 0 required but it was " + count);
         } else
         if (count == 0) {
             return RxJavaPlugins.onAssembly(new FlowableIgnoreElements<>(this));
@@ -15800,7 +15816,7 @@ public final Flowable takeLast(long count, long time, @NonNull TimeUnit unit)
      * @return a {@code Flowable} that emits at most {@code count} items from the source {@code Publisher} that were emitted
      *         in a specified window of time before the {@code Publisher} completed, where the timing information is
      *         provided by the given {@code scheduler}
-     * @throws IndexOutOfBoundsException
+     * @throws IllegalArgumentException
      *             if {@code count} is less than zero
      * @see ReactiveX operators documentation: TakeLast
      */
@@ -15842,8 +15858,8 @@ public final Flowable takeLast(long count, long time, @NonNull TimeUnit unit,
      * @return a {@code Flowable} that emits at most {@code count} items from the source {@code Publisher} that were emitted
      *         in a specified window of time before the {@code Publisher} completed, where the timing information is
      *         provided by the given {@code scheduler}
-     * @throws IndexOutOfBoundsException
-     *             if {@code count} is less than zero
+     * @throws IllegalArgumentException
+     *             if {@code count} is negative
      * @see ReactiveX operators documentation: TakeLast
      */
     @CheckReturnValue
@@ -15855,7 +15871,7 @@ public final Flowable takeLast(long count, long time, @NonNull TimeUnit unit,
         Objects.requireNonNull(scheduler, "scheduler is null");
         ObjectHelper.verifyPositive(bufferSize, "bufferSize");
         if (count < 0) {
-            throw new IndexOutOfBoundsException("count >= 0 required but it was " + count);
+            throw new IllegalArgumentException("count >= 0 required but it was " + count);
         }
         return RxJavaPlugins.onAssembly(new FlowableTakeLastTimed<>(this, count, time, unit, scheduler, bufferSize, delayError));
     }
@@ -16699,7 +16715,7 @@ public final  Flowable timeout(@NonNull Function Flowable timeout(@NonNull Function timeout(long timeout, @NonNull TimeUnit timeUnit) {
-        return timeout0(timeout, timeUnit, null, Schedulers.computation());
+    public final Flowable timeout(long timeout, @NonNull TimeUnit unit) {
+        return timeout0(timeout, unit, null, Schedulers.computation());
     }
 
     /**
@@ -16731,7 +16747,7 @@ public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit) {
      *
      * @param timeout
      *            maximum duration between items before a timeout occurs
-     * @param timeUnit
+     * @param unit
      *            the unit of time that applies to the {@code timeout} argument
      * @param other
      *            the fallback {@code Publisher} to use in case of a timeout
@@ -16742,9 +16758,9 @@ public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit) {
     @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.COMPUTATION)
-    public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonNull Publisher other) {
+    public final Flowable timeout(long timeout, @NonNull TimeUnit unit, @NonNull Publisher other) {
         Objects.requireNonNull(other, "other is null");
-        return timeout0(timeout, timeUnit, other, Schedulers.computation());
+        return timeout0(timeout, unit, other, Schedulers.computation());
     }
 
     /**
@@ -16766,7 +16782,7 @@ public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonN
      *
      * @param timeout
      *            maximum duration between items before a timeout occurs
-     * @param timeUnit
+     * @param unit
      *            the unit of time that applies to the {@code timeout} argument
      * @param scheduler
      *            the {@code Scheduler} to run the timeout timers on
@@ -16780,9 +16796,9 @@ public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonN
     @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.CUSTOM)
-    public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonNull Scheduler scheduler, @NonNull Publisher other) {
+    public final Flowable timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Publisher other) {
         Objects.requireNonNull(other, "other is null");
-        return timeout0(timeout, timeUnit, other, scheduler);
+        return timeout0(timeout, unit, other, scheduler);
     }
 
     /**
@@ -16802,7 +16818,7 @@ public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonN
      *
      * @param timeout
      *            maximum duration between items before a timeout occurs
-     * @param timeUnit
+     * @param unit
      *            the unit of time that applies to the {@code timeout} argument
      * @param scheduler
      *            the {@code Scheduler} to run the timeout timers on
@@ -16814,8 +16830,8 @@ public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonN
     @BackpressureSupport(BackpressureKind.PASS_THROUGH)
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     @NonNull
-    public final Flowable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonNull Scheduler scheduler) {
-        return timeout0(timeout, timeUnit, null, scheduler);
+    public final Flowable timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) {
+        return timeout0(timeout, unit, null, scheduler);
     }
 
     /**
@@ -16908,11 +16924,11 @@ public final  Flowable timeout(
         return timeout0(firstTimeoutIndicator, itemTimeoutIndicator, other);
     }
 
-    private Flowable timeout0(long timeout, TimeUnit timeUnit, Publisher other,
+    private Flowable timeout0(long timeout, TimeUnit unit, Publisher other,
             Scheduler scheduler) {
-        Objects.requireNonNull(timeUnit, "timeUnit is null");
+        Objects.requireNonNull(unit, "unit is null");
         Objects.requireNonNull(scheduler, "scheduler is null");
-        return RxJavaPlugins.onAssembly(new FlowableTimeoutTimed<>(this, timeout, timeUnit, scheduler, other));
+        return RxJavaPlugins.onAssembly(new FlowableTimeoutTimed<>(this, timeout, unit, scheduler, other));
     }
 
     private  Flowable timeout0(
diff --git a/src/main/java/io/reactivex/rxjava3/core/Maybe.java b/src/main/java/io/reactivex/rxjava3/core/Maybe.java
index e8e01a15c7..441267389c 100644
--- a/src/main/java/io/reactivex/rxjava3/core/Maybe.java
+++ b/src/main/java/io/reactivex/rxjava3/core/Maybe.java
@@ -147,12 +147,14 @@ public static  Maybe amb(@NonNull Iterable Maybe ambArray(@NonNull MaybeSource... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return empty();
         }
@@ -402,6 +404,7 @@ public static  Flowable concatArray(@NonNull MaybeSource... s
     @SafeVarargs
     @NonNull
     public static  Flowable concatArrayDelayError(@NonNull MaybeSource... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return Flowable.empty();
         } else
@@ -1364,6 +1367,7 @@ public static  Flowable mergeArray(MaybeSource... sources) {
     @SafeVarargs
     @NonNull
     public static  Flowable mergeArrayDelayError(@NonNull MaybeSource... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return Flowable.empty();
         }
@@ -1764,6 +1768,8 @@ public static Maybe timer(long delay, @NonNull TimeUnit unit, @NonNull Sch
      * @param  the value type
      * @param onSubscribe the function that is called with the subscribing {@code MaybeObserver}
      * @return the new {@code Maybe} instance
+     * @throws IllegalArgumentException if {@code onSubscribe} is a {@code Maybe}
+     * @throws NullPointerException if {@code onSubscribe} is {@code null}
      */
     @CheckReturnValue
     @NonNull
@@ -1858,6 +1864,7 @@ public static  Maybe using(@NonNull Supplier resourceSuppl
      * @param  the value type
      * @param source the source to wrap
      * @return the {@code Maybe} wrapper or the source cast to {@code Maybe} (if possible)
+     * @throws NullPointerException if {@code source} is {@code null}
      */
     @CheckReturnValue
     @NonNull
@@ -3522,7 +3529,7 @@ public final Single isEmpty() {
      *         if (str.length() < 2) {
      *             downstream.onSuccess(str);
      *         } else {
-     *             // Maybe i {@code Maybe} ly expected to produce one of the onXXX events
+     *             // Maybe is expected to produce one of the onXXX events only
      *             downstream.onComplete();
      *         }
      *     }
diff --git a/src/main/java/io/reactivex/rxjava3/core/Observable.java b/src/main/java/io/reactivex/rxjava3/core/Observable.java
index ba46947bbe..2d75dee207 100644
--- a/src/main/java/io/reactivex/rxjava3/core/Observable.java
+++ b/src/main/java/io/reactivex/rxjava3/core/Observable.java
@@ -115,6 +115,7 @@ public abstract class Observable implements ObservableSource {
      *            occur in the same order as in the {@code Iterable}.
      * @return an {@code Observable} that emits the same sequence as whichever of the returned {@code ObservableSource}s first
      *         emitted an item or sent a termination notification
+     * @throws NullPointerException if {@code sources} is {@code null}
      * @see ReactiveX operators documentation: Amb
      */
     @CheckReturnValue
@@ -141,6 +142,7 @@ public static  Observable amb(@NonNull IterableReactiveX operators documentation: Amb
      */
     @SuppressWarnings("unchecked")
@@ -248,9 +250,11 @@ public static  Observable combineLatest(
      * @param combiner
      *            the aggregation function used to combine the items emitted by the returned {@code ObservableSource}s
      * @param bufferSize
-     *            the internal buffer size and prefetch amount applied to every {@code ObservableSource}
+     *            the expected number of row combination items to be buffered internally
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the returned
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code sources} or {@code combiner} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: CombineLatest
      */
     @CheckReturnValue
@@ -344,9 +348,11 @@ public static  Observable combineLatestArray(
      * @param combiner
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @param bufferSize
-     *            the internal buffer size and prefetch amount applied to every {@code ObservableSource}
+     *            the expected number of row combination items to be buffered internally
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code sources} or {@code combiner} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: CombineLatest
      */
     @CheckReturnValue
@@ -393,6 +399,7 @@ public static  Observable combineLatestArray(
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code source1}, {@code source2} or {@code combiner} is {@code null}
      * @see ReactiveX operators documentation: CombineLatest
      */
     @SuppressWarnings("unchecked")
@@ -437,6 +444,7 @@ public static  Observable combineLatest(
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3} or {@code combiner} is {@code null}
      * @see ReactiveX operators documentation: CombineLatest
      */
     @SuppressWarnings("unchecked")
@@ -486,6 +494,8 @@ public static  Observable combineLatest(
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4} or {@code combiner} is {@code null}
      * @see ReactiveX operators documentation: CombineLatest
      */
     @SuppressWarnings("unchecked")
@@ -539,6 +549,8 @@ public static  Observable combineLatest(
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5} or {@code combiner} is {@code null}
      * @see ReactiveX operators documentation: CombineLatest
      */
     @SuppressWarnings("unchecked")
@@ -597,6 +609,8 @@ public static  Observable combineLatest(
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5}, {@code source6} or {@code combiner} is {@code null}
      * @see ReactiveX operators documentation: CombineLatest
      */
     @SuppressWarnings("unchecked")
@@ -659,6 +673,9 @@ public static  Observable combineLatest(
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5}, {@code source6},
+     *                              {@code source7} or {@code combiner} is {@code null}
      * @see ReactiveX operators documentation: CombineLatest
      */
     @SuppressWarnings("unchecked")
@@ -726,6 +743,9 @@ public static  Observable combineLatest(
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5}, {@code source6},
+     *                              {@code source7}, {@code source8} or {@code combiner} is {@code null}
      * @see ReactiveX operators documentation: CombineLatest
      */
     @SuppressWarnings("unchecked")
@@ -797,6 +817,9 @@ public static  Observable combineLatest(
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5}, {@code source6},
+     *                              {@code source7}, {@code source8}, {@code source9} or {@code combiner} is {@code null}
      * @see ReactiveX operators documentation: CombineLatest
      */
     @SuppressWarnings("unchecked")
@@ -900,9 +923,11 @@ public static  Observable combineLatestDelayError(
      * @param combiner
      *            the aggregation function used to combine the items emitted by the {@code ObservableSource}s
      * @param bufferSize
-     *            the internal buffer size and prefetch amount applied to every source {@code ObservableSource}
+     *            the expected number of row combination items to be buffered internally
      * @return an {@code Observable} that emits items that are the result of combining the items emitted by the
      *         {@code ObservableSource}s by means of the given aggregation function
+     * @throws NullPointerException if {@code sources} or {@code combiner} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: CombineLatest
      */
     @CheckReturnValue
@@ -910,8 +935,9 @@ public static  Observable combineLatestDelayError(
     @SchedulerSupport(SchedulerSupport.NONE)
     public static  Observable combineLatestDelayError(@NonNull ObservableSource[] sources,
             @NonNull Function combiner, int bufferSize) {
-        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        Objects.requireNonNull(sources, "sources is null");
         Objects.requireNonNull(combiner, "combiner is null");
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
         if (sources.length == 0) {
             return empty();
         }
@@ -997,9 +1023,11 @@ public static  Observable combineLatestDelayError(@NonNull IterableReactiveX operators documentation: CombineLatest
      */
     @CheckReturnValue
@@ -1028,6 +1056,7 @@ public static  Observable combineLatestDelayError(@NonNull Iterable the common value type of the sources
      * @param sources the {@code Iterable} sequence of {@code ObservableSource}s
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code sources} is {@code null}
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @CheckReturnValue
@@ -1053,6 +1082,7 @@ public static  Observable concat(@NonNull IterableReactiveX operators documentation: Concat
      */
     @CheckReturnValue
@@ -1075,20 +1105,22 @@ public static  Observable concat(@NonNull ObservableSource the common element base type
      * @param sources
      *            an {@code ObservableSource} that emits {@code ObservableSource}s
-     * @param prefetch
-     *            the number of {@code ObservableSource}s to prefetch from the sources sequence.
+     * @param bufferSize
+     *            the number of inner {@code ObservableSource}s expected to be buffered.
      * @return an {@code Observable} that emits items all of the items emitted by the {@code ObservableSource}s emitted by
      *         {@code ObservableSource}s, one after the other, without interleaving them
+     * @throws NullPointerException if {@code sources} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: Concat
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @CheckReturnValue
     @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
-    public static  Observable concat(@NonNull ObservableSource> sources, int prefetch) {
+    public static  Observable concat(@NonNull ObservableSource> sources, int bufferSize) {
         Objects.requireNonNull(sources, "sources is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMap(sources, Functions.identity(), prefetch, ErrorMode.IMMEDIATE));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMap(sources, Functions.identity(), bufferSize, ErrorMode.IMMEDIATE));
     }
 
     /**
@@ -1108,6 +1140,7 @@ public static  Observable concat(@NonNull ObservableSourceReactiveX operators documentation: Concat
      */
     @CheckReturnValue
@@ -1138,6 +1171,7 @@ public static  Observable concat(@NonNull ObservableSource so
      *            an {@code ObservableSource} to be concatenated
      * @return an {@code Observable} that emits items emitted by the three source {@code ObservableSource}s, one after the other,
      *         without interleaving them
+     * @throws NullPointerException if {@code source1}, {@code source2} or {@code source3} is {@code null}
      * @see ReactiveX operators documentation: Concat
      */
     @CheckReturnValue
@@ -1173,6 +1207,7 @@ public static  Observable concat(
      *            an {@code ObservableSource} to be concatenated
      * @return an {@code Observable} that emits items emitted by the four source {@code ObservableSource}s, one after the other,
      *         without interleaving them
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3} or {@code source4} is {@code null}
      * @see ReactiveX operators documentation: Concat
      */
     @CheckReturnValue
@@ -1201,7 +1236,7 @@ public static  Observable concat(
      * @param sources the array of sources
      * @param  the common base value type
      * @return the new {@code Observable} instance
-     * @throws NullPointerException if sources is {@code null}
+     * @throws NullPointerException if {@code sources} is {@code null}
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @CheckReturnValue
@@ -1209,6 +1244,7 @@ public static  Observable concat(
     @NonNull
     @SafeVarargs
     public static  Observable concatArray(@NonNull ObservableSource... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return empty();
         }
@@ -1230,13 +1266,14 @@ public static  Observable concatArray(@NonNull ObservableSource the common base value type
      * @return the new {@code Observable} instance
-     * @throws NullPointerException if sources is {@code null}
+     * @throws NullPointerException if {@code sources} is {@code null}
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
     @NonNull
     @SafeVarargs
     public static  Observable concatArrayDelayError(@NonNull ObservableSource... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return empty();
         }
@@ -1289,7 +1326,7 @@ public static  Observable concatArrayEager(@NonNull ObservableSource Observable concatArrayEager(@NonNull ObservableSource Observable concatArrayEager(int maxConcurrency, int prefetch, @NonNull ObservableSource... sources) {
-        return fromArray(sources).concatMapEagerDelayError((Function)Functions.identity(), false, maxConcurrency, prefetch);
+    public static  Observable concatArrayEager(int maxConcurrency, int bufferSize, @NonNull ObservableSource... sources) {
+        return fromArray(sources).concatMapEagerDelayError((Function)Functions.identity(), false, maxConcurrency, bufferSize);
     }
 
     /**
@@ -1345,7 +1382,7 @@ public static  Observable concatArrayEagerDelayError(@NonNull ObservableSo
      * @param sources an array of {@code ObservableSource}s that need to be eagerly concatenated
      * @param maxConcurrency the maximum number of concurrent subscriptions at a time, {@link Integer#MAX_VALUE}
      *                       is interpreted as indication to subscribe to all sources at once
-     * @param prefetch the number of elements to prefetch from each {@code ObservableSource} source
+     * @param bufferSize the number of elements expected from each {@code ObservableSource} to be buffered
      * @return the new {@code Observable} instance with the specified concatenation behavior
      * @since 2.2.1 - experimental
      */
@@ -1354,8 +1391,8 @@ public static  Observable concatArrayEagerDelayError(@NonNull ObservableSo
     @SchedulerSupport(SchedulerSupport.NONE)
     @NonNull
     @SafeVarargs
-    public static  Observable concatArrayEagerDelayError(int maxConcurrency, int prefetch, @NonNull ObservableSource... sources) {
-        return fromArray(sources).concatMapEagerDelayError((Function)Functions.identity(), true, maxConcurrency, prefetch);
+    public static  Observable concatArrayEagerDelayError(int maxConcurrency, int bufferSize, @NonNull ObservableSource... sources) {
+        return fromArray(sources).concatMapEagerDelayError((Function)Functions.identity(), true, maxConcurrency, bufferSize);
     }
 
     /**
@@ -1372,6 +1409,7 @@ public static  Observable concatArrayEagerDelayError(int maxConcurrency, i
      * @param  the common element base type
      * @param sources the {@code Iterable} sequence of {@code ObservableSource}s
      * @return the new {@code Observable} with the concatenating behavior
+     * @throws NullPointerException if {@code sources} is {@code null}
      */
     @CheckReturnValue
     @NonNull
@@ -1415,19 +1453,21 @@ public static  Observable concatDelayError(@NonNull ObservableSource the common element base type
      * @param sources the {@code ObservableSource} sequence of {@code ObservableSource}s
-     * @param prefetch the number of elements to prefetch from the outer {@code ObservableSource}
+     * @param bufferSize the number of inner {@code ObservableSource}s expected to be buffered
      * @param tillTheEnd if {@code true}, exceptions from the outer and all inner {@code ObservableSource}s are delayed to the end
      *                   if {@code false}, exception from the outer {@code ObservableSource} is delayed till the active {@code ObservableSource} terminates
      * @return the new {@code Observable} with the concatenating behavior
+     * @throws NullPointerException if {@code sources} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @CheckReturnValue
     @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
-    public static  Observable concatDelayError(@NonNull ObservableSource> sources, int prefetch, boolean tillTheEnd) {
+    public static  Observable concatDelayError(@NonNull ObservableSource> sources, int bufferSize, boolean tillTheEnd) {
         Objects.requireNonNull(sources, "sources is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch is null");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMap(sources, Functions.identity(), prefetch, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize is null");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMap(sources, Functions.identity(), bufferSize, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY));
     }
 
     /**
@@ -1445,6 +1485,7 @@ public static  Observable concatDelayError(@NonNull ObservableSource the value type
      * @param sources a sequence of {@code ObservableSource}s that need to be eagerly concatenated
      * @return the new {@code Observable} instance with the specified concatenation behavior
+     * @throws NullPointerException if {@code sources} is {@code null}
      * @since 2.0
      */
     @CheckReturnValue
@@ -1470,16 +1511,18 @@ public static  Observable concatEager(@NonNull ObservableSource Observable concatEager(@NonNull ObservableSource> sources, int maxConcurrency, int prefetch) {
-        return wrap(sources).concatMapEager((Function)Functions.identity(), maxConcurrency, prefetch);
+    public static  Observable concatEager(@NonNull ObservableSource> sources, int maxConcurrency, int bufferSize) {
+        return wrap(sources).concatMapEager((Function)Functions.identity(), maxConcurrency, bufferSize);
     }
 
     /**
@@ -1522,7 +1565,7 @@ public static  Observable concatEager(@NonNull Iterable Observable concatEager(@NonNull Iterable Observable concatEager(@NonNull Iterable> sources, int maxConcurrency, int prefetch) {
-        return fromIterable(sources).concatMapEagerDelayError((Function)Functions.identity(), false, maxConcurrency, prefetch);
+    public static  Observable concatEager(@NonNull Iterable> sources, int maxConcurrency, int bufferSize) {
+        return fromIterable(sources).concatMapEagerDelayError((Function)Functions.identity(), false, maxConcurrency, bufferSize);
     }
 
     /**
@@ -1580,6 +1623,7 @@ public static  Observable concatEager(@NonNull Iterable the element type
      * @param source the emitter that is called when an {@code Observer} subscribes to the returned {@code Observable}
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code source} is {@code null}
      * @see ObservableOnSubscribe
      * @see ObservableEmitter
      * @see Cancellable
@@ -1614,6 +1658,7 @@ public static  Observable create(@NonNull ObservableOnSubscribe source)
      *            the type of the items emitted by the {@code ObservableSource}
      * @return an {@code Observable} whose {@code Observer}s' subscriptions trigger an invocation of the given
      *         {@code ObservableSource} factory function
+     * @throws NullPointerException if {@code supplier} is {@code null}
      * @see ReactiveX operators documentation: Defer
      */
     @CheckReturnValue
@@ -1664,6 +1709,7 @@ public static  Observable empty() {
      *            the type of the items (ostensibly) emitted by the {@code Observable}
      * @return an {@code Observable} that invokes the {@code Observer}'s {@link Observer#onError onError} method when
      *         the {@code Observer} subscribes to it
+     * @throws NullPointerException if {@code errorSupplier} is {@code null}
      * @see ReactiveX operators documentation: Throw
      */
     @CheckReturnValue
@@ -1690,6 +1736,7 @@ public static  Observable error(@NonNull Supplier err
      *            the type of the items (ostensibly) emitted by the {@code Observable}
      * @return an {@code Observable} that invokes the {@code Observer}'s {@link Observer#onError onError} method when
      *         the {@code Observer} subscribes to it
+     * @throws NullPointerException if {@code exception} is {@code null}
      * @see ReactiveX operators documentation: Throw
      */
     @CheckReturnValue
@@ -1714,6 +1761,7 @@ public static  Observable error(@NonNull Throwable exception) {
      * @param 
      *            the type of items in the array and the type of items to be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits each item in the source array
+     * @throws NullPointerException if {@code items} is {@code null}
      * @see ReactiveX operators documentation: From
      */
     @CheckReturnValue
@@ -1750,12 +1798,13 @@ public static  Observable fromArray(@NonNull T... items) {
      *   {@link RxJavaPlugins#onError(Throwable)} as an {@link UndeliverableException}.
      *   
      * 

-     * @param supplier
+     * @param callable
      *         a function, the execution of which should be deferred; {@code fromCallable} will invoke this
      *         function only when an observer subscribes to the {@code Observable} that {@code fromCallable} returns
      * @param 
      *         the type of the item returned by the {@code Callable} and emitted by the {@code Observable}
      * @return an {@code Observable} whose {@link Observer}s' subscriptions trigger an invocation of the given function
+     * @throws NullPointerException if {@code callable} is {@code null}
      * @see #defer(Supplier)
      * @see #fromSupplier(Supplier)
      * @since 2.0
@@ -1763,9 +1812,9 @@ public static  Observable fromArray(@NonNull T... items) {
     @CheckReturnValue
     @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
-    public static  Observable fromCallable(@NonNull Callable supplier) {
-        Objects.requireNonNull(supplier, "supplier is null");
-        return RxJavaPlugins.onAssembly(new ObservableFromCallable<>(supplier));
+    public static  Observable fromCallable(@NonNull Callable callable) {
+        Objects.requireNonNull(callable, "callable is null");
+        return RxJavaPlugins.onAssembly(new ObservableFromCallable<>(callable));
     }
 
     /**
@@ -1795,6 +1844,7 @@ public static  Observable fromCallable(@NonNull Callable supp
      *            the type of object that the {@code Future} returns, and also the type of item to be emitted by
      *            the resulting {@code Observable}
      * @return an {@code Observable} that emits the item from the source {@code Future}
+     * @throws NullPointerException if {@code future} is {@code null}
      * @see ReactiveX operators documentation: From
      */
     @CheckReturnValue
@@ -1836,6 +1886,7 @@ public static  Observable fromFuture(@NonNull Future future)
      *            the type of object that the {@code Future} returns, and also the type of item to be emitted by
      *            the resulting {@code Observable}
      * @return an {@code Observable} that emits the item from the source {@code Future}
+     * @throws NullPointerException if {@code future} or {@code unit} is {@code null}
      * @see ReactiveX operators documentation: From
      */
     @CheckReturnValue
@@ -1862,6 +1913,7 @@ public static  Observable fromFuture(@NonNull Future future,
      *            the type of items in the {@code Iterable} sequence and the type of items to be emitted by the
      *            resulting {@code Observable}
      * @return an {@code Observable} that emits each item in the source {@code Iterable} sequence
+     * @throws NullPointerException if {@code source} is {@code null}
      * @see ReactiveX operators documentation: From
      * @see #fromStream(Stream)
      */
@@ -1935,6 +1987,7 @@ public static  Observable fromPublisher(@NonNull Publisher pu
      * @param 
      *         the type of the item emitted by the {@code Observable}
      * @return an {@code Observable} whose {@link Observer}s' subscriptions trigger an invocation of the given function
+     * @throws NullPointerException if {@code supplier} is {@code null}
      * @see #defer(Supplier)
      * @see #fromCallable(Callable)
      * @since 3.0.0
@@ -1967,6 +2020,7 @@ public static  Observable fromSupplier(@NonNull Supplier supp
      * {@code onComplete} to signal a value or a terminal event. Signaling multiple {@code onNext}
      * in a call will make the operator signal {@link IllegalStateException}.
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code generator} is {@code null}
      */
     @CheckReturnValue
     @NonNull
@@ -1999,6 +2053,7 @@ public static  Observable generate(@NonNull Consumer> generator
      * {@code onComplete} to signal a value or a terminal event. Signaling multiple {@code onNext}
      * in a call will make the operator signal {@link IllegalStateException}.
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code initialState} or {@code generator} is {@code null}
      */
     @CheckReturnValue
     @NonNull
@@ -2032,6 +2087,7 @@ public static  Observable generate(@NonNull Supplier initialState, @
      * @param disposeState the {@link Consumer} that is called with the current state when the generator
      * terminates the sequence or it gets disposed
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code initialState}, {@code generator} or {@code disposeState} is {@code null}
      */
     @CheckReturnValue
     @NonNull
@@ -2067,6 +2123,7 @@ public static  Observable generate(
      * the next invocation. Signaling multiple {@code onNext}
      * in a call will make the operator signal {@link IllegalStateException}.
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code initialState} or {@code generator} is {@code null}
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
@@ -2100,6 +2157,7 @@ public static  Observable generate(@NonNull Supplier initialState, @
      * @param disposeState the {@link Consumer} that is called with the current state when the generator
      * terminates the sequence or it gets disposed
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code initialState}, {@code generator} or {@code disposeState} is {@code null}
      */
     @CheckReturnValue
     @NonNull
@@ -2131,6 +2189,7 @@ public static  Observable generate(@NonNull Supplier initialState, @
      * @return an {@code Observable} that emits a 0L after the {@code initialDelay} and ever increasing numbers after
      *         each {@code period} of time thereafter
      * @see ReactiveX operators documentation: Interval
+     * @throws NullPointerException if {@code unit} is {@code null}
      * @since 1.0.12
      */
     @CheckReturnValue
@@ -2162,6 +2221,7 @@ public static Observable interval(long initialDelay, long period, @NonNull
      *         each {@code period} of time thereafter, while running on the given {@code Scheduler}
      * @see ReactiveX operators documentation: Interval
      * @since 1.0.12
+     * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null}
      */
     @CheckReturnValue
     @NonNull
@@ -2262,6 +2322,10 @@ public static Observable intervalRange(long start, long count, long initia
      * @param unit the unit of measure of the {@code initialDelay} and {@code period} amounts
      * @param scheduler the target scheduler where the values and terminal signals will be emitted
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null}
+     * @throws IllegalArgumentException
+     *             if {@code count} is negative, or if {@code start} + {@code count} − 1 exceeds
+     *             {@link Long#MAX_VALUE}
      */
     @CheckReturnValue
     @NonNull
@@ -2307,6 +2371,7 @@ public static Observable intervalRange(long start, long count, long initia
      * @param 
      *            the type of that item
      * @return an {@code Observable} that emits {@code value} as a single item and then completes
+     * @throws NullPointerException if {@code item} is {@code null}
      * @see ReactiveX operators documentation: Just
      * @see #just(Object, Object)
      * @see #fromCallable(Callable)
@@ -2337,6 +2402,7 @@ public static  Observable just(@NonNull T item) {
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1} or {@code item2} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2367,6 +2433,7 @@ public static  Observable just(@NonNull T item1, @NonNull T item2) {
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1}, {@code item2} or {@code item3} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2400,6 +2467,7 @@ public static  Observable just(@NonNull T item1, @NonNull T item2, @NonNul
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1}, {@code item2}, {@code item3} or {@code item4} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2436,6 +2504,8 @@ public static  Observable just(@NonNull T item1, @NonNull T item2, @NonNul
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1}, {@code item2}, {@code item3},
+     *                              {@code item4} or {@code item5} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2475,6 +2545,8 @@ public static  Observable just(@NonNull T item1, @NonNull T item2, @NonNul
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1}, {@code item2}, {@code item3},
+     *                              {@code item4}, {@code item5} or {@code item6} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2517,6 +2589,9 @@ public static  Observable just(@NonNull T item1, @NonNull T item2, @NonNul
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1}, {@code item2}, {@code item3},
+     *                              {@code item4}, {@code item5}, {@code item6}
+     *                              or {@code item7} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2562,6 +2637,9 @@ public static  Observable just(@NonNull T item1, @NonNull T item2, @NonNul
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1}, {@code item2}, {@code item3},
+     *                              {@code item4}, {@code item5}, {@code item6}
+     *                              {@code item7} or {@code item8} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2610,6 +2688,9 @@ public static  Observable just(@NonNull T item1, @NonNull T item2, @NonNul
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1}, {@code item2}, {@code item3},
+     *                              {@code item4}, {@code item5}, {@code item6}
+     *                              {@code item7}, {@code item8} or {@code item9} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2661,6 +2742,10 @@ public static  Observable just(@NonNull T item1, @NonNull T item2, @NonNul
      * @param 
      *            the type of these items
      * @return an {@code Observable} that emits each item
+     * @throws NullPointerException if {@code item1}, {@code item2}, {@code item3},
+     *                              {@code item4}, {@code item5}, {@code item6}
+     *                              {@code item7}, {@code item8}, {@code item9}
+     *                              or {@code item10} is {@code null}
      * @see ReactiveX operators documentation: Just
      */
     @CheckReturnValue
@@ -2713,7 +2798,7 @@ public static  Observable just(@NonNull T item1, @NonNull T item2, @NonNul
      * @param maxConcurrency
      *            the maximum number of {@code ObservableSource}s that may be subscribed to concurrently
      * @param bufferSize
-     *            the number of items to prefetch from each inner {@code ObservableSource}
+     *            the number of items expected from each inner {@code ObservableSource} to be buffered
      * @return an {@code Observable} that emits items that are the result of flattening the items emitted by the
      *         {@code ObservableSource}s in the {@code Iterable}
      * @throws IllegalArgumentException
@@ -2761,7 +2846,7 @@ public static  Observable merge(@NonNull Iterable Observable merge(@NonNull IterableReactiveX operators documentation: Merge
+     * @throws NullPointerException if {@code sources} is {@code null}
      * @see #mergeDelayError(ObservableSource)
      */
     @CheckReturnValue
@@ -2942,8 +3028,9 @@ public static  Observable merge(@NonNull ObservableSourceReactiveX operators documentation: Merge
      * @since 1.1.0
      * @see #mergeDelayError(ObservableSource, int)
@@ -2989,6 +3076,7 @@ public static  Observable merge(@NonNull ObservableSourceReactiveX operators documentation: Merge
      * @see #mergeDelayError(ObservableSource, ObservableSource)
      */
@@ -3035,6 +3123,7 @@ public static  Observable merge(@NonNull ObservableSource sou
      * @param source3
      *            an {@code ObservableSource} to be merged
      * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s
+     * @throws NullPointerException if {@code source1}, {@code source2} or {@code source3} is {@code null}
      * @see ReactiveX operators documentation: Merge
      * @see #mergeDelayError(ObservableSource, ObservableSource, ObservableSource)
      */
@@ -3086,6 +3175,7 @@ public static  Observable merge(
      * @param source4
      *            an {@code ObservableSource} to be merged
      * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3} or {@code source4} is {@code null}
      * @see ReactiveX operators documentation: Merge
      * @see #mergeDelayError(ObservableSource, ObservableSource, ObservableSource, ObservableSource)
      */
@@ -3132,6 +3222,7 @@ public static  Observable merge(
      * @param sources
      *            the array of {@code ObservableSource}s
      * @return an {@code Observable} that emits all of the items emitted by the {@code ObservableSource}s in the array
+     * @throws NullPointerException if {@code sources} is {@code null}
      * @see ReactiveX operators documentation: Merge
      * @see #mergeArrayDelayError(ObservableSource...)
      */
@@ -3167,6 +3258,7 @@ public static  Observable mergeArray(@NonNull ObservableSourceReactiveX operators documentation: Merge
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -3201,9 +3293,11 @@ public static  Observable mergeDelayError(@NonNull IterableReactiveX operators documentation: Merge
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -3238,9 +3332,11 @@ public static  Observable mergeDelayError(@NonNull IterableReactiveX operators documentation: Merge
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -3310,6 +3406,7 @@ public static  Observable mergeDelayError(@NonNull IterableReactiveX operators documentation: Merge
      */
     @CheckReturnValue
@@ -3347,6 +3444,8 @@ public static  Observable mergeDelayError(@NonNull ObservableSourceReactiveX operators documentation: Merge
      * @since 2.0
      */
@@ -3384,6 +3483,7 @@ public static  Observable mergeDelayError(@NonNull ObservableSourceReactiveX operators documentation: Merge
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -3424,6 +3524,7 @@ public static  Observable mergeDelayError(
      * @param source3
      *            an {@code ObservableSource} to be merged
      * @return an {@code Observable} that emits all of the items that are emitted by the {@code ObservableSource}s
+     * @throws NullPointerException if {@code source1}, {@code source2} or {@code source3} is {@code null}
      * @see ReactiveX operators documentation: Merge
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -3468,6 +3569,7 @@ public static  Observable mergeDelayError(
      * @param source4
      *            an {@code ObservableSource} to be merged
      * @return an {@code Observable} that emits all of the items that are emitted by the {@code ObservableSource}s
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3} or {@code source4} is {@code null}
      * @see ReactiveX operators documentation: Merge
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -3557,7 +3659,7 @@ public static  Observable never() {
      *            the number of sequential {@code Integer}s to generate
      * @return an {@code Observable} that emits a range of sequential {@code Integer}s
      * @throws IllegalArgumentException
-     *             if {@code count} is less than zero, or if {@code start} + {@code count} − 1 exceeds
+     *             if {@code count} is negative, or if {@code start} + {@code count} − 1 exceeds
      *             {@link Integer#MAX_VALUE}
      * @see ReactiveX operators documentation: Range
      */
@@ -3595,7 +3697,7 @@ public static Observable range(int start, int count) {
      *            the number of sequential {@code Long}s to generate
      * @return an {@code Observable} that emits a range of sequential {@code Long}s
      * @throws IllegalArgumentException
-     *             if {@code count} is less than zero, or if {@code start} + {@code count} − 1 exceeds
+     *             if {@code count} is negative, or if {@code start} + {@code count} − 1 exceeds
      *             {@link Long#MAX_VALUE}
      * @see ReactiveX operators documentation: Range
      */
@@ -3699,11 +3801,13 @@ public static  Single sequenceEqual(
      * @param isEqual
      *            a function used to compare items emitted by each {@code ObservableSource}
      * @param bufferSize
-     *            the number of items to prefetch from the first and second source {@code ObservableSource}
+     *            the number of items expected from the first and second source {@code ObservableSource} to be buffered
      * @param 
      *            the type of items emitted by each {@code ObservableSource}
      * @return a {@code Single} that emits a {@code Boolean} value that indicates whether the two {@code ObservableSource} two sequences
      *         are the same according to the specified function
+     * @throws NullPointerException if {@code source1}, {@code source2} or {@code isEqual} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: SequenceEqual
      */
     @CheckReturnValue
@@ -3734,7 +3838,7 @@ public static  Single sequenceEqual(
      * @param source2
      *            the second {@code ObservableSource} to compare
      * @param bufferSize
-     *            the number of items to prefetch from the first and second source {@code ObservableSource}
+     *            the number of items expected from the first and second source {@code ObservableSource} to be buffered
      * @param 
      *            the type of items emitted by each {@code ObservableSource}
      * @return a {@code Single} that emits a {@code Boolean} value that indicates whether the two sequences are the same
@@ -3773,6 +3877,8 @@ public static  Single sequenceEqual(@NonNull ObservableSourceReactiveX operators documentation: Switch
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
@@ -3877,6 +3983,8 @@ public static  Observable switchOnNextDelayError(@NonNull ObservableSource
      *            the expected number of items to cache from the inner {@code ObservableSource}s
      * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} most recently emitted by the {@code sources}
      *         {@code ObservableSource}
+     * @throws NullPointerException if {@code sources} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: Switch
      * @since 2.0
      */
@@ -3947,7 +4055,7 @@ public static Observable timer(long delay, @NonNull TimeUnit unit, @NonNul
 
     /**
      * Create an {@code Observable} by wrapping an {@link ObservableSource} which has to be implemented according
-     * to the {@code Observable} specification derived from the Reactive Streams specification by handling
+     * to the {@code Observable} specification derived from the Reactive Streams specification by handling
      * disposal correctly; no safeguards are provided by the {@code Observable} itself.
      * 

      *  
Scheduler:

@@ -3956,6 +4064,7 @@ public static Observable timer(long delay, @NonNull TimeUnit unit, @NonNul
      * @param  the value type emitted
      * @param onSubscribe the {@code ObservableSource} instance to wrap
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code onSubscribe} is {@code null}
      * @throws IllegalArgumentException if the {@code onSubscribe} is already an {@code Observable}, use
      *                                  {@link #wrap(ObservableSource)} in this case
      * @see #wrap(ObservableSource)
@@ -4028,6 +4137,7 @@ public static  Observable using(
      *            If {@code false}, the resource disposal will happen either on a {@code dispose()} call after the upstream is disposed
      *            or just after the emission of a terminal event ({@code onComplete} or {@code onError}).
      * @return the {@code ObservableSource} whose lifetime controls the lifetime of the dependent resource object
+     * @throws NullPointerException if {@code resourceSupplier}, {@code sourceSupplier} and {@code resourceDisposer} is {@code null}
      * @see ReactiveX operators documentation: Using
      * @since 2.0
      */
@@ -4111,6 +4221,7 @@ public static  Observable wrap(@NonNull ObservableSource source) {
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in
      *            an item that will be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code sources} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4166,10 +4277,12 @@ public static  Observable zip(@NonNull Iterable the common source value type
      * @param  the zipped result type
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code sources} or {@code zipper} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4226,6 +4339,7 @@ public static  Observable zip(@NonNull IterableReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4283,6 +4397,7 @@ public static  Observable zip(
      *            in an item that will be emitted by the resulting {@code Observable}
      * @param delayError delay errors from any of the {@code ObservableSource}s till the other terminates
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4339,8 +4454,9 @@ public static  Observable zip(
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results
      *            in an item that will be emitted by the resulting {@code Observable}
      * @param delayError delay errors from any of the {@code ObservableSource}s till the other terminates
-     * @param bufferSize the number of elements to prefetch from each source {@code ObservableSource}
+     * @param bufferSize the number of elements expected from each source {@code ObservableSource} to be buffered
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4401,6 +4517,7 @@ public static  Observable zip(
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in
      *            an item that will be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4466,6 +4583,8 @@ public static  Observable zip(
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in
      *            an item that will be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4535,6 +4654,8 @@ public static  Observable zip(
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in
      *            an item that will be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4607,6 +4728,8 @@ public static  Observable zip(
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in
      *            an item that will be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5}, {@code source6} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4683,6 +4806,9 @@ public static  Observable zip(
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in
      *            an item that will be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5}, {@code source6},
+     *                              {@code source7} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4764,6 +4890,9 @@ public static  Observable zip(
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in
      *            an item that will be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5}, {@code source6},
+     *                              {@code source7}, {@code source8} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4849,6 +4978,9 @@ public static  Observable zip(
      *            a function that, when applied to an item emitted by each of the {@code ObservableSource}s, results in
      *            an item that will be emitted by the resulting {@code Observable}
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3},
+     *                              {@code source4}, {@code source5}, {@code source6},
+     *                              {@code source7}, {@code source8}, {@code source9} or {@code zipper} is {@code null}
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4918,8 +5050,10 @@ public static  Observable zip(
      * @param delayError
      *            delay errors signaled by any of the {@code ObservableSource} until all {@code ObservableSource}s terminate
      * @param bufferSize
-     *            the number of elements to prefetch from each source {@code ObservableSource}
+     *            the number of elements expected from each source {@code ObservableSource} to be buffered
      * @return an {@code Observable} that emits the zipped results
+     * @throws NullPointerException if {@code sources} or {@code zipper} is {@code null}
+     * @throws IllegalArgumentException if {@code bufferSize} is non-positive
      * @see ReactiveX operators documentation: Zip
      */
     @CheckReturnValue
@@ -4930,6 +5064,7 @@ public static  Observable zipArray(
             @NonNull Function zipper,
             boolean delayError, int bufferSize,
             @NonNull ObservableSource... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return empty();
         }
@@ -4956,6 +5091,7 @@ public static  Observable zipArray(
      *            a function that evaluates an item and returns a {@code Boolean}
      * @return a {@code Single} that emits {@code true} if all items emitted by the current {@code Observable} satisfy the
      *         predicate; otherwise, {@code false}
+     * @throws NullPointerException if {@code predicate} is {@code null}
      * @see ReactiveX operators documentation: All
      */
     @CheckReturnValue
@@ -4981,6 +5117,7 @@ public final Single all(@NonNull Predicate predicate) {
      *            subscribing to the current source.
      * @return an {@code Observable} that emits the same sequence as whichever of the current {@code Observable}s first
      *         emitted an item or sent a termination notification
+     * @throws NullPointerException if {@code other} is {@code null}
      * @see ReactiveX operators documentation: Amb
      */
     @CheckReturnValue
@@ -5009,6 +5146,7 @@ public final Observable ambWith(@NonNull ObservableSource other)
      *            the condition to test items emitted by the current {@code Observable}
      * @return a {@code Single} that emits a {@link Boolean} that indicates whether any item emitted by the current
      *         {@code Observable} satisfies the {@code predicate}
+     * @throws NullPointerException if {@code predicate} is {@code null}
      * @see ReactiveX operators documentation: Contains
      */
     @CheckReturnValue
@@ -5135,6 +5273,8 @@ public final void blockingForEach(@NonNull Consumer onNext) {
      *            the {@code Consumer} to invoke for each item emitted by the {@code Observable}
      * @param capacityHint
      *            the number of items expected to be buffered (allows reducing buffer reallocations)
+     * @throws NullPointerException if {@code onNext} is {@code null}
+     * @throws IllegalArgumentException if {@code capacityHint} is non-positive
      * @throws RuntimeException
      *             if an error occurs; {@code Error}s and {@code RuntimeException}s are rethrown
      *             as they are, checked {@code Exception}s are wrapped into {@code RuntimeException}s
@@ -5144,6 +5284,7 @@ public final void blockingForEach(@NonNull Consumer onNext) {
     @SchedulerSupport(SchedulerSupport.NONE)
     @NonNull
     public final void blockingForEach(@NonNull Consumer onNext, int capacityHint) {
+        Objects.requireNonNull(onNext, "onNext is null");
         Iterator it = blockingIterable(capacityHint).iterator();
         while (it.hasNext()) {
             try {
@@ -5190,6 +5331,7 @@ public final Iterable blockingIterable() {
      *
      * @param capacityHint the expected number of items to be buffered
      * @return the new {@code Iterable} instance
+     * @throws IllegalArgumentException if {@code capacityHint} is non-positive
      * @see ReactiveX documentation: To
      */
     @CheckReturnValue
@@ -5394,9 +5536,9 @@ public final T blockingSingle(@NonNull T defaultItem) {
      * 

      * 
      * 

-     * If the {@link Observable} emits more than one item, {@link java.util.concurrent.Future} will receive an
-     * {@link java.lang.IndexOutOfBoundsException}. If the {@link Observable} is empty, {@link java.util.concurrent.Future}
-     * will receive an {@link java.util.NoSuchElementException}. The {@code Observable} source has to terminate in order
+     * If the {@code Observable} emits more than one item, {@code Future} will receive an
+     * {@link IndexOutOfBoundsException}. If the {@code Observable} is empty, {@code Future}
+     * will receive an {@link NoSuchElementException}. The {@code Observable} source has to terminate in order
      * for the returned {@code Future} to terminate as well.
      * 

      * If the {@code Observable} may emit more than one item, use {@code Observable.toList().toFuture()}.
@@ -5407,6 +5549,7 @@ public final T blockingSingle(@NonNull T defaultItem) {
      *
      * @return a {@code Future} that expects a single item to be emitted by the current {@code Observable}
      * @see ReactiveX documentation: To
+     * @see #singleOrErrorStage()
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
@@ -5523,10 +5666,12 @@ public final void blockingSubscribe(@NonNull Consumer onNext, @NonNul
      * 

      * The a dispose() call is composed through.
      * @param observer the {@code Observer} instance to forward events and calls to in the current thread
+     * @throws NullPointerException if {@code observer} is {@code null}
      * @since 2.0
      */
     @SchedulerSupport(SchedulerSupport.NONE)
     public final void blockingSubscribe(@NonNull Observer observer) {
+        Objects.requireNonNull(observer, "observer is null");
         ObservableBlockingSubscribe.subscribe(this, observer);
     }
 
@@ -5547,6 +5692,7 @@ public final void blockingSubscribe(@NonNull Observer observer) {
      *            the maximum number of items in each buffer before it should be emitted
      * @return an {@code Observable} that emits connected, non-overlapping buffers, each containing at most
      *         {@code count} items from the current {@code Observable}
+     * @throws IllegalArgumentException if {@code count} is non-positive
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5577,6 +5723,7 @@ public final void blockingSubscribe(@NonNull Observer observer) {
      *            {@link #buffer(int)}.
      * @return an {@code Observable} that emits buffers for every {@code skip} item from the current {@code Observable} and
      *         containing at most {@code count} items
+     * @throws IllegalArgumentException if {@code count} or {@code skip} is non-positive
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5611,6 +5758,8 @@ public final void blockingSubscribe(@NonNull Observer observer) {
      *            as the buffer
      * @return an {@code Observable} that emits buffers for every {@code skip} item from the current {@code Observable} and
      *         containing at most {@code count} items
+     * @throws NullPointerException if {@code bufferSupplier} is {@code null}
+     * @throws IllegalArgumentException if {@code count} or {@code skip} is non-positive
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5644,6 +5793,8 @@ public final > Observable buffer(int count, i
      *            as the buffer
      * @return an {@code Observable} that emits connected, non-overlapping buffers, each containing at most
      *         {@code count} items from the current {@code Observable}
+     * @throws NullPointerException if {@code bufferSupplier} is {@code null}
+     * @throws IllegalArgumentException if {@code count} is non-positive
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5675,6 +5826,7 @@ public final > Observable buffer(int count, i
      *            the unit of time that applies to the {@code timespan} and {@code timeskip} arguments
      * @return an {@code Observable} that emits new buffers of items emitted by the current {@code Observable} periodically after
      *         a fixed timespan has elapsed
+     * @throws NullPointerException if {@code unit} is {@code null}
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5709,6 +5861,7 @@ public final > Observable buffer(int count, i
      *            the {@code Scheduler} to use when determining the end and start of a buffer
      * @return an {@code Observable} that emits new buffers of items emitted by the current {@code Observable} periodically after
      *         a fixed timespan has elapsed
+     * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null}
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5747,6 +5900,7 @@ public final > Observable buffer(int count, i
      *            as the buffer
      * @return an {@code Observable} that emits new buffers of items emitted by the current {@code Observable} periodically after
      *         a fixed timespan has elapsed
+     * @throws NullPointerException if {@code unit}, {@code scheduler} or {@code bufferSupplier} is {@code null}
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5892,6 +6046,8 @@ public final > Observable buffer(int count, i
      * @return an {@code Observable} that emits connected, non-overlapping buffers of items emitted by the current
      *         {@code Observable} after a fixed duration or when the buffer reaches maximum capacity (whichever occurs
      *         first)
+     * @throws NullPointerException if {@code unit}, {@code scheduler} or {@code bufferSupplier} is {@code null}
+     * @throws IllegalArgumentException if {@code count} is non-positive
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5932,6 +6088,7 @@ public final > Observable buffer(int count, i
      *            the {@code Scheduler} to use when determining the end and start of a buffer
      * @return an {@code Observable} that emits connected, non-overlapping buffers of items emitted by the current
      *         {@code Observable} within a fixed duration
+     * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null}
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -5963,6 +6120,7 @@ public final > Observable buffer(int count, i
      *            {@code ObservableSource} emits an item, the associated buffer is emitted.
      * @return an {@code Observable} that emits buffers, containing items from the current {@code Observable}, that are created
      *         and closed when the specified {@code ObservableSource}s emit items
+     * @throws NullPointerException if {@code openingIndicator} or {@code closingIndicator} is {@code null}
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -6000,6 +6158,7 @@ public final > Observable buffer(int count, i
      *            as the buffer
      * @return an {@code Observable} that emits buffers, containing items from the current {@code Observable}, that are created
      *         and closed when the specified {@code ObservableSource}s emit items
+     * @throws NullPointerException if {@code openingIndicator}, {@code closingIndicator} or {@code bufferSupplier} is {@code null}
      * @see ReactiveX operators documentation: Buffer
      */
     @CheckReturnValue
@@ -6070,6 +6229,8 @@ public final > Observable buffer(int count, i
      * @return an {@code Observable} that emits buffered items from the current {@code Observable} when the boundary {@code ObservableSource}
      *         emits an item
      * @see ReactiveX operators documentation: Buffer
+     * @throws NullPointerException if {@code boundary} is {@code null}
+     * @throws IllegalArgumentException if {@code initialCapacity} is non-positive
      * @see #buffer(ObservableSource)
      */
     @CheckReturnValue
@@ -6105,6 +6266,7 @@ public final > Observable buffer(int count, i
      *            as the buffer
      * @return an {@code Observable} that emits buffered items from the current {@code Observable} when the boundary {@code ObservableSource}
      *         emits an item
+     * @throws NullPointerException if {@code boundary} or {@code bufferSupplier} is {@code null}
      * @see #buffer(ObservableSource, int)
      * @see ReactiveX operators documentation: Buffer
      */
@@ -6224,6 +6386,7 @@ public final Observable cache() {
      * @param initialCapacity hint for number of items to cache (for optimizing underlying data structure)
      * @return an {@code Observable} that, when first subscribed to, caches all of its items and notifications for the
      *         benefit of subsequent subscribers
+     * @throws IllegalArgumentException if {@code initialCapacity} is non-positive
      * @see ReactiveX operators documentation: Replay
      * @see #takeUntil(Predicate)
      * @see #takeUntil(ObservableSource)
@@ -6252,6 +6415,7 @@ public final Observable cacheWithInitialCapacity(int initialCapacity) {
      *            into before emitting them from the resulting {@code Observable}
      * @return an {@code Observable} that emits each item from the current {@code Observable} after converting it to the
      *         specified type
+     * @throws NullPointerException if {@code clazz} is {@code null}
      * @see ReactiveX operators documentation: Map
      */
     @CheckReturnValue
@@ -6286,6 +6450,7 @@ public final  Observable cast(@NonNull Class clazz) {
      *           accordingly
      * @return a {@code Single} that emits the result of collecting the values emitted by the current {@code Observable}
      *         into a single mutable data structure
+     * @throws NullPointerException if {@code initialValueSupplier} or {@code collector} is {@code null}
      * @see ReactiveX operators documentation: Reduce
      */
     @CheckReturnValue
@@ -6321,6 +6486,7 @@ public final  Single collect(@NonNull Supplier initialValueSu
      *           accordingly
      * @return a {@code Single} that emits the result of collecting the values emitted by the current {@code Observable}
      *         into a single mutable data structure
+     * @throws NullPointerException if {@code initialValue} or {@code collector} is {@code null}
      * @see ReactiveX operators documentation: Reduce
      */
     @CheckReturnValue
@@ -6348,6 +6514,7 @@ public final  Single collectInto(@NonNull U initialValue, @NonNull BiConsu
      * @param  the value type of the output {@code ObservableSource}
      * @param composer implements the function that transforms the current {@code Observable}
      * @return the current {@code Observable}, transformed by the transformer function
+     * @throws NullPointerException if {@code composer} is {@code null}
      * @see RxJava wiki: Implementing Your Own Operators
      */
     @SuppressWarnings("unchecked")
@@ -6379,6 +6546,7 @@ public final  Observable compose(@NonNull ObservableTransformerReactiveX operators documentation: FlatMap
      * @see #concatMap(Function, int, Scheduler)
      */
@@ -6408,19 +6576,21 @@ public final  Observable concatMap(@NonNull FunctionReactiveX operators documentation: FlatMap
      * @see #concatMap(Function, int, Scheduler)
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
     @NonNull
-    public final  Observable concatMap(@NonNull Function> mapper, int prefetch) {
+    public final  Observable concatMap(@NonNull Function> mapper, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
         if (this instanceof ScalarSupplier) {
             @SuppressWarnings("unchecked")
             T v = ((ScalarSupplier)this).get();
@@ -6429,7 +6599,7 @@ public final  Observable concatMap(@NonNull Function(this, mapper, prefetch, ErrorMode.IMMEDIATE));
+        return RxJavaPlugins.onAssembly(new ObservableConcatMap<>(this, mapper, bufferSize, ErrorMode.IMMEDIATE));
     }
 
     /**
@@ -6450,23 +6620,25 @@ public final  Observable concatMap(@NonNull FunctionReactiveX operators documentation: FlatMap
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     @NonNull
-    public final  Observable concatMap(@NonNull Function> mapper, int prefetch, @NonNull Scheduler scheduler) {
+    public final  Observable concatMap(@NonNull Function> mapper, int bufferSize, @NonNull Scheduler scheduler) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
         Objects.requireNonNull(scheduler, "scheduler is null");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapScheduler<>(this, mapper, prefetch, ErrorMode.IMMEDIATE, scheduler));
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapScheduler<>(this, mapper, bufferSize, ErrorMode.IMMEDIATE, scheduler));
     }
 
     /**
@@ -6488,6 +6660,7 @@ public final  Observable concatMap(@NonNull Function the result value type
      * @param mapper the function that maps the items of the current {@code Observable} into the inner {@code ObservableSource}s.
      * @return the new {@code Observable} instance with the concatenation behavior
+     * @throws NullPointerException if {@code mapper} is {@code null}
      * @see #concatMapDelayError(Function, boolean, int, Scheduler)
      */
     @CheckReturnValue
@@ -6518,18 +6691,20 @@ public final  Observable concatMapDelayError(@NonNull Function Observable concatMapDelayError(@NonNull Function> mapper,
-            boolean tillTheEnd, int prefetch) {
+            boolean tillTheEnd, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
         if (this instanceof ScalarSupplier) {
             @SuppressWarnings("unchecked")
             T v = ((ScalarSupplier)this).get();
@@ -6538,7 +6713,7 @@ public final  Observable concatMapDelayError(@NonNull Function(this, mapper, prefetch, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY));
+        return RxJavaPlugins.onAssembly(new ObservableConcatMap<>(this, mapper, bufferSize, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY));
     }
 
     /**
@@ -6558,11 +6733,13 @@ public final  Observable concatMapDelayError(@NonNull Function Observable concatMapDelayError(@NonNull Function Observable concatMapDelayError(@NonNull Function> mapper,
-            boolean tillTheEnd, int prefetch, @NonNull Scheduler scheduler) {
+            boolean tillTheEnd, int bufferSize, @NonNull Scheduler scheduler) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
         Objects.requireNonNull(scheduler, "scheduler is null");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapScheduler<>(this, mapper, prefetch, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, scheduler));
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapScheduler<>(this, mapper, bufferSize, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, scheduler));
     }
 
     /**
@@ -6594,6 +6771,7 @@ public final  Observable concatMapDelayError(@NonNull Function Observable concatMapEager(@NonNull Function Observable concatMapEager(@NonNull Function> mapper,
-            int maxConcurrency, int prefetch) {
+            int maxConcurrency, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
         ObjectHelper.verifyPositive(maxConcurrency, "maxConcurrency");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapEager<>(this, mapper, ErrorMode.IMMEDIATE, maxConcurrency, prefetch));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapEager<>(this, mapper, ErrorMode.IMMEDIATE, maxConcurrency, bufferSize));
     }
 
     /**
@@ -6655,6 +6835,7 @@ public final  Observable concatMapEager(@NonNull Function Observable concatMapEagerDelayError(@NonNull Function Observable concatMapEagerDelayError(@NonNull Function> mapper,
-            boolean tillTheEnd, int maxConcurrency, int prefetch) {
+            boolean tillTheEnd, int maxConcurrency, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
         ObjectHelper.verifyPositive(maxConcurrency, "maxConcurrency");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapEager<>(this, mapper, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, maxConcurrency, prefetch));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapEager<>(this, mapper, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, maxConcurrency, bufferSize));
     }
 
     /**
@@ -6715,6 +6898,7 @@ public final  Observable concatMapEagerDelayError(@NonNull Function mapper, boolean tillTheEnd, int prefetch) {
+    public final Completable concatMapCompletableDelayError(@NonNull Function mapper, boolean tillTheEnd, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapCompletable<>(this, mapper, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, prefetch));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapCompletable<>(this, mapper, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, bufferSize));
     }
 
     /**
@@ -6863,6 +7051,7 @@ public final Completable concatMapCompletableDelayError(@NonNull FunctionReactiveX operators documentation: FlatMap
      */
     @CheckReturnValue
@@ -6889,19 +7078,21 @@ public final  Observable concatMapIterable(@NonNull FunctionReactiveX operators documentation: FlatMap
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
     @NonNull
-    public final  Observable concatMapIterable(@NonNull Function> mapper, int prefetch) {
+    public final  Observable concatMapIterable(@NonNull Function> mapper, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return concatMap(ObservableInternalHelper.flatMapIntoIterable(mapper), prefetch);
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return concatMap(ObservableInternalHelper.flatMapIntoIterable(mapper), bufferSize);
     }
 
     /**
@@ -6920,6 +7111,7 @@ public final  Observable concatMapIterable(@NonNull Function Observable concatMapMaybe(@NonNull Function Observable concatMapMaybe(@NonNull Function Observable concatMapMaybe(@NonNull Function> mapper, int prefetch) {
+    public final  Observable concatMapMaybe(@NonNull Function> mapper, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapMaybe<>(this, mapper, ErrorMode.IMMEDIATE, prefetch));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapMaybe<>(this, mapper, ErrorMode.IMMEDIATE, bufferSize));
     }
 
     /**
@@ -6980,6 +7172,7 @@ public final  Observable concatMapMaybe(@NonNull Function Observable concatMapMaybeDelayError(@NonNull Function Observable concatMapMaybeDelayError(@NonNull Function Observable concatMapMaybeDelayError(@NonNull Function> mapper, boolean tillTheEnd, int prefetch) {
+    public final  Observable concatMapMaybeDelayError(@NonNull Function> mapper, boolean tillTheEnd, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapMaybe<>(this, mapper, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, prefetch));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapMaybe<>(this, mapper, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, bufferSize));
     }
 
     /**
@@ -7078,6 +7272,7 @@ public final  Observable concatMapMaybeDelayError(@NonNull Function Observable concatMapSingle(@NonNull Function Observable concatMapSingle(@NonNull Function Observable concatMapSingle(@NonNull Function> mapper, int prefetch) {
+    public final  Observable concatMapSingle(@NonNull Function> mapper, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapSingle<>(this, mapper, ErrorMode.IMMEDIATE, prefetch));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapSingle<>(this, mapper, ErrorMode.IMMEDIATE, bufferSize));
     }
 
     /**
@@ -7138,6 +7333,7 @@ public final  Observable concatMapSingle(@NonNull Function Observable concatMapSingleDelayError(@NonNull Function Observable concatMapSingleDelayError(@NonNull Function Observable concatMapSingleDelayError(@NonNull Function> mapper, boolean tillTheEnd, int prefetch) {
+    public final  Observable concatMapSingleDelayError(@NonNull Function> mapper, boolean tillTheEnd, int bufferSize) {
         Objects.requireNonNull(mapper, "mapper is null");
-        ObjectHelper.verifyPositive(prefetch, "prefetch");
-        return RxJavaPlugins.onAssembly(new ObservableConcatMapSingle<>(this, mapper, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, prefetch));
+        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
+        return RxJavaPlugins.onAssembly(new ObservableConcatMapSingle<>(this, mapper, tillTheEnd ? ErrorMode.END : ErrorMode.BOUNDARY, bufferSize));
     }
 
     /**
@@ -7234,6 +7431,7 @@ public final  Observable concatMapSingleDelayError(@NonNull FunctionReactiveX operators documentation: Concat
      */
     @CheckReturnValue
@@ -7256,6 +7454,7 @@ public final Observable concatWith(@NonNull ObservableSource oth
      * 
History: 2.1.10 - experimental
      * @param other the {@code SingleSource} whose signal should be emitted after the current {@code Observable} completes normally.
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code other} is {@code null}
      * @since 2.2
      */
     @CheckReturnValue
@@ -7278,6 +7477,7 @@ public final Observable concatWith(@NonNull SingleSource other)
      * 
History: 2.1.10 - experimental
      * @param other the {@code MaybeSource} whose signal should be emitted after the current {@code Observable} completes normally.
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code other} is {@code null}
      * @since 2.2
      */
     @CheckReturnValue
@@ -7300,6 +7500,7 @@ public final Observable concatWith(@NonNull MaybeSource other) {
      * 
History: 2.1.10 - experimental
      * @param other the {@code CompletableSource} to subscribe to once the current {@code Observable} completes normally
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code other} is {@code null}
      * @since 2.2
      */
     @CheckReturnValue
@@ -7324,6 +7525,7 @@ public final Observable concatWith(@NonNull CompletableSource other) {
      *            the item to search for in the emissions from the current {@code Observable}
      * @return a {@code Single} that emits {@code true} if the specified item is emitted by the current {@code Observable},
      *         or {@code false} if the current {@code Observable} completes without emitting that item
+     * @throws NullPointerException if {@code element} is {@code null}
      * @see ReactiveX operators documentation: Contains
      */
     @CheckReturnValue
@@ -7380,6 +7582,7 @@ public final Single count() {
      *            function to return a sequence that indicates the throttle duration for each item via its own emission or completion
      * @return an {@code Observable} that omits items emitted by the current {@code Observable} that are followed by another item
      *         within a computed debounce duration
+     * @throws NullPointerException if {@code debounceSelector} is {@code null}
      * @see ReactiveX operators documentation: Debounce
      */
     @CheckReturnValue
@@ -7419,6 +7622,7 @@ public final  Observable debounce(@NonNull FunctionReactiveX operators documentation: Debounce
      * @see #throttleWithTimeout(long, TimeUnit)
      */
@@ -7460,6 +7664,7 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit) {
      *            item
      * @return an {@code Observable} that filters out items from the current {@code Observable} that are too quickly followed by
      *         newer items
+     * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null}
      * @see ReactiveX operators documentation: Debounce
      * @see #throttleWithTimeout(long, TimeUnit, Scheduler)
      */
@@ -7486,6 +7691,7 @@ public final Observable debounce(long timeout, @NonNull TimeUnit unit, @NonNu
      *            the item to emit if the current {@code Observable} emits no items
      * @return an {@code Observable} that emits either the specified default item if the current {@code Observable} emits no
      *         items, or the items emitted by the current {@code Observable}
+     * @throws NullPointerException if {@code defaultItem} is {@code null}
      * @see ReactiveX operators documentation: DefaultIfEmpty
      */
     @CheckReturnValue
@@ -7517,6 +7723,7 @@ public final Observable defaultIfEmpty(@NonNull T defaultItem) {
      *            returned from {@code itemDelay} emits an item
      * @return an {@code Observable} that delays the emissions of the current {@code Observable} via another {@code ObservableSource} on a
      *         per-item basis
+     * @throws NullPointerException if {@code itemDelay} is {@code null}
      * @see ReactiveX operators documentation: Delay
      */
     @CheckReturnValue
@@ -7542,6 +7749,7 @@ public final  Observable delay(@NonNull FunctionReactiveX operators documentation: Delay
      * @see #delay(long, TimeUnit, boolean)
      * @see #delay(long, TimeUnit, Scheduler)
@@ -7571,6 +7779,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit) {
      *            if {@code true}, the upstream exception is signaled with the given delay, after all preceding normal elements,
      *            if {@code false}, the upstream exception is signaled immediately
      * @return the current {@code Observable} shifted in time by the specified delay
+     * @throws NullPointerException if {@code unit} is {@code null}
      * @see ReactiveX operators documentation: Delay
      * @see #delay(long, TimeUnit, Scheduler, boolean)
      */
@@ -7598,6 +7807,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, boolean del
      * @param scheduler
      *            the {@code Scheduler} to use for delaying
      * @return the current {@code Observable} shifted in time by the specified delay
+     * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null}
      * @see ReactiveX operators documentation: Delay
      */
     @CheckReturnValue
@@ -7627,6 +7837,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, @NonNull Sc
      *            if {@code true}, the upstream exception is signaled with the given delay, after all preceding normal elements,
      *            if {@code false}, the upstream exception is signaled immediately
      * @return the current {@code Observable} shifted in time by the specified delay
+     * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null}
      * @see ReactiveX operators documentation: Delay
      */
     @CheckReturnValue
@@ -7665,6 +7876,7 @@ public final Observable delay(long delay, @NonNull TimeUnit unit, @NonNull Sc
      *            returned from {@code itemDelay} emits an item
      * @return an {@code Observable} that delays the subscription and emissions of the current {@code Observable} via another
      *         {@code ObservableSource} on a per-item basis
+     * @throws NullPointerException if {@code subscriptionDelay} or {@code itemDelay} is {@code null}
      * @see ReactiveX operators documentation: Delay
      */
     @CheckReturnValue
@@ -7690,6 +7902,7 @@ public final  Observable delay(@NonNull ObservableSource subscriptio
      *        to the current {@code Observable}.
      * @return an {@code Observable} that delays the subscription to the current {@code Observable}
      *         until the other {@code ObservableSource} emits an element or completes normally.
+     * @throws NullPointerException if {@code other} is {@code null}
      * @since 2.0
      */
     @CheckReturnValue
@@ -7714,6 +7927,7 @@ public final  Observable delaySubscription(@NonNull ObservableSource ot
      * @param unit
      *            the time unit of {@code delay}
      * @return an {@code Observable} that delays the subscription to the current {@code Observable} by the given amount
+     * @throws NullPointerException if {@code unit} is {@code null}
      * @see ReactiveX operators documentation: Delay
      */
     @CheckReturnValue
@@ -7741,6 +7955,7 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit)
      *            the {@code Scheduler} on which the waiting and subscription will happen
      * @return an {@code Observable} that delays the subscription to the current {@code Observable} by a given
      *         amount, waiting and subscribing on the given {@code Scheduler}
+     * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null}
      * @see ReactiveX operators documentation: Delay
      */
     @CheckReturnValue
@@ -7794,6 +8009,7 @@ public final Observable delaySubscription(long delay, @NonNull TimeUnit unit,
      * the corresponding {@code Observer} event to the downstream.
      * @return an {@code Observable} that emits the items and notifications embedded in the {@code Notification} objects
      *         selected from the items emitted by the current {@code Observable}
+     * @throws NullPointerException if {@code selector} is {@code null}
      * @see ReactiveX operators documentation: Dematerialize
      * @since 3.0.0
      */
@@ -7874,6 +8090,7 @@ public final Observable distinct() {
      *            a function that projects an emitted item to a key value that is used to decide whether an item
      *            is distinct from another one or not
      * @return an {@code Observable} that emits those items emitted by the current {@code Observable} that have distinct keys
+     * @throws NullPointerException if {@code keySelector} is {@code null}
      * @see ReactiveX operators documentation: Distinct
      * @see #distinct(Function, Supplier)
      */
@@ -7907,6 +8124,7 @@ public final  Observable distinct(@NonNull Function keySelec
      *            function called for each individual {@link Observer} to return a {@link Collection} subtype for holding the extracted
      *            keys and whose {@code add()} method's return indicates uniqueness.
      * @return an {@code Observable} that emits those items emitted by the current {@code Observable} that have distinct keys
+     * @throws NullPointerException if {@code keySelector} or {@code collectionSupplier} is {@code null}
      * @see ReactiveX operators documentation: Distinct
      */
     @CheckReturnValue
@@ -7990,6 +8208,7 @@ public final Observable distinctUntilChanged() {
      *            is distinct from another one or not
      * @return an {@code Observable} that emits those items from the current {@code Observable} whose keys are distinct from
      *         those of their immediate predecessors
+     * @throws NullPointerException if {@code keySelector} is {@code null}
      * @see ReactiveX operators documentation: Distinct
      */
     @CheckReturnValue
@@ -8024,6 +8243,7 @@ public final  Observable distinctUntilChanged(@NonNull FunctionReactiveX operators documentation: Distinct
      * @since 2.0
      */
@@ -8051,6 +8271,7 @@ public final Observable distinctUntilChanged(@NonNull BiPredicateHistory: 2.0.1 - experimental
      * @param onAfterNext the {@code Consumer} that will be called after emitting an item from upstream to the downstream
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code onAfterNext} is {@code null}
      * @since 2.1
      */
     @CheckReturnValue
@@ -8071,19 +8292,20 @@ public final Observable doAfterNext(@NonNull Consumer onAfterNext)
      *  
{@code doAfterTerminate} does not operate by default on a particular {@link Scheduler}.

      * 

      *
-     * @param onFinally
-     *            an {@code Action} to be invoked when the current {@code Observable} finishes
+     * @param onAfterTerminate
+     *            an {@code Action} to be invoked after the current {@code Observable} finishes
      * @return an {@code Observable} that emits the same items as the current {@code Observable}, then invokes the
      *         {@code Action}
+     * @throws NullPointerException if {@code onAfterTerminate} is {@code null}
      * @see ReactiveX operators documentation: Do
      * @see #doOnTerminate(Action)
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
     @NonNull
-    public final Observable doAfterTerminate(@NonNull Action onFinally) {
-        Objects.requireNonNull(onFinally, "onFinally is null");
-        return doOnEach(Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, onFinally);
+    public final Observable doAfterTerminate(@NonNull Action onAfterTerminate) {
+        Objects.requireNonNull(onAfterTerminate, "onAfterTerminate is null");
+        return doOnEach(Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, onAfterTerminate);
     }
 
     /**
@@ -8104,6 +8326,7 @@ public final Observable doAfterTerminate(@NonNull Action onFinally) {
      * 
History: 2.0.1 - experimental
      * @param onFinally the action called when the current {@code Observable} terminates or gets disposed
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code onFinally} is {@code null}
      * @since 2.1
      */
     @CheckReturnValue
@@ -8154,6 +8377,7 @@ public final Observable doOnDispose(@NonNull Action onDispose) {
      * @param onComplete
      *            the action to invoke when the current {@code Observable} calls {@code onComplete}
      * @return the current {@code Observable} with the side-effecting behavior applied
+     * @throws NullPointerException if {@code onComplete} is {@code null}
      * @see ReactiveX operators documentation: Do
      */
     @CheckReturnValue
@@ -8174,6 +8398,7 @@ public final Observable doOnComplete(@NonNull Action onComplete) {
      *
* * @return the current {@code Observable} with the side-effecting behavior applied + * @throws NullPointerException if {@code onNext}, {@code onError}, {@code onComplete} or {@code onAfterTerminate} is {@code null} * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8200,6 +8425,7 @@ private Observable doOnEach(@NonNull Consumer onNext, @NonNull Con * @param onNotification * the action to invoke for each item emitted by the current {@code Observable} * @return the current {@code Observable} with the side-effecting behavior applied + * @throws NullPointerException if {@code onNotification} is {@code null} * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8234,6 +8460,7 @@ public final Observable doOnEach(@NonNull Consumer> o * the observer to be notified about {@code onNext}, {@code onError} and {@code onComplete} events on its * respective methods before the actual downstream {@code Observer} gets notified. * @return the current {@code Observable} with the side-effecting behavior applied + * @throws NullPointerException if {@code observer} is {@code null} * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8263,6 +8490,7 @@ public final Observable doOnEach(@NonNull Observer observer) { * @param onError * the action to invoke if the current {@code Observable} calls {@code onError} * @return the current {@code Observable} with the side-effecting behavior applied + * @throws NullPointerException if {@code onError} is {@code null} * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8287,6 +8515,7 @@ public final Observable doOnError(@NonNull Consumer onErro * @param onDispose * called when the downstream disposes the {@code Disposable} via {@code dispose()} * @return the current {@code Observable} with the side-effecting behavior applied + * @throws NullPointerException if {@code onSubscribe} or {@code onDispose} is {@code null} * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8310,6 +8539,7 @@ public final Observable doOnLifecycle(@NonNull Consumer o * @param onNext * the action to invoke when the current {@code Observable} calls {@code onNext} * @return the current {@code Observable} with the side-effecting behavior applied + * @throws NullPointerException if {@code onNext} is {@code null} * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8334,6 +8564,7 @@ public final Observable doOnNext(@NonNull Consumer onNext) { * @param onSubscribe * the {@code Consumer} that gets called when an {@code Observer} subscribes to the current {@code Observable} * @return the current {@code Observable} modified so as to call this {@code Consumer} whenever it gets subscribed + * @throws NullPointerException if {@code onSubscribe} is {@code null} * @see ReactiveX operators documentation: Do */ @CheckReturnValue @@ -8359,6 +8590,7 @@ public final Observable doOnSubscribe(@NonNull Consumer o * @param onTerminate * the action to invoke when the current {@code Observable} calls {@code onComplete} or {@code onError} * @return the current {@code Observable} with the side-effecting behavior applied + * @throws NullPointerException if {@code onTerminate} is {@code null} * @see ReactiveX operators documentation: Do * @see #doAfterTerminate(Action) */ @@ -8387,7 +8619,7 @@ public final Observable doOnTerminate(@NonNull Action onTerminate) { * @return a {@code Maybe} that emits a single item: the item at the specified position in the sequence of * those emitted by the current {@code Observable} * @throws IndexOutOfBoundsException - * if {@code index} is less than 0 + * if {@code index} is negative * @see ReactiveX operators documentation: ElementAt */ @CheckReturnValue @@ -8416,8 +8648,9 @@ public final Maybe elementAt(long index) { * the default item * @return a {@code Single} that emits the item at the specified position in the sequence emitted by the current * {@code Observable}, or the default item if that index is outside the bounds of the source sequence + * @throws NullPointerException if {@code defaultItem} is {@code null} * @throws IndexOutOfBoundsException - * if {@code index} is less than 0 + * if {@code index} is negative * @see ReactiveX operators documentation: ElementAt */ @CheckReturnValue @@ -8446,7 +8679,7 @@ public final Single elementAt(long index, @NonNull T defaultItem) { * @return a {@code Single} that emits the item at the specified position in the sequence emitted by the current * {@code Observable}, or the default item if that index is outside the bounds of the source sequence * @throws IndexOutOfBoundsException - * if {@code index} is less than 0 + * if {@code index} is negative * @see ReactiveX operators documentation: ElementAt */ @CheckReturnValue @@ -8473,6 +8706,7 @@ public final Single elementAtOrError(long index) { * if it passes the filter * @return an {@code Observable} that emits only those items emitted by the current {@code Observable} that the filter * evaluates as {@code true} + * @throws NullPointerException if {@code predicate} is {@code null} * @see ReactiveX operators documentation: Filter */ @CheckReturnValue @@ -8516,6 +8750,7 @@ public final Maybe firstElement() { * @param defaultItem * the default item to emit if the current {@code Observable} doesn't emit anything * @return the new {@code Single} instance + * @throws NullPointerException if {@code defaultItem} is {@code null} * @see ReactiveX operators documentation: First */ @CheckReturnValue @@ -8563,6 +8798,7 @@ public final Single firstOrError() { * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted * by the current {@code Observable} and merging the results of the {@code ObservableSource}s obtained from this * transformation + * @throws NullPointerException if {@code mapper} is {@code null} * @see ReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -8593,6 +8829,7 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -8626,6 +8863,8 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8658,10 +8897,12 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8706,6 +8947,7 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -8746,6 +8988,8 @@ public final Observable flatMap( * the maximum number of {@code ObservableSource}s that may be subscribed to concurrently * @return an {@code Observable} that emits the results of merging the {@code ObservableSource}s returned from applying the * specified functions to the emissions and notifications of the current {@code Observable} + * @throws NullPointerException if {@code onNextMapper} or {@code onErrorMapper} or {@code onCompleteSupplier} is {@code null} + * @throws IllegalArgumentException if {@code maxConcurrency} is non-positive * @see ReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8784,6 +9028,8 @@ public final Observable flatMap( * @return an {@code Observable} that emits the result of applying the transformation function to each item emitted * by the current {@code Observable} and merging the results of the {@code ObservableSource}s obtained from this * transformation + * @throws NullPointerException if {@code mapper} is {@code null} + * @throws IllegalArgumentException if {@code maxConcurrency} is non-positive * @see ReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8810,19 +9056,20 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @NonNull public final Observable flatMap(@NonNull Function> mapper, - @NonNull BiFunction resultSelector) { - return flatMap(mapper, resultSelector, false, bufferSize(), bufferSize()); + @NonNull BiFunction combiner) { + return flatMap(mapper, combiner, false, bufferSize(), bufferSize()); } /** @@ -8849,6 +9096,7 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -8886,6 +9134,8 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8923,9 +9173,11 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8963,6 +9215,8 @@ public final Observable flatMap(@NonNull FunctionReactiveX operators documentation: FlatMap * @since 2.0 */ @@ -8984,6 +9238,7 @@ public final Observable flatMap(@NonNull Function{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}. *
* @param mapper the function that received each source value and transforms them into {@code CompletableSource}s. + * @throws NullPointerException if {@code mapper} is {@code null} * @return the new {@link Completable} instance */ @CheckReturnValue @@ -9006,6 +9261,7 @@ public final Completable flatMapCompletable(@NonNull FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue @@ -9060,20 +9317,21 @@ public final Observable flatMapIterable(@NonNull FunctionReactiveX operators documentation: FlatMap */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @NonNull public final Observable flatMapIterable(@NonNull Function> mapper, - @NonNull BiFunction resultSelector) { + @NonNull BiFunction combiner) { Objects.requireNonNull(mapper, "mapper is null"); - Objects.requireNonNull(resultSelector, "resultSelector is null"); - return flatMap(ObservableInternalHelper.flatMapIntoIterable(mapper), resultSelector, false, bufferSize(), bufferSize()); + Objects.requireNonNull(combiner, "combiner is null"); + return flatMap(ObservableInternalHelper.flatMapIntoIterable(mapper), combiner, false, bufferSize(), bufferSize()); } /** @@ -9088,6 +9346,7 @@ public final Observable flatMapIterable(@NonNull Function the result value type * @param mapper the function that received each source value and transforms them into {@code MaybeSource}s. * @return the new {@code Observable} instance + * @throws NullPointerException if {@code mapper} is {@code null} */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -9111,6 +9370,7 @@ public final Observable flatMapMaybe(@NonNull Function Observable flatMapMaybe(@NonNull Function the result value type * @param mapper the function that received each source value and transforms them into {@code SingleSource}s. * @return the new {@code Observable} instance + * @throws NullPointerException if {@code mapper} is {@code null} */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -9155,6 +9416,7 @@ public final Observable flatMapSingle(@NonNull Function onNext, @NonN * @return an {@code Observable} that emits {@code GroupedObservable}s, each of which corresponds to a * unique key value and each of which emits those items from the current {@code Observable} that share that * key value + * @throws NullPointerException if {@code keySelector} is {@code null} * @see ReactiveX operators documentation: GroupBy */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -9359,6 +9622,7 @@ public final Observable> groupBy(@NonNull FunctionReactiveX operators documentation: GroupBy */ @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -9406,6 +9670,7 @@ public final Observable> groupBy(@NonNull FunctionReactiveX operators documentation: GroupBy */ @CheckReturnValue @@ -9508,6 +9773,8 @@ public final Observable> groupBy(@NonNull Functio * @return an {@code Observable} that emits {@code GroupedObservable}s, each of which corresponds to a * unique key value and each of which emits those items from the current {@code Observable} that share that * key value + * @throws NullPointerException if {@code keySelector} or {@code valueSelector} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: GroupBy */ @CheckReturnValue @@ -9552,6 +9819,7 @@ public final Observable> groupBy(@NonNull Functio * by the resulting {@code Observable} * @return an {@code Observable} that emits items based on combining those items emitted by the current {@code Observable}s * whose durations overlap + * @throws NullPointerException if {@code other}, {@code leftEnd}, {@code rightEnd} or {@code resultSelector} is {@code null} * @see ReactiveX operators documentation: Join */ @CheckReturnValue @@ -9664,6 +9932,7 @@ public final Single isEmpty() { * overlapping items emitted by the two {@code ObservableSource}s * @return an {@code Observable} that emits items correlating to items emitted by the current {@code Observable}s that have * overlapping durations + * @throws NullPointerException if {@code other}, {@code leftEnd}, {@code rightEnd} or {@code resultSelector} is {@code null} * @see ReactiveX operators documentation: Join */ @CheckReturnValue @@ -9718,6 +9987,7 @@ public final Maybe lastElement() { * the default item to emit if the current {@code Observable} is empty * @return a {@code Single} that emits only the last item emitted by the current {@code Observable}, or a default item * if the current {@code Observable} is empty + * @throws NullPointerException if {@code defaultItem} is {@code null} * @see ReactiveX operators documentation: Last */ @CheckReturnValue @@ -9888,6 +10158,7 @@ public final Single lastOrError() { * an {@code Observer} with custom behavior to be used as the consumer for the current * {@code Observable}. * @return the new {@code Observable} instance + * @throws NullPointerException if {@code lifter} is {@code null} * @see RxJava wiki: Writing operators * @see #compose(ObservableTransformer) */ @@ -9914,6 +10185,7 @@ public final Observable lift(@NonNull ObservableOperatorReactiveX operators documentation: Map */ @CheckReturnValue @@ -9961,6 +10233,7 @@ public final Observable> materialize() { * @param other * an {@code ObservableSource} to be merged * @return an {@code Observable} that emits all of the items emitted by the current {@code Observable}s + * @throws NullPointerException if {@code other} is {@code null} * @see ReactiveX operators documentation: Merge */ @CheckReturnValue @@ -9985,6 +10258,7 @@ public final Observable mergeWith(@NonNull ObservableSource othe *

History: 2.1.10 - experimental * @param other the {@code SingleSource} whose success value to merge with * @return the new {@code Observable} instance + * @throws NullPointerException if {@code other} is {@code null} * @since 2.2 */ @CheckReturnValue @@ -10010,6 +10284,7 @@ public final Observable mergeWith(@NonNull SingleSource other) { *

History: 2.1.10 - experimental * @param other the {@code MaybeSource} which provides a success value to merge with or completes * @return the new {@code Observable} instance + * @throws NullPointerException if {@code other} is {@code null} * @since 2.2 */ @CheckReturnValue @@ -10032,6 +10307,7 @@ public final Observable mergeWith(@NonNull MaybeSource other) { *

History: 2.1.10 - experimental * @param other the {@code CompletableSource} to await for completion * @return the new {@code Observable} instance + * @throws NullPointerException if {@code other} is {@code null} * @since 2.2 */ @CheckReturnValue @@ -10066,6 +10342,7 @@ public final Observable mergeWith(@NonNull CompletableSource other) { * the {@code Scheduler} to notify {@link Observer}s on * @return the current {@code Observable} modified so that its {@code Observer}s are notified on the specified * {@code Scheduler} + * @throws NullPointerException if {@code scheduler} is {@code null} * @see ReactiveX operators documentation: ObserveOn * @see RxJava Threading Examples * @see #subscribeOn @@ -10145,6 +10422,8 @@ public final Observable observeOn(@NonNull Scheduler scheduler, boolean delay * @param bufferSize the size of the buffer. * @return the current {@code Observable} modified so that its {@code Observer}s are notified on the specified * {@code Scheduler} + * @throws NullPointerException if {@code scheduler} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: ObserveOn * @see RxJava Threading Examples * @see #subscribeOn @@ -10174,6 +10453,7 @@ public final Observable observeOn(@NonNull Scheduler scheduler, boolean delay * @param clazz * the class type to filter the items emitted by the current {@code Observable} * @return an {@code Observable} that emits items from the current {@code Observable} of type {@code clazz} + * @throws NullPointerException if {@code clazz} is {@code null} * @see ReactiveX operators documentation: Filter */ @CheckReturnValue @@ -10211,6 +10491,7 @@ public final Observable ofType(@NonNull Class clazz) { * a function that returns an {@code ObservableSource} that will take over if the current {@code Observable} encounters * an error * @return the original {@code ObservableSource}, with appropriately modified behavior + * @throws NullPointerException if {@code resumeFunction} is {@code null} * @see ReactiveX operators documentation: Catch */ @CheckReturnValue @@ -10248,6 +10529,7 @@ public final Observable onErrorResumeNext(@NonNull FunctionReactiveX operators documentation: Catch */ @CheckReturnValue @@ -10282,6 +10564,7 @@ public final Observable onErrorResumeWith(@NonNull ObservableSourceReactiveX operators documentation: Catch */ @CheckReturnValue @@ -10316,6 +10599,7 @@ public final Observable onErrorReturn(@NonNull FunctionReactiveX operators documentation: Catch */ @CheckReturnValue @@ -10386,6 +10670,7 @@ public final ConnectableObservable publish() { * receive all notifications of the source from the time of the subscription forward. * @return an {@code Observable} that emits the results of invoking the selector on the items * emitted by a {@code ConnectableObservable} that shares a single subscription to the underlying sequence + * @throws NullPointerException if {@code selector} is {@code null} * @see ReactiveX operators documentation: Publish */ @CheckReturnValue @@ -10397,7 +10682,7 @@ public final Observable publish(@NonNull Function, } /** - * Returns a Maybe that applies a specified accumulator function to the first item emitted by the current + * Returns a {@link Maybe} that applies a specified accumulator function to the first item emitted by the current * {@code Observable}, then feeds the result of that function along with the second item emitted by the current * {@code Observable} into the same function, and so on until all items have been emitted by the current and finite {@code Observable}, * and emits the final result from the final call to your function as its sole item. @@ -10410,7 +10695,7 @@ public final Observable publish(@NonNull Function, *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulator object to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code reduce} does not operate by default on a particular {@link Scheduler}.
@@ -10419,8 +10704,9 @@ public final Observable publish(@NonNull Function, * @param reducer * an accumulator function to be invoked on each item emitted by the current {@code Observable}, whose * result will be used in the next accumulator call - * @return a Maybe that emits a single item that is the result of accumulating the items emitted by + * @return a {@code Maybe} that emits a single item that is the result of accumulating the items emitted by * the current {@code Observable} + * @throws NullPointerException if {@code reducer} is {@code null} * @see ReactiveX operators documentation: Reduce * @see Wikipedia: Fold (higher-order function) */ @@ -10464,7 +10750,7 @@ public final Maybe reduce(@NonNull BiFunction reducer) { *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulator object to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code reduce} does not operate by default on a particular {@link Scheduler}.
@@ -10476,8 +10762,9 @@ public final Maybe reduce(@NonNull BiFunction reducer) { * @param reducer * an accumulator function to be invoked on each item emitted by the current {@code Observable}, the * result of which will be used in the next accumulator call - * @return a Single that emits a single item that is the result of accumulating the output from the + * @return a {@code Single} that emits a single item that is the result of accumulating the output from the * items emitted by the current {@code Observable} + * @throws NullPointerException if {@code seed} or {@code reducer} is {@code null} * @see ReactiveX operators documentation: Reduce * @see Wikipedia: Fold (higher-order function) * @see #reduceWith(Supplier, BiFunction) @@ -10492,8 +10779,8 @@ public final Maybe reduce(@NonNull BiFunction reducer) { } /** - * Returns a Single that applies a specified accumulator function to the first item emitted by the current - * {@code Observable} and a seed value derived from calling a specified seedSupplier, then feeds the result + * Returns a {@link Single} that applies a specified accumulator function to the first item emitted by the current + * {@code Observable} and a seed value derived from calling a specified {@code seedSupplier}, then feeds the result * of that function along with the second item emitted by the current {@code Observable} into the same function, * and so on until all items have been emitted by the current and finite {@code Observable}, emitting the final result * from the final call to your function as its sole item. @@ -10506,7 +10793,7 @@ public final Maybe reduce(@NonNull BiFunction reducer) { *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulator object to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code reduceWith} does not operate by default on a particular {@link Scheduler}.
@@ -10514,12 +10801,13 @@ public final Maybe reduce(@NonNull BiFunction reducer) { * * @param the accumulator and output value type * @param seedSupplier - * the Supplier that provides the initial (seed) accumulator value for each individual Observer + * the {@link Supplier} that provides the initial (seed) accumulator value for each individual {@link Observer} * @param reducer * an accumulator function to be invoked on each item emitted by the current {@code Observable}, the * result of which will be used in the next accumulator call - * @return a Single that emits a single item that is the result of accumulating the output from the + * @return a {@code Single} that emits a single item that is the result of accumulating the output from the * items emitted by the current {@code Observable} + * @throws NullPointerException if {@code seedSupplier} or {@code reducer} is {@code null} * @see ReactiveX operators documentation: Reduce * @see Wikipedia: Fold (higher-order function) */ @@ -10567,7 +10855,7 @@ public final Observable repeat() { * @return an {@code Observable} that repeats the sequence of items emitted by the current {@code Observable} at most * {@code count} times * @throws IllegalArgumentException - * if {@code count} is less than zero + * if {@code count} is negative * @see ReactiveX operators documentation: Repeat */ @CheckReturnValue @@ -10585,7 +10873,7 @@ public final Observable repeat(long times) { /** * Returns an {@code Observable} that repeats the sequence of items emitted by the current {@code Observable} until - * the provided stop function returns true. + * the provided stop function returns {@code true}. *

* *

@@ -10599,7 +10887,7 @@ public final Observable repeat(long times) { * the current {@code Observable} is resubscribed. * @return the new {@code Observable} instance * @throws NullPointerException - * if {@code stop} is null + * if {@code stop} is {@code null} * @see ReactiveX operators documentation: Repeat */ @CheckReturnValue @@ -10613,7 +10901,7 @@ public final Observable repeatUntil(@NonNull BooleanSupplier stop) { /** * Returns an {@code Observable} that emits the same values as the current {@code Observable} with the exception of an * {@code onComplete}. An {@code onComplete} notification from the source will result in the emission of - * a {@code void} item to the {@code ObservableSource} provided as an argument to the {@code notificationHandler} + * a {@code void} item to the {@link ObservableSource} provided as an argument to the {@code notificationHandler} * function. If that {@code ObservableSource} calls {@code onComplete} or {@code onError} then {@code repeatWhen} will * call {@code onComplete} or {@code onError} on the child subscription. Otherwise, the current {@code Observable} * will be resubscribed. @@ -10626,7 +10914,8 @@ public final Observable repeatUntil(@NonNull BooleanSupplier stop) { * * @param handler * receives an {@code ObservableSource} of notifications with which a user can complete or error, aborting the repeat. - * @return the current {@code Observable} modified with repeat logic + * @return the new {@code Observable} instance + * @throws NullPointerException if {@code handler} is {@code null} * @see ReactiveX operators documentation: Repeat */ @CheckReturnValue @@ -10638,9 +10927,9 @@ public final Observable repeatWhen(@NonNull Function * @@ -10649,8 +10938,8 @@ public final Observable repeatWhen(@NonNull FunctionThis version of {@code replay} does not operate by default on a particular {@link Scheduler}. *
* - * @return a {@link ConnectableObservable} that upon connection causes the current {@code Observable} to emit its - * items to its {@link Observer}s + * @return a {@code ConnectableObservable} that upon connection causes the current {@code Observable} to emit its + * items to its {@code Observer}s * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -10674,9 +10963,10 @@ public final ConnectableObservable replay() { * the type of items emitted by the resulting {@code Observable} * @param selector * the selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @return an {@code Observable} that emits items that are the results of invoking the selector on a - * {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} + * {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} + * @throws NullPointerException if {@code selector} is {@code null} * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -10705,12 +10995,14 @@ public final Observable replay(@NonNull Function, ? * the type of items emitted by the resulting {@code Observable} * @param selector * the selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @param bufferSize - * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay + * the buffer size that limits the number of items the connectable {@code Observable} can replay * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} + * a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} * replaying no more than {@code bufferSize} items + * @throws NullPointerException if {@code selector} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay * @see #replay(Function, int, boolean) */ @@ -10741,15 +11033,17 @@ public final Observable replay(@NonNull Function, ? * the type of items emitted by the resulting {@code Observable} * @param selector * the selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @param bufferSize - * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay + * the buffer size that limits the number of items the connectable {@code Observable} can replay * @param eagerTruncate * if {@code true}, whenever the internal buffer is truncated to the given bufferSize, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} + * a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} * replaying no more than {@code bufferSize} items + * @throws NullPointerException if {@code selector} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -10779,17 +11073,19 @@ public final Observable replay(@NonNull Function, ? * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @param bufferSize - * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay + * the buffer size that limits the number of items the connectable {@code Observable} can replay * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, and + * a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable}, and * replays no more than {@code bufferSize} items that were emitted within the window defined by * {@code time} + * @throws NullPointerException if {@code selector} or {@code unit} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -10817,21 +11113,23 @@ public final Observable replay(@NonNull Function, ? * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @param bufferSize - * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay + * the buffer size that limits the number of items the connectable {@code Observable} can replay * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @param scheduler - * the Scheduler that is the time source for the window + * the {@code Scheduler} that is the time source for the window * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, and + * a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable}, and * replays no more than {@code bufferSize} items that were emitted within the window defined by * {@code time} * @throws IllegalArgumentException - * if {@code bufferSize} is less than zero + * if {@code bufferSize} is non-positive + * @throws NullPointerException if {@code selector}, {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay * @see #replay(Function, int, long, TimeUnit, Scheduler, boolean) */ @@ -10846,6 +11144,7 @@ public final Observable replay(@NonNull Function, ? return ObservableReplay.multicastSelector( ObservableInternalHelper.replaySupplier(this, bufferSize, time, unit, scheduler, false), selector); } + /** * Returns an {@code Observable} that emits items that are the results of invoking a specified selector on items * emitted by a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, @@ -10864,24 +11163,25 @@ public final Observable replay(@NonNull Function, ? * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @param bufferSize - * the buffer size that limits the number of items the connectable {@code ObservableSource} can replay + * the buffer size that limits the number of items the connectable {@code Observable} can replay * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @param scheduler - * the Scheduler that is the time source for the window + * the {@code Scheduler} that is the time source for the window * @param eagerTruncate * if {@code true}, whenever the internal buffer is truncated to the given bufferSize/age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, and + * a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable}, and * replays no more than {@code bufferSize} items that were emitted within the window defined by * {@code time} + * @throws NullPointerException if {@code selector}, {@code unit} or {@code scheduler} is {@code null} * @throws IllegalArgumentException - * if {@code bufferSize} is less than zero + * if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -10911,14 +11211,15 @@ public final Observable replay(@NonNull Function, ? * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @param time * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, + * a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within the window defined by {@code time} + * @throws NullPointerException if {@code selector} or {@code unit} is {@code null} * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -10943,7 +11244,7 @@ public final Observable replay(@NonNull Function, ? * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @param time * the duration of the window in which the replayed items must have been emitted * @param unit @@ -10951,8 +11252,9 @@ public final Observable replay(@NonNull Function, ? * @param scheduler * the scheduler that is the time source for the window * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, + * a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within the window defined by {@code time} + * @throws NullPointerException if {@code selector}, {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Replay * @see #replay(Function, long, TimeUnit, Scheduler, boolean) */ @@ -10981,7 +11283,7 @@ public final Observable replay(@NonNull Function, ? * the type of items emitted by the resulting {@code Observable} * @param selector * a selector function, which can use the multicasted sequence as many times as needed, without - * causing multiple subscriptions to the {@code ObservableSource} + * causing multiple subscriptions to the current {@code Observable} * @param time * the duration of the window in which the replayed items must have been emitted * @param unit @@ -10992,8 +11294,9 @@ public final Observable replay(@NonNull Function, ? * if {@code true}, whenever the internal buffer is truncated to the given age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention * @return an {@code Observable} that emits items that are the results of invoking the selector on items emitted by - * a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable}, + * a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable}, * replaying all items that were emitted within the window defined by {@code time} + * @throws NullPointerException if {@code selector}, {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -11008,8 +11311,8 @@ public final Observable replay(@NonNull Function, ? /** * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} that - * replays at most {@code bufferSize} items emitted by that ObservableSource. A Connectable {@code ObservableSource} resembles - * an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, but only + * replays at most {@code bufferSize} items emitted by the current {@code Observable}. A connectable {@code Observable} resembles + * an ordinary {@code Observable}, except that it does not begin emitting items when it is subscribed to, but only * when its {@code connect} method is called. *

* @@ -11025,8 +11328,9 @@ public final Observable replay(@NonNull Function, ? * * @param bufferSize * the buffer size that limits the number of items that can be replayed - * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and - * replays at most {@code bufferSize} items emitted by that {@code ObservableSource} + * @return a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * replays at most {@code bufferSize} items emitted by the current {@code Observable} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay * @see #replay(int, boolean) */ @@ -11040,8 +11344,8 @@ public final ConnectableObservable replay(int bufferSize) { /** * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} that - * replays at most {@code bufferSize} items emitted by that ObservableSource. A Connectable {@code ObservableSource} resembles - * an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, but only + * replays at most {@code bufferSize} items emitted by the current {@code Observable}. A connectable {@code Observable} resembles + * an ordinary {@code Observable}, except that it does not begin emitting items when it is subscribed to, but only * when its {@code connect} method is called. *

* @@ -11059,8 +11363,9 @@ public final ConnectableObservable replay(int bufferSize) { * @param eagerTruncate * if {@code true}, whenever the internal buffer is truncated to the given bufferSize/age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention - * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and - * replays at most {@code bufferSize} items emitted by that {@code ObservableSource} + * @return a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * replays at most {@code bufferSize} items emitted by the current {@code Observable} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -11073,8 +11378,8 @@ public final ConnectableObservable replay(int bufferSize, boolean eagerTrunca /** * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and - * replays at most {@code bufferSize} items that were emitted during a specified time window. A Connectable - * {@code ObservableSource} resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is + * replays at most {@code bufferSize} items that were emitted during a specified time window. A connectable + * {@code Observable} resembles an ordinary {@code Observable}, except that it does not begin emitting items when it is * subscribed to, but only when its {@code connect} method is called. *

* @@ -11094,9 +11399,11 @@ public final ConnectableObservable replay(int bufferSize, boolean eagerTrunca * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} - * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * @return a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays at most {@code bufferSize} items that were emitted during the window defined by * {@code time} + * @throws NullPointerException if {@code unit} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay * @see #replay(int, long, TimeUnit, Scheduler, boolean) */ @@ -11110,7 +11417,7 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull /** * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * that replays a maximum of {@code bufferSize} items that are emitted within a specified time window. A - * Connectable {@code ObservableSource} resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items + * connectable {@code Observable} resembles an ordinary {@code Observable}, except that it does not begin emitting items * when it is subscribed to, but only when its {@code connect} method is called. *

* Note that due to concurrency requirements, {@code replay(bufferSize)} may hold strong references to more than @@ -11132,11 +11439,12 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull * the time unit of {@code time} * @param scheduler * the scheduler that is used as a time source for the window - * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * @return a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays at most {@code bufferSize} items that were emitted during the window defined by * {@code time} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @throws IllegalArgumentException - * if {@code bufferSize} is less than zero + * if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay * @see #replay(int, long, TimeUnit, Scheduler, boolean) */ @@ -11153,7 +11461,7 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull /** * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and * that replays a maximum of {@code bufferSize} items that are emitted within a specified time window. A - * Connectable {@code ObservableSource} resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items + * connectable {@code Observable} resembles an ordinary {@code Observable}, except that it does not begin emitting items * when it is subscribed to, but only when its {@code connect} method is called. *

* @@ -11175,14 +11483,15 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull * the time unit of {@code time} * @param scheduler * the scheduler that is used as a time source for the window - * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * @return a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays at most {@code bufferSize} items that were emitted during the window defined by * {@code time} * @param eagerTruncate * if {@code true}, whenever the internal buffer is truncated to the given bufferSize/age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @throws IllegalArgumentException - * if {@code bufferSize} is less than zero + * if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -11197,8 +11506,8 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull /** * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and - * replays all items emitted by that {@code ObservableSource} within a specified time window. A Connectable {@code ObservableSource} - * resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, + * replays all items emitted by the current {@code Observable} within a specified time window. A connectable {@code Observable} + * resembles an ordinary {@code Observable}, except that it does not begin emitting items when it is subscribed to, * but only when its {@code connect} method is called. *

* @@ -11211,8 +11520,9 @@ public final ConnectableObservable replay(int bufferSize, long time, @NonNull * the duration of the window in which the replayed items must have been emitted * @param unit * the time unit of {@code time} - * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * @return a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays the items that were emitted during the window defined by {@code time} + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -11224,8 +11534,8 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit) /** * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and - * replays all items emitted by that {@code ObservableSource} within a specified time window. A Connectable {@code ObservableSource} - * resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, + * replays all items emitted by the current {@code Observable} within a specified time window. A connectable {@code Observable} + * resembles an ordinary {@code Observable}, except that it does not begin emitting items when it is subscribed to, * but only when its {@code connect} method is called. *

* @@ -11242,9 +11552,10 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit) * @param unit * the time unit of {@code time} * @param scheduler - * the Scheduler that is the time source for the window - * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * the {@code Scheduler} that is the time source for the window + * @return a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays the items that were emitted during the window defined by {@code time} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Replay * @see #replay(long, TimeUnit, Scheduler, boolean) */ @@ -11259,8 +11570,8 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit, /** * Returns a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and - * replays all items emitted by that {@code ObservableSource} within a specified time window. A Connectable {@code ObservableSource} - * resembles an ordinary {@code ObservableSource}, except that it does not begin emitting items when it is subscribed to, + * replays all items emitted by the current {@code Observable} within a specified time window. A connectable {@code Observable} + * resembles an ordinary {@code Observable}, except that it does not begin emitting items when it is subscribed to, * but only when its {@code connect} method is called. *

* @@ -11277,12 +11588,13 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit, * @param unit * the time unit of {@code time} * @param scheduler - * the Scheduler that is the time source for the window + * the {@code Scheduler} that is the time source for the window * @param eagerTruncate * if {@code true}, whenever the internal buffer is truncated to the given bufferSize/age, the * oldest item will be guaranteed dereferenced, thus avoiding unexpected retention - * @return a {@link ConnectableObservable} that shares a single subscription to the current {@code Observable} and + * @return a {@code ConnectableObservable} that shares a single subscription to the current {@code Observable} and * replays the items that were emitted during the window defined by {@code time} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Replay */ @CheckReturnValue @@ -11304,7 +11616,7 @@ public final ConnectableObservable replay(long time, @NonNull TimeUnit unit, * {@code Observable} rather than propagating the {@code onError} call. *

* Any and all items emitted by the current {@code Observable} will be emitted by the resulting {@code Observable}, even - * those emitted during failed subscriptions. For example, if an {@code ObservableSource} fails at first but emits + * those emitted during failed subscriptions. For example, if the current {@code Observable} fails at first but emits * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onComplete]}. *

@@ -11324,7 +11636,7 @@ public final Observable retry() { /** * Returns an {@code Observable} that mirrors the current {@code Observable}, resubscribing to it if it calls {@code onError} - * and the predicate returns true for that specific exception and retry count. + * and the predicate returns {@code true} for that specific exception and retry count. *

* *

@@ -11336,6 +11648,7 @@ public final Observable retry() { * the predicate that determines if a resubscription may happen in case of a specific exception * and retry count * @return the current {@code Observable} modified with retry logic + * @throws NullPointerException if {@code predicate} is {@code null} * @see #retry() * @see ReactiveX operators documentation: Retry */ @@ -11359,7 +11672,7 @@ public final Observable retry(@NonNull BiPredicate * Any and all items emitted by the current {@code Observable} will be emitted by the resulting {@code Observable}, even - * those emitted during failed subscriptions. For example, if an {@code ObservableSource} fails at first but emits + * those emitted during failed subscriptions. For example, if the current {@code Observable} fails at first but emits * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onComplete]}. *
@@ -11370,6 +11683,7 @@ public final Observable retry(@NonNull BiPredicateReactiveX operators documentation: Retry */ @CheckReturnValue @@ -11388,7 +11702,9 @@ public final Observable retry(long times) { *
{@code retry} does not operate by default on a particular {@link Scheduler}.
*
* @param times the number of times to resubscribe if the current {@code Observable} fails - * @param predicate the predicate called with the failure Throwable and should return true to trigger a retry. + * @param predicate the predicate called with the failure {@link Throwable} and should return {@code true} to trigger a retry. + * @throws NullPointerException if {@code predicate} is {@code null} + * @throws IllegalArgumentException if {@code times} is negative * @return the new {@code Observable} instance */ @CheckReturnValue @@ -11404,7 +11720,7 @@ public final Observable retry(long times, @NonNull Predicate * *
@@ -11412,8 +11728,9 @@ public final Observable retry(long times, @NonNull Predicate{@code retry} does not operate by default on a particular {@link Scheduler}. *
* - * @param predicate the predicate that receives the failure Throwable and should return true to trigger a retry. + * @param predicate the predicate that receives the failure {@link Throwable} and should return {@code true} to trigger a retry. * @return the new {@code Observable} instance + * @throws NullPointerException if {@code predicate} is {@code null} */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -11423,15 +11740,16 @@ public final Observable retry(@NonNull Predicate predicate } /** - * Retries until the given stop function returns true. + * Retries until the given stop function returns {@code true}. *

* *

*
Scheduler:
*
{@code retryUntil} does not operate by default on a particular {@link Scheduler}.
*
- * @param stop the function that should return true to stop retrying + * @param stop the function that should return {@code true} to stop retrying * @return the new {@code Observable} instance + * @throws NullPointerException if {@code stop} is {@code null} */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -11444,8 +11762,8 @@ public final Observable retryUntil(@NonNull BooleanSupplier stop) { /** * Returns an {@code Observable} that emits the same values as the current {@code Observable} with the exception of an * {@code onError}. An {@code onError} notification from the source will result in the emission of a - * {@link Throwable} item to the {@code ObservableSource} provided as an argument to the {@code notificationHandler} - * function. If that {@code ObservableSource} calls {@code onComplete} or {@code onError} then {@code retry} will call + * {@link Throwable} item to the {@code Observable} provided as an argument to the {@code notificationHandler} + * function. If that {@code Observable} calls {@code onComplete} or {@code onError} then {@code retry} will call * {@code onComplete} or {@code onError} on the child subscription. Otherwise, the current {@code Observable} * will be resubscribed. *

@@ -11479,10 +11797,10 @@ public final Observable retryUntil(@NonNull BooleanSupplier stop) { * subscribing * } *

- * Note that the inner {@code ObservableSource} returned by the handler function should signal + * Note that the inner {@link ObservableSource} returned by the handler function should signal * either {@code onNext}, {@code onError} or {@code onComplete} in response to the received * {@code Throwable} to indicate the operator should retry or terminate. If the upstream to - * the operator is asynchronous, signaling {@code onNext} followed by onComplete immediately may + * the operator is asynchronous, signaling {@code onNext} followed by {@code onComplete} immediately may * result in the sequence to be completed immediately. Similarly, if this inner * {@code ObservableSource} signals {@code onError} or {@code onComplete} while the upstream is * active, the sequence is terminated with the same signal immediately. @@ -11509,9 +11827,10 @@ public final Observable retryUntil(@NonNull BooleanSupplier stop) { *

* * @param handler - * receives an {@code ObservableSource} of notifications with which a user can complete or error, aborting the + * receives an {@code Observable} of notifications with which a user can complete or error, aborting the * retry * @return the current {@code Observable} modified with retry logic + * @throws NullPointerException if {@code handler} is {@code null} * @see ReactiveX operators documentation: Retry */ @CheckReturnValue @@ -11524,16 +11843,16 @@ public final Observable retryWhen( } /** - * Subscribes to the current {@code Observable} and wraps the given {@code Observer} into a SafeObserver - * (if not already a SafeObserver) that + * Subscribes to the current {@code Observable} and wraps the given {@link Observer} into a {@link SafeObserver} + * (if not already a {@code SafeObserver}) that * deals with exceptions thrown by a misbehaving {@code Observer} (that doesn't follow the - * Reactive-Streams specification). + * Reactive Streams specification). *
*
Scheduler:
*
{@code safeSubscribe} does not operate by default on a particular {@link Scheduler}.
*
* @param observer the incoming {@code Observer} instance - * @throws NullPointerException if s is null + * @throws NullPointerException if {@code observer} is {@code null} */ @SchedulerSupport(SchedulerSupport.NONE) @NonNull @@ -11562,6 +11881,7 @@ public final void safeSubscribe(@NonNull Observer observer) { * the {@link TimeUnit} in which {@code period} is defined * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} at * the specified time interval + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Sample * @see #throttleLast(long, TimeUnit) */ @@ -11590,7 +11910,7 @@ public final Observable sample(long period, @NonNull TimeUnit unit) { * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} at * the specified time interval * @param emitLast - * if true and the upstream completes while there is still an unsampled item available, + * if {@code true} and the upstream completes while there is still an unsampled item available, * that item is emitted to downstream before completion * if {@code false}, an unsampled last item is ignored. * @see ReactiveX operators documentation: Sample @@ -11606,12 +11926,12 @@ public final Observable sample(long period, @NonNull TimeUnit unit, boolean e /** * Returns an {@code Observable} that emits the most recently emitted item (if any) emitted by the current {@code Observable} - * within periodic time intervals, where the intervals are defined on a particular Scheduler. + * within periodic time intervals, where the intervals are defined on a particular {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param period @@ -11619,9 +11939,10 @@ public final Observable sample(long period, @NonNull TimeUnit unit, boolean e * @param unit * the {@link TimeUnit} in which {@code period} is defined * @param scheduler - * the {@link Scheduler} to use when sampling + * the {@code Scheduler} to use when sampling * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} at * the specified time interval + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Sample * @see #throttleLast(long, TimeUnit, Scheduler) */ @@ -11636,13 +11957,13 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull /** * Returns an {@code Observable} that emits the most recently emitted item (if any) emitted by the current {@code Observable} - * within periodic time intervals, where the intervals are defined on a particular Scheduler + * within periodic time intervals, where the intervals are defined on a particular {@link Scheduler} * and optionally emit the very last upstream item when the upstream completes. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* *

History: 2.0.5 - experimental @@ -11651,13 +11972,14 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull * @param unit * the {@link TimeUnit} in which {@code period} is defined * @param scheduler - * the {@link Scheduler} to use when sampling + * the {@code Scheduler} to use when sampling * @param emitLast - * if true and the upstream completes while there is still an unsampled item available, + * if {@code true} and the upstream completes while there is still an unsampled item available, * that item is emitted to downstream before completion * if {@code false}, an unsampled last item is ignored. * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} at * the specified time interval + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Sample * @see #throttleLast(long, TimeUnit, Scheduler) * @since 2.1 @@ -11672,9 +11994,9 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull } /** - * Returns an {@code Observable} that, when the specified {@code sampler} {@code ObservableSource} emits an item or completes, + * Returns an {@code Observable} that, when the specified {@code sampler} {@link ObservableSource} emits an item or completes, * emits the most recently emitted item (if any) emitted by the current {@code Observable} since the previous - * emission from the {@code sampler} ObservableSource. + * emission from the {@code sampler} {@code ObservableSource}. *

* *

@@ -11687,6 +12009,7 @@ public final Observable sample(long period, @NonNull TimeUnit unit, @NonNull * the {@code ObservableSource} to use for sampling the current {@code Observable} * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} whenever * the {@code sampler} {@code ObservableSource} emits an item or completes + * @throws NullPointerException if {@code sampler} is {@code null} * @see ReactiveX operators documentation: Sample */ @CheckReturnValue @@ -11698,7 +12021,7 @@ public final Observable sample(@NonNull ObservableSource sampler) { } /** - * Returns an {@code Observable} that, when the specified {@code sampler} {@code ObservableSource} emits an item or completes, + * Returns an {@code Observable} that, when the specified {@code sampler} {@link ObservableSource} emits an item or completes, * emits the most recently emitted item (if any) emitted by the current {@code Observable} since the previous * emission from the {@code sampler} {@code ObservableSource} * and optionally emit the very last upstream item when the upstream or other {@code ObservableSource} complete. @@ -11714,11 +12037,12 @@ public final Observable sample(@NonNull ObservableSource sampler) { * @param sampler * the {@code ObservableSource} to use for sampling the current {@code Observable} * @param emitLast - * if true and the upstream completes while there is still an unsampled item available, + * if {@code true} and the upstream completes while there is still an unsampled item available, * that item is emitted to downstream before completion * if {@code false}, an unsampled last item is ignored. * @return an {@code Observable} that emits the results of sampling the items emitted by the current {@code Observable} whenever * the {@code sampler} {@code ObservableSource} emits an item or completes + * @throws NullPointerException if {@code sampler} is {@code null} * @see ReactiveX operators documentation: Sample * @since 2.1 */ @@ -11749,6 +12073,7 @@ public final Observable sample(@NonNull ObservableSource sampler, bool * result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the * next accumulator call * @return an {@code Observable} that emits the results of each call to the accumulator function + * @throws NullPointerException if {@code accumulator} is {@code null} * @see ReactiveX operators documentation: Scan */ @CheckReturnValue @@ -11769,7 +12094,7 @@ public final Observable scan(@NonNull BiFunction accumulator) { *

* This sort of function is sometimes called an accumulator. *

- * Note that the {@code ObservableSource} that results from this method will emit {@code initialValue} as its first + * Note that the {@code Observable} that results from this method will emit {@code initialValue} as its first * emitted item. *

* Note that the {@code initialValue} is shared among all subscribers to the resulting {@code Observable} @@ -11799,6 +12124,7 @@ public final Observable scan(@NonNull BiFunction accumulator) { * next accumulator call * @return an {@code Observable} that emits {@code initialValue} followed by the results of each call to the * accumulator function + * @throws NullPointerException if {@code initialValue} or {@code accumulator} is {@code null} * @see ReactiveX operators documentation: Scan */ @CheckReturnValue @@ -11819,7 +12145,7 @@ public final Observable scan(@NonNull R initialValue, @NonNull BiFunction *

* This sort of function is sometimes called an accumulator. *

- * Note that the {@code ObservableSource} that results from this method will emit the value returned + * Note that the {@code Observable} that results from this method will emit the value returned * by the {@code seedSupplier} as its first item. *

*
Scheduler:
@@ -11828,13 +12154,14 @@ public final Observable scan(@NonNull R initialValue, @NonNull BiFunction * * @param the initial, accumulator and result type * @param seedSupplier - * a Supplier that returns the initial (seed) accumulator item for each individual Observer + * a {@link Supplier} that returns the initial (seed) accumulator item for each individual {@link Observer} * @param accumulator * an accumulator function to be invoked on each item emitted by the current {@code Observable}, whose - * result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the + * result will be emitted to {@code Observer}s via {@link Observer#onNext onNext} and used in the * next accumulator call * @return an {@code Observable} that emits {@code initialValue} followed by the results of each call to the * accumulator function + * @throws NullPointerException if {@code seedSupplier} or {@code accumulator} is {@code null} * @see ReactiveX operators documentation: Scan */ @CheckReturnValue @@ -11847,13 +12174,13 @@ public final Observable scanWith(@NonNull Supplier seedSupplier, @NonN } /** - * Forces an {@code ObservableSource}'s emissions and notifications to be serialized and for it to obey + * Forces the current {@code Observable}'s emissions and notifications to be serialized and for it to obey * the {@code ObservableSource} contract in other ways. *

- * It is possible for an {@code ObservableSource} to invoke its {@code Observer}s' methods asynchronously, perhaps from - * different threads. This could make such an {@code ObservableSource} poorly-behaved, in that it might try to invoke + * It is possible for an {@code Observable} to invoke its {@link Observer}s' methods asynchronously, perhaps from + * different threads. This could make such an {@code Observable} poorly-behaved, in that it might try to invoke * {@code onComplete} or {@code onError} before one of its {@code onNext} invocations, or it might call - * {@code onNext} from two different threads concurrently. You can force such an {@code ObservableSource} to be + * {@code onNext} from two different threads concurrently. You can force such an {@code Observable} to be * well-behaved and sequential by applying the {@code serialize} method to it. *

* @@ -11862,7 +12189,7 @@ public final Observable scanWith(@NonNull Supplier seedSupplier, @NonN *

{@code serialize} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an {@link ObservableSource} that is guaranteed to be well-behaved and to make only serialized calls to + * @return an {@code Observable} that is guaranteed to be well-behaved and to make only serialized calls to * its observers * @see ReactiveX operators documentation: Serialize */ @@ -11874,8 +12201,8 @@ public final Observable serialize() { } /** - * Returns a new {@link ObservableSource} that multicasts (and shares a single subscription to) the original {@link ObservableSource}. As long as - * there is at least one {@link Observer}, the current {@link Observable} will stay subscribed and keep emitting signals. + * Returns a new {@code Observable} that multicasts (and shares a single subscription to) the current {@code Observable}. As long as + * there is at least one {@link Observer}, the current {@code Observable} will stay subscribed and keep emitting signals. * When all observers have disposed, the operator will dispose the subscription to the current {@code Observable}. *

* This is an alias for {@link #publish()}.{@link ConnectableObservable#refCount() refCount()}. @@ -11886,8 +12213,8 @@ public final Observable serialize() { *

{@code share} does not operate by default on a particular {@link Scheduler}.
*
* - * @return an {@code ObservableSource} that upon connection causes the current {@code Observable} to emit items - * to its {@link Observer}s + * @return an {@code Observable} that upon connection causes the current {@code Observable} to emit items + * to its {@code Observer}s * @see ReactiveX operators documentation: RefCount */ @CheckReturnValue @@ -11899,7 +12226,7 @@ public final Observable share() { /** * Returns a {@link Maybe} that completes if the current {@code Observable} is empty or emits the single item - * emitted by the current {@code Observable}, or signals an {@code IllegalArgumentException} if the current + * emitted by the current {@code Observable}, or signals an {@link IllegalArgumentException} if the current * {@code Observable} emits more than one item. *

* @@ -11908,7 +12235,7 @@ public final Observable share() { *

{@code singleElement} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a {@link Maybe} that emits the single item emitted by the current {@code Observable} + * @return a {@code Maybe} that emits the single item emitted by the current {@code Observable} * @see ReactiveX operators documentation: First */ @CheckReturnValue @@ -11919,9 +12246,9 @@ public final Maybe singleElement() { } /** - * Returns a Single that emits the single item emitted by the current {@code Observable}, if the current {@code Observable} + * Returns a {@link Single} that emits the single item emitted by the current {@code Observable}, if the current {@code Observable} * emits only a single item, or a default item if the current {@code Observable} emits no items. If the current - * {@code Observable} emits more than one item, an {@code IllegalArgumentException} is signaled instead. + * {@code Observable} emits more than one item, an {@link IllegalArgumentException} is signaled instead. *

* *

@@ -11931,7 +12258,8 @@ public final Maybe singleElement() { * * @param defaultItem * a default value to emit if the current {@code Observable} emits no item - * @return the new Single instance + * @return the new {@code Single} instance + * @throws NullPointerException if {@code defaultItem} is {@code null} * @see ReactiveX operators documentation: First */ @CheckReturnValue @@ -11946,7 +12274,7 @@ public final Single single(@NonNull T defaultItem) { * Returns a {@link Single} that emits the single item emitted by the current {@code Observable} if it * emits only a single item, otherwise * if the current {@code Observable} completes without emitting any items or emits more than one item a - * {@link NoSuchElementException} or {@code IllegalArgumentException} will be signaled respectively. + * {@link NoSuchElementException} or {@link IllegalArgumentException} will be signaled respectively. *

* *

@@ -11954,7 +12282,7 @@ public final Single single(@NonNull T defaultItem) { *
{@code singleOrError} does not operate by default on a particular {@link Scheduler}.
*
* - * @return the new Single instance + * @return the new {@code Single} instance * @see ReactiveX operators documentation: First */ @CheckReturnValue @@ -12007,6 +12335,7 @@ public final Observable skip(long count) { * the time unit of {@code time} * @return an {@code Observable} that skips values emitted by the current {@code Observable} before the time window defined * by {@code time} elapses and the emits the remainder + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Skip */ @CheckReturnValue @@ -12023,7 +12352,7 @@ public final Observable skip(long time, @NonNull TimeUnit unit) { * *
*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use for the timed skipping
+ *
You specify which {@code Scheduler} this operator will use for the timed skipping
*
* * @param time @@ -12031,9 +12360,10 @@ public final Observable skip(long time, @NonNull TimeUnit unit) { * @param unit * the time unit of {@code time} * @param scheduler - * the {@link Scheduler} on which the timed wait happens + * the {@code Scheduler} on which the timed wait happens * @return an {@code Observable} that skips values emitted by the current {@code Observable} before the time window defined * by {@code time} and {@code scheduler} elapses, and then emits the remainder + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Skip */ @CheckReturnValue @@ -12049,8 +12379,8 @@ public final Observable skip(long time, @NonNull TimeUnit unit, @NonNull Sche *

* *

- * This {@code Observer} accumulates a queue long enough to store the first {@code count} items. As more items are - * received, items are taken from the front of the queue and emitted by the returned ObservableSource. This causes + * This {@link Observer} accumulates a queue long enough to store the first {@code count} items. As more items are + * received, items are taken from the front of the queue and emitted by the returned {@code Observable}. This causes * such items to be delayed. *

*
Scheduler:
@@ -12061,8 +12391,8 @@ public final Observable skip(long time, @NonNull TimeUnit unit, @NonNull Sche * number of items to drop from the end of the source sequence * @return an {@code Observable} that emits the items emitted by the current {@code Observable} except for the dropped ones * at the end - * @throws IndexOutOfBoundsException - * if {@code count} is less than zero + * @throws IllegalArgumentException + * if {@code count} is negative * @see ReactiveX operators documentation: SkipLast */ @CheckReturnValue @@ -12070,7 +12400,7 @@ public final Observable skip(long time, @NonNull TimeUnit unit, @NonNull Sche @NonNull public final Observable skipLast(int count) { if (count < 0) { - throw new IndexOutOfBoundsException("count >= 0 required but it was " + count); + throw new IllegalArgumentException("count >= 0 required but it was " + count); } if (count == 0) { return RxJavaPlugins.onAssembly(this); @@ -12088,7 +12418,7 @@ public final Observable skipLast(int count) { *
*
Scheduler:
*
{@code skipLast} does not operate on any particular scheduler but uses the current time - * from the {@code computation} {@link Scheduler}.
+ * from the {@code trampoline} {@link Scheduler}. *
* * @param time @@ -12097,6 +12427,7 @@ public final Observable skipLast(int count) { * the time unit of {@code time} * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the * source completes defined by {@code time} + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: SkipLast */ @CheckReturnValue @@ -12128,6 +12459,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit) { * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the * source completes defined by {@code time} + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: SkipLast */ @CheckReturnValue @@ -12157,6 +12489,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, boolean d * the scheduler used as the time source * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the * source completes defined by {@code time} and {@code scheduler} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: SkipLast */ @CheckReturnValue @@ -12189,6 +12522,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the * source completes defined by {@code time} and {@code scheduler} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: SkipLast */ @CheckReturnValue @@ -12223,6 +12557,8 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull * the hint about how many elements to expect to be skipped * @return an {@code Observable} that drops those items emitted by the current {@code Observable} in a time window before the * source completes defined by {@code time} and {@code scheduler} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: SkipLast */ @CheckReturnValue @@ -12238,7 +12574,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull } /** - * Returns an {@code Observable} that skips items emitted by the current {@code Observable} until a second {@code ObservableSource} emits + * Returns an {@code Observable} that skips items emitted by the current {@code Observable} until a second {@link ObservableSource} emits * an item. *

* @@ -12253,6 +12589,7 @@ public final Observable skipLast(long time, @NonNull TimeUnit unit, @NonNull * to be mirrored by the resulting {@code Observable} * @return an {@code Observable} that skips items from the current {@code Observable} until the second {@code ObservableSource} emits an * item, then emits the remaining items + * @throws NullPointerException if {@code other} is {@code null} * @see ReactiveX operators documentation: SkipUntil */ @CheckReturnValue @@ -12265,7 +12602,7 @@ public final Observable skipUntil(@NonNull ObservableSource other) { /** * Returns an {@code Observable} that skips all items emitted by the current {@code Observable} as long as a specified - * condition holds {@code true}, but emits all further source items as soon as the condition becomes false. + * condition holds {@code true}, but emits all further source items as soon as the condition becomes {@code false}. *

* *

@@ -12276,7 +12613,8 @@ public final Observable skipUntil(@NonNull ObservableSource other) { * @param predicate * a function to test each item emitted from the current {@code Observable} * @return an {@code Observable} that begins emitting items emitted by the current {@code Observable} when the specified - * predicate becomes false + * predicate becomes {@code false} + * @throws NullPointerException if {@code predicate} is {@code null} * @see ReactiveX operators documentation: SkipWhile */ @CheckReturnValue @@ -12288,13 +12626,13 @@ public final Observable skipWhile(@NonNull Predicate predicate) { } /** - * Returns an {@code Observable} that emits the events emitted by source {@code ObservableSource}, in a - * sorted order. Each item emitted by the {@code ObservableSource} must implement {@link Comparable} with respect to all + * Returns an {@code Observable} that emits the events emitted by the current {@code Observable}, in a + * sorted order. Each item emitted by the current {@code Observable} must implement {@link Comparable} with respect to all * other items in the sequence. *

* *

- * If any item emitted by the current {@code Observable} does not implement {@link Comparable} with respect to + * If any item emitted by the current {@code Observable} does not implement {@code Comparable} with respect to * all other items emitted by the current {@code Observable}, no items will be emitted and the * sequence is terminated with a {@link ClassCastException}. * @@ -12315,7 +12653,7 @@ public final Observable sorted() { } /** - * Returns an {@code Observable} that emits the events emitted by source {@code ObservableSource}, in a + * Returns an {@code Observable} that emits the events emitted by the current {@code Observable}, in a * sorted order based on a specified comparison function. * *

Note that calling {@code sorted} with long, non-terminating or infinite sources @@ -12327,8 +12665,9 @@ public final Observable sorted() { *

* * @param sortFunction - * a function that compares two items emitted by the current {@code Observable} and returns an Integer + * a function that compares two items emitted by the current {@code Observable} and returns an {@code int} * that indicates their sort order + * @throws NullPointerException if {@code sortFunction} is {@code null} * @return an {@code Observable} that emits the items emitted by the current {@code Observable} in sorted order */ @CheckReturnValue @@ -12350,9 +12689,10 @@ public final Observable sorted(@NonNull Comparator sortFunction) { *
* * @param items - * an Iterable that contains the items you want the modified {@code ObservableSource} to emit first - * @return an {@code Observable} that emits the items in the specified {@link Iterable} and then emits the items + * an {@code Iterable} that contains the items you want the resulting {@code Observable} to emit first + * @return an {@code Observable} that emits the items in the specified {@code Iterable} and then emits the items * emitted by the current {@code Observable} + * @throws NullPointerException if {@code items} is {@code null} * @see ReactiveX operators documentation: StartWith * @since 3.0.0 * @see #startWithItem(Object) @@ -12377,8 +12717,9 @@ public final Observable startWithIterable(@NonNull Iterable item * * @param other * an {@code ObservableSource} that contains the items you want the modified {@code ObservableSource} to emit first - * @return an {@code Observable} that emits the items in the specified {@link ObservableSource} and then emits the items + * @return an {@code Observable} that emits the items in the specified {@code ObservableSource} and then emits the items * emitted by the current {@code Observable} + * @throws NullPointerException if {@code other} is {@code null} * @see ReactiveX operators documentation: StartWith */ @CheckReturnValue @@ -12403,6 +12744,7 @@ public final Observable startWith(@NonNull ObservableSource othe * the item to emit first * @return an {@code Observable} that emits the specified item before it begins to emit items emitted by the current * {@code Observable} + * @throws NullPointerException if {@code item} is {@code null} * @see ReactiveX operators documentation: StartWith * @see #startWithArray(Object...) * @see #startWithIterable(Iterable) @@ -12412,7 +12754,6 @@ public final Observable startWith(@NonNull ObservableSource othe @SchedulerSupport(SchedulerSupport.NONE) @NonNull public final Observable startWithItem(@NonNull T item) { - Objects.requireNonNull(item, "item is null"); return concatArray(just(item), this); } @@ -12430,6 +12771,7 @@ public final Observable startWithItem(@NonNull T item) { * the array of values to emit first * @return an {@code Observable} that emits the specified items before it begins to emit items emitted by the current * {@code Observable} + * @throws NullPointerException if {@code items} is {@code null} * @see ReactiveX operators documentation: StartWith * @see #startWithItem(Object) * @see #startWithIterable(Iterable) @@ -12447,18 +12789,18 @@ public final Observable startWithArray(@NonNull T... items) { } /** - * Subscribes to an {@code ObservableSource} and ignores {@code onNext} and {@code onComplete} emissions. + * Subscribes to the current {@code Observable} and ignores {@code onNext} and {@code onComplete} emissions. *

* If the {@code Observable} emits an error, it is wrapped into an * {@link OnErrorNotImplementedException} - * and routed to the RxJavaPlugins.onError handler. + * and routed to the {@link RxJavaPlugins#onError(Throwable)} handler. *

*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @return a {@link Disposable} reference with which the caller can stop receiving items before - * the {@code ObservableSource} has finished sending them + * the current {@code Observable} has finished sending them * @see ReactiveX operators documentation: Subscribe */ @SchedulerSupport(SchedulerSupport.NONE) @@ -12468,22 +12810,22 @@ public final Disposable subscribe() { } /** - * Subscribes to an {@code ObservableSource} and provides a callback to handle the items it emits. + * Subscribes to the current {@code Observable} and provides a callback to handle the items it emits. *

* If the {@code Observable} emits an error, it is wrapped into an * {@link OnErrorNotImplementedException} - * and routed to the RxJavaPlugins.onError handler. + * and routed to the {@link RxJavaPlugins#onError(Throwable)} handler. *

*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext - * the {@code Consumer} you have designed to accept emissions from the {@code ObservableSource} + * the {@code Consumer} you have designed to accept emissions from the current {@code Observable} * @return a {@link Disposable} reference with which the caller can stop receiving items before - * the {@code ObservableSource} has finished sending them + * the current {@code Observable} has finished sending them * @throws NullPointerException - * if {@code onNext} is null + * if {@code onNext} is {@code null} * @see ReactiveX operators documentation: Subscribe */ @CheckReturnValue @@ -12494,24 +12836,23 @@ public final Disposable subscribe(@NonNull Consumer onNext) { } /** - * Subscribes to an {@code ObservableSource} and provides callbacks to handle the items it emits and any error - * notification it issues. + * Subscribes to the current {@code Observable} and provides callbacks to handle the items it emits and any error + * notification it signals. *
*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext - * the {@code Consumer} you have designed to accept emissions from the {@code ObservableSource} + * the {@code Consumer} you have designed to accept emissions from the current {@code Observable} * @param onError - * the {@code Consumer} you have designed to accept any error notification from the - * {@code ObservableSource} + * the {@code Consumer} you have designed to accept any error notification from the current + * {@code Observable} * @return a {@link Disposable} reference with which the caller can stop receiving items before - * the {@code ObservableSource} has finished sending them + * the current {@code Observable} has finished sending them * @see ReactiveX operators documentation: Subscribe * @throws NullPointerException - * if {@code onNext} is null, or - * if {@code onError} is null + * if {@code onNext} or {@code onError} is {@code null} */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -12521,27 +12862,25 @@ public final Disposable subscribe(@NonNull Consumer onNext, @NonNull } /** - * Subscribes to an {@code ObservableSource} and provides callbacks to handle the items it emits and any error or - * completion notification it issues. + * Subscribes to the current {@code Observable} and provides callbacks to handle the items it emits and any error or + * completion notification it signals. *
*
Scheduler:
*
{@code subscribe} does not operate by default on a particular {@link Scheduler}.
*
* * @param onNext - * the {@code Consumer} you have designed to accept emissions from the {@code ObservableSource} + * the {@code Consumer} you have designed to accept emissions from the current {@code Observable} * @param onError - * the {@code Consumer} you have designed to accept any error notification from the - * {@code ObservableSource} + * the {@code Consumer} you have designed to accept any error notification from the current + * {@code Observable} * @param onComplete - * the {@code Action} you have designed to accept a completion notification from the - * {@code ObservableSource} + * the {@link Action} you have designed to accept a completion notification from the current + * {@code Observable} * @return a {@link Disposable} reference with which the caller can stop receiving items before - * the {@code ObservableSource} has finished sending them + * the current {@code Observable} has finished sending them * @throws NullPointerException - * if {@code onNext} is null, or - * if {@code onError} is null, or - * if {@code onComplete} is null + * if {@code onNext}, {@code onError} or {@code onComplete} is {@code null} * @see ReactiveX operators documentation: Subscribe */ @CheckReturnValue @@ -12590,7 +12929,7 @@ public final void subscribe(@NonNull Observer observer) { *

There is no need to call any of the plugin hooks on the current {@code Observable} instance or * the {@code Observer}; all hooks and basic safeguards have been * applied by {@link #subscribe(Observer)} before this method gets called. - * @param observer the incoming Observer, never null + * @param observer the incoming {@code Observer}, never {@code null} */ protected abstract void subscribeActual(@NonNull Observer observer); @@ -12613,7 +12952,7 @@ public final void subscribe(@NonNull Observer observer) { *

{@code subscribeWith} does not operate by default on a particular {@link Scheduler}.
*
* @param the type of the {@code Observer} to use and return - * @param observer the {@code Observer} (subclass) to use and return, not null + * @param observer the {@code Observer} (subclass) to use and return, not {@code null} * @return the input {@code observer} * @throws NullPointerException if {@code observer} is {@code null} * @since 2.0 @@ -12627,18 +12966,19 @@ public final void subscribe(@NonNull Observer observer) { } /** - * Asynchronously subscribes {@code Observer}s to the current {@code Observable} on the specified {@link Scheduler}. + * Asynchronously subscribes {@link Observer}s to the current {@code Observable} on the specified {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param scheduler - * the {@link Scheduler} to perform subscription actions on + * the {@code Scheduler} to perform subscription actions on * @return the current {@code Observable} modified so that its subscriptions happen on the - * specified {@link Scheduler} + * specified {@code Scheduler} + * @throws NullPointerException if {@code scheduler} is {@code null} * @see ReactiveX operators documentation: SubscribeOn * @see RxJava Threading Examples * @see #observeOn @@ -12653,7 +12993,7 @@ public final Observable subscribeOn(@NonNull Scheduler scheduler) { /** * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} or the items of an alternate - * {@code ObservableSource} if the current {@code Observable} is empty. + * {@link ObservableSource} if the current {@code Observable} is empty. *

* *

@@ -12663,8 +13003,9 @@ public final Observable subscribeOn(@NonNull Scheduler scheduler) { * * @param other * the alternate {@code ObservableSource} to subscribe to if the source does not emit any items - * @return an {@code ObservableSource} that emits the items emitted by the current {@code Observable} or the items of an + * @return an {@code Observable} that emits the items emitted by the current {@code Observable} or the items of an * alternate {@code ObservableSource} if the current {@code Observable} is empty. + * @throws NullPointerException if {@code other} is {@code null} * @since 1.1.0 */ @CheckReturnValue @@ -12677,7 +13018,7 @@ public final Observable switchIfEmpty(@NonNull ObservableSource /** * Returns a new {@code Observable} by applying a function that you supply to each item emitted by the current - * {@code Observable} that returns an {@code ObservableSource}, and then emitting the items emitted by the most recently emitted + * {@code Observable} that returns an {@link ObservableSource}, and then emitting the items emitted by the most recently emitted * of these {@code ObservableSource}s. *

* The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code ObservableSource}, if any, complete. @@ -12694,6 +13035,7 @@ public final Observable switchIfEmpty(@NonNull ObservableSource * a function that, when applied to an item emitted by the current {@code Observable}, returns an * {@code ObservableSource} * @return an {@code Observable} that emits the items emitted by the {@code ObservableSource} returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} + * @throws NullPointerException if {@code mapper} is {@code null} * @see ReactiveX operators documentation: FlatMap * @see #switchMapDelayError(Function) */ @@ -12706,11 +13048,11 @@ public final Observable switchMap(@NonNull Function * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code ObservableSource}, if any, complete. - * If the current {@code Observable} signals an onError, the inner {@code ObservableSource} is disposed and the error delivered in-sequence. + * If the current {@code Observable} signals an {@code onError}, the inner {@code ObservableSource} is disposed and the error delivered in-sequence. *

* *

@@ -12723,8 +13065,10 @@ public final Observable switchMap(@NonNull FunctionReactiveX operators documentation: FlatMap * @see #switchMapDelayError(Function, int) */ @@ -12746,7 +13090,7 @@ public final Observable switchMap(@NonNull Function @@ -12755,27 +13099,28 @@ public final Observable switchMap(@NonNull Function *
Scheduler:
*
{@code switchMapCompletable} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
*
If either the current {@code Observable} or the active {@code CompletableSource} signals an {@code onError}, - * the resulting {@code Completable} is terminated immediately with that {@code Throwable}. + * the resulting {@code Completable} is terminated immediately with that {@link Throwable}. * Use the {@link #switchMapCompletableDelayError(Function)} to delay such inner failures until * every inner {@code CompletableSource}s and the main {@code Observable} terminates in some fashion. * If they fail concurrently, the operator may combine the {@code Throwable}s into a * {@link CompositeException} * and signal it to the downstream instead. If any inactivated (switched out) {@code CompletableSource} * signals an {@code onError} late, the {@code Throwable}s will be signaled to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. *
*
*

History: 2.1.11 - experimental * @param mapper the function called with each upstream item and should return a - * {@link CompletableSource} to be subscribed to and awaited for + * {@code CompletableSource} to be subscribed to and awaited for * (non blockingly) for its terminal event - * @return the new Completable instance + * @return the new {@code Completable} instance + * @throws NullPointerException if {@code mapper} is {@code null} * @see #switchMapCompletableDelayError(Function) * @since 2.2 */ @@ -12798,27 +13143,28 @@ public final Completable switchMapCompletable(@NonNull Function *

Scheduler:
*
{@code switchMapCompletableDelayError} does not operate by default on a particular {@link Scheduler}.
*
Error handling:
- *
Errors of the current {@code Observable} and all the {@code CompletableSource}s, who had the chance + *
The errors of the current {@code Observable} and all the {@code CompletableSource}s, who had the chance * to run to their completion, are delayed until * all of them terminate in some fashion. At this point, if there was only one failure, the respective - * {@code Throwable} is emitted to the downstream. It there were more than one failures, the + * {@link Throwable} is emitted to the downstream. It there were more than one failures, the * operator combines all {@code Throwable}s into a {@link CompositeException} * and signals that to the downstream. * If any inactivated (switched out) {@code CompletableSource} * signals an {@code onError} late, the {@code Throwable}s will be signaled to the global error handler via - * {@link RxJavaPlugins#onError(Throwable)} method as {@code UndeliverableException} errors. + * {@link RxJavaPlugins#onError(Throwable)} method as {@link UndeliverableException} errors. *
*
*

History: 2.1.11 - experimental * @param mapper the function called with each upstream item and should return a - * {@link CompletableSource} to be subscribed to and awaited for + * {@code CompletableSource} to be subscribed to and awaited for * (non blockingly) for its terminal event - * @return the new Completable instance + * @return the new {@code Completable} instance + * @throws NullPointerException if {@code mapper} is {@code null} * @see #switchMapCompletable(Function) * @since 2.2 */ @@ -12831,7 +13177,7 @@ public final Completable switchMapCompletableDelayError(@NonNull FunctionError handling: *

This operator terminates with an {@code onError} if the current {@code Observable} or any of * the inner {@code MaybeSource}s fail while they are active. When this happens concurrently, their - * individual {@code Throwable} errors may get combined and emitted as a single + * individual {@link Throwable} errors may get combined and emitted as a single * {@link CompositeException}. Otherwise, a late * (i.e., inactive or switched out) {@code onError} from the current {@code Observable} or from any of * the inner {@code MaybeSource}s will be forwarded to the global error handler via @@ -12856,6 +13202,7 @@ public final Completable switchMapCompletableDelayError(@NonNull Function Observable switchMapMaybe(@NonNull Function Observable switchMapMaybeDelayError(@NonNull Function - * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner SingleSource, if any, complete. - * If the current {@code Observable} signals an onError, the inner SingleSource is disposed and the error delivered in-sequence. + * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code SingleSource}, if any, complete. + * If the current {@code Observable} signals an {@code onError}, the inner {@code SingleSource} is disposed and the error delivered in-sequence. *

* *

@@ -12908,11 +13256,12 @@ public final Observable switchMapMaybeDelayError(@NonNull Function{@code switchMapSingle} does not operate by default on a particular {@link Scheduler}.
*
*

History: 2.0.8 - experimental - * @param the element type of the inner SingleSources and the output + * @param the element type of the inner {@code SingleSource}s and the output * @param mapper * a function that, when applied to an item emitted by the current {@code Observable}, returns a - * SingleSource - * @return an {@code Observable} that emits the item emitted by the SingleSource returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} + * {@code SingleSource} + * @return an {@code Observable} that emits the item emitted by the {@code SingleSource} returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} + * @throws NullPointerException if {@code mapper} is {@code null} * @see ReactiveX operators documentation: FlatMap * @see #switchMapSingleDelayError(Function) * @since 2.2 @@ -12927,12 +13276,12 @@ public final Observable switchMapSingle(@NonNull Function - * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner SingleSource, if any, complete. - * If the current {@code Observable} signals an onError, the termination of the last inner SingleSource will emit that error as is - * or wrapped into a CompositeException along with the other possible errors the former inner SingleSources signaled. + * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code SingleSource}, if any, complete. + * If the current {@code Observable} signals an {@code onError}, the termination of the last inner {@code SingleSource} will emit that error as is + * or wrapped into a {@link CompositeException} along with the other possible errors the former inner {@code SingleSource}s signaled. *

* *

@@ -12940,11 +13289,13 @@ public final Observable switchMapSingle(@NonNull Function{@code switchMapSingleDelayError} does not operate by default on a particular {@link Scheduler}. *
*

History: 2.0.8 - experimental - * @param the element type of the inner SingleSources and the output + * @param the element type of the inner {@code SingleSource}s and the output * @param mapper * a function that, when applied to an item emitted by the current {@code Observable}, returns a - * SingleSource - * @return an {@code Observable} that emits the item emitted by the SingleSource returned from applying {@code mapper} to the most recently emitted item emitted by the current {@code Observable} + * {@code SingleSource} + * @return an {@code Observable} that emits the item emitted by the {@code SingleSource} returned from applying {@code mapper} + * to the most recently emitted item emitted by the current {@code Observable} + * @throws NullPointerException if {@code mapper} is {@code null} * @see ReactiveX operators documentation: FlatMap * @see #switchMapSingle(Function) * @since 2.2 @@ -12959,12 +13310,12 @@ public final Observable switchMapSingleDelayError(@NonNull Function * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code ObservableSource}, if any, complete. - * If the current {@code Observable} signals an onError, the termination of the last inner {@code ObservableSource} will emit that error as is - * or wrapped into a CompositeException along with the other possible errors the former inner {@code ObservableSource}s signaled. + * If the current {@code Observable} signals an {@code onError}, the termination of the last inner {@code ObservableSource} will emit that error as is + * or wrapped into a {@link CompositeException} along with the other possible errors the former inner {@code ObservableSource}s signaled. *

* *

@@ -12976,7 +13327,9 @@ public final Observable switchMapSingleDelayError(@NonNull FunctionReactiveX operators documentation: FlatMap * @see #switchMap(Function) * @since 2.0 @@ -12990,12 +13343,12 @@ public final Observable switchMapDelayError(@NonNull Function * The resulting {@code Observable} completes if both the current {@code Observable} and the last inner {@code ObservableSource}, if any, complete. * If the current {@code Observable} signals an {@code onError}, the termination of the last inner {@code ObservableSource} will emit that error as is - * or wrapped into a CompositeException along with the other possible errors the former inner {@code ObservableSource}s signaled. + * or wrapped into a {@link CompositeException} along with the other possible errors the former inner {@code ObservableSource}s signaled. *

* *

@@ -13008,8 +13361,10 @@ public final Observable switchMapDelayError(@NonNull FunctionReactiveX operators documentation: FlatMap * @see #switchMap(Function, int) * @since 2.0 @@ -13037,9 +13392,13 @@ public final Observable switchMapDelayError(@NonNull Function * *

- * This method returns an {@code ObservableSource} that will invoke a subscribing {@link Observer}'s + * This method returns an {@code Observable} that will invoke a subscribing {@link Observer}'s * {@link Observer#onNext onNext} function a maximum of {@code count} times before invoking * {@link Observer#onComplete onComplete}. + *

+ * Taking {@code 0} items from the current {@code Observable} will still subscribe to it, allowing the + * subscription-time side-effects to happen there, but will be immediately disposed and the downstream completed + * without any item emission. *

*
Scheduler:
*
This version of {@code take} does not operate by default on a particular {@link Scheduler}.
@@ -13048,7 +13407,8 @@ public final Observable switchMapDelayError(@NonNull FunctionReactiveX operators documentation: Take */ @CheckReturnValue @@ -13062,7 +13422,7 @@ public final Observable take(long count) { } /** - * Returns an {@code Observable} that emits those items emitted by source {@code ObservableSource} before a specified time runs + * Returns an {@code Observable} that emits those items emitted by the current {@code Observable} before a specified time runs * out. *

* If time runs out before the {@code Observable} completes normally, the {@code onComplete} event will be @@ -13071,7 +13431,7 @@ public final Observable take(long count) { * *

*
Scheduler:
- *
This version of {@code take} operates by default on the {@code computation} {@link Scheduler}.
+ *
This version of {@code take} operates by default on the {@code computation} {@code Scheduler}.
*
* * @param time @@ -13079,6 +13439,7 @@ public final Observable take(long count) { * @param unit * the time unit of {@code time} * @return an {@code Observable} that emits those items emitted by the current {@code Observable} before the time runs out + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Take */ @CheckReturnValue @@ -13089,16 +13450,16 @@ public final Observable take(long time, @NonNull TimeUnit unit) { } /** - * Returns an {@code Observable} that emits those items emitted by source {@code ObservableSource} before a specified time (on a - * specified Scheduler) runs out. + * Returns an {@code Observable} that emits those items emitted by the current {@code Observable} before a specified time (on a + * specified {@link Scheduler}) runs out. *

* If time runs out before the {@code Observable} completes normally, the {@code onComplete} event will be - * signaled on the provided {@link Scheduler}. + * signaled on the provided {@code Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param time @@ -13106,9 +13467,10 @@ public final Observable take(long time, @NonNull TimeUnit unit) { * @param unit * the time unit of {@code time} * @param scheduler - * the Scheduler used for time source + * the {@code Scheduler} used for time source * @return an {@code Observable} that emits those items emitted by the current {@code Observable} before the time runs out, - * according to the specified Scheduler + * according to the specified {@code Scheduler} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Take */ @CheckReturnValue @@ -13132,8 +13494,8 @@ public final Observable take(long time, @NonNull TimeUnit unit, @NonNull Sche * the maximum number of items to emit from the end of the sequence of items emitted by the current * {@code Observable} * @return an {@code Observable} that emits at most the last {@code count} items emitted by the current {@code Observable} - * @throws IndexOutOfBoundsException - * if {@code count} is less than zero + * @throws IllegalArgumentException + * if {@code count} is negative * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13141,7 +13503,7 @@ public final Observable take(long time, @NonNull TimeUnit unit, @NonNull Sche @NonNull public final Observable takeLast(int count) { if (count < 0) { - throw new IndexOutOfBoundsException("count >= 0 required but it was " + count); + throw new IllegalArgumentException("count >= 0 required but it was " + count); } if (count == 0) { return RxJavaPlugins.onAssembly(new ObservableIgnoreElements<>(this)); @@ -13154,13 +13516,13 @@ public final Observable takeLast(int count) { /** * Returns an {@code Observable} that emits at most a specified number of items from the current {@code Observable} that were - * emitted in a specified window of time before the {@code ObservableSource} completed. + * emitted in a specified window of time before the current {@code Observable} completed. *

* *

*
Scheduler:
*
{@code takeLast} does not operate on any particular scheduler but uses the current time - * from the {@code computation} {@link Scheduler}.
+ * from the {@code trampoline} {@link Scheduler}. *
* * @param count @@ -13170,7 +13532,8 @@ public final Observable takeLast(int count) { * @param unit * the time unit of {@code time} * @return an {@code Observable} that emits at most {@code count} items from the current {@code Observable} that were emitted - * in a specified window of time before the {@code ObservableSource} completed + * in a specified window of time before the current {@code Observable} completed + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13182,13 +13545,13 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni /** * Returns an {@code Observable} that emits at most a specified number of items from the current {@code Observable} that were - * emitted in a specified window of time before the {@code ObservableSource} completed, where the timing information is - * provided by a given Scheduler. + * emitted in a specified window of time before the current {@code Observable} completed, where the timing information is + * provided by a given {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use for tracking the current time
+ *
You specify which {@code Scheduler} this operator will use for tracking the current time
*
* * @param count @@ -13198,12 +13561,13 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni * @param unit * the time unit of {@code time} * @param scheduler - * the {@link Scheduler} that provides the timestamps for the observed items + * the {@code Scheduler} that provides the timestamps for the observed items * @return an {@code Observable} that emits at most {@code count} items from the current {@code Observable} that were emitted - * in a specified window of time before the {@code ObservableSource} completed, where the timing information is - * provided by the given {@code scheduler} - * @throws IndexOutOfBoundsException - * if {@code count} is less than zero + * in a specified window of time before the current {@code Observable} completed, where the timing information is + * provided by the given {@code Scheduler} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException + * if {@code count} is negative * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13215,13 +13579,13 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni /** * Returns an {@code Observable} that emits at most a specified number of items from the current {@code Observable} that were - * emitted in a specified window of time before the {@code ObservableSource} completed, where the timing information is - * provided by a given Scheduler. + * emitted in a specified window of time before the current {@code Observable} completed, where the timing information is + * provided by a given {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use for tracking the current time
+ *
You specify which {@code Scheduler} this operator will use for tracking the current time
*
* * @param count @@ -13231,17 +13595,18 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni * @param unit * the time unit of {@code time} * @param scheduler - * the {@link Scheduler} that provides the timestamps for the observed items + * the {@code Scheduler} that provides the timestamps for the observed items * @param delayError * if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped * @param bufferSize * the hint about how many elements to expect to be last * @return an {@code Observable} that emits at most {@code count} items from the current {@code Observable} that were emitted - * in a specified window of time before the {@code ObservableSource} completed, where the timing information is + * in a specified window of time before the current {@code Observable} completed, where the timing information is * provided by the given {@code scheduler} - * @throws IndexOutOfBoundsException - * if {@code count} is less than zero + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException + * if {@code count} is negative or {@code bufferSize} is non-positive * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13252,19 +13617,20 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni Objects.requireNonNull(scheduler, "scheduler is null"); ObjectHelper.verifyPositive(bufferSize, "bufferSize"); if (count < 0) { - throw new IndexOutOfBoundsException("count >= 0 required but it was " + count); + throw new IllegalArgumentException("count >= 0 required but it was " + count); } return RxJavaPlugins.onAssembly(new ObservableTakeLastTimed<>(this, count, time, unit, scheduler, bufferSize, delayError)); } /** * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified - * window of time before the {@code ObservableSource} completed. + * window of time before the current {@code Observable} completed. *

* *

*
Scheduler:
- *
This version of {@code takeLast} operates by default on the {@code computation} {@link Scheduler}.
+ *
{@code takeLast} does not operate on any particular scheduler but uses the current time + * from the {@code trampoline} {@link Scheduler}.
*
* * @param time @@ -13272,7 +13638,7 @@ public final Observable takeLast(long count, long time, @NonNull TimeUnit uni * @param unit * the time unit of {@code time} * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of - * time before the {@code ObservableSource} completed specified by {@code time} + * time before the current {@code Observable} completed specified by {@code time} * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13284,12 +13650,13 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit) { /** * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified - * window of time before the {@code ObservableSource} completed. + * window of time before the current {@code Observable} completed. *

* *

*
Scheduler:
- *
This version of {@code takeLast} operates by default on the {@code computation} {@link Scheduler}.
+ *
{@code takeLast} does not operate on any particular scheduler but uses the current time + * from the {@code trampoline} {@link Scheduler}.
*
* * @param time @@ -13300,7 +13667,7 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit) { * if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of - * time before the {@code ObservableSource} completed specified by {@code time} + * time before the current {@code Observable} completed specified by {@code time} * @see ReactiveX operators documentation: TakeLast */ @CheckReturnValue @@ -13312,13 +13679,13 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, boolean d /** * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified - * window of time before the {@code ObservableSource} completed, where the timing information is provided by a specified - * Scheduler. + * window of time before the current {@code Observable} completed, where the timing information is provided by a specified + * {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param time @@ -13326,9 +13693,9 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, boolean d * @param unit * the time unit of {@code time} * @param scheduler - * the Scheduler that provides the timestamps for the Observed items + * the {@code Scheduler} that provides the timestamps for the observed items * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of - * time before the {@code ObservableSource} completed specified by {@code time}, where the timing information is + * time before the current {@code Observable} completed specified by {@code time}, where the timing information is * provided by {@code scheduler} * @see ReactiveX operators documentation: TakeLast */ @@ -13341,13 +13708,13 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull /** * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified - * window of time before the {@code ObservableSource} completed, where the timing information is provided by a specified - * Scheduler. + * window of time before the current {@code Observable} completed, where the timing information is provided by a specified + * {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param time @@ -13355,12 +13722,12 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull * @param unit * the time unit of {@code time} * @param scheduler - * the Scheduler that provides the timestamps for the Observed items + * the {@code Scheduler} that provides the timestamps for the observed items * @param delayError * if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of - * time before the {@code ObservableSource} completed specified by {@code time}, where the timing information is + * time before the current {@code Observable} completed specified by {@code time}, where the timing information is * provided by {@code scheduler} * @see ReactiveX operators documentation: TakeLast */ @@ -13373,13 +13740,13 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull /** * Returns an {@code Observable} that emits the items from the current {@code Observable} that were emitted in a specified - * window of time before the {@code ObservableSource} completed, where the timing information is provided by a specified - * Scheduler. + * window of time before the current {@code Observable} completed, where the timing information is provided by a specified + * {@link Scheduler}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param time @@ -13387,14 +13754,14 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull * @param unit * the time unit of {@code time} * @param scheduler - * the Scheduler that provides the timestamps for the Observed items + * the {@code Scheduler} that provides the timestamps for the observed items * @param delayError * if {@code true}, an exception signaled by the current {@code Observable} is delayed until the regular elements are consumed * by the downstream; if {@code false}, an exception is immediately signaled and all regular elements dropped * @param bufferSize * the hint about how many elements to expect to be last * @return an {@code Observable} that emits the items from the current {@code Observable} that were emitted in the window of - * time before the {@code ObservableSource} completed specified by {@code time}, where the timing information is + * time before the current {@code Observable} completed specified by {@code time}, where the timing information is * provided by {@code scheduler} * @see ReactiveX operators documentation: TakeLast */ @@ -13406,7 +13773,7 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull } /** - * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} until a second {@code ObservableSource} + * Returns an {@code Observable} that emits the items emitted by the current {@code Observable} until a second {@link ObservableSource} * emits an item. *

* @@ -13421,6 +13788,7 @@ public final Observable takeLast(long time, @NonNull TimeUnit unit, @NonNull * @param * the type of items emitted by {@code other} * @return an {@code Observable} that emits the items emitted by the current {@code Observable} until such time as {@code other} emits its first item + * @throws NullPointerException if {@code other} is {@code null} * @see ReactiveX operators documentation: TakeUntil */ @CheckReturnValue @@ -13446,9 +13814,10 @@ public final Observable takeUntil(@NonNull ObservableSource other) { *

* * @param stopPredicate - * a function that evaluates an item emitted by the current {@code Observable} and returns a Boolean + * a function that evaluates an item emitted by the current {@code Observable} and returns a {@link Boolean} * @return an {@code Observable} that first emits items emitted by the current {@code Observable}, checks the specified * condition after each item, and then completes when the condition is satisfied. + * @throws NullPointerException if {@code stopPredicate} is {@code null} * @see ReactiveX operators documentation: TakeUntil * @see Observable#takeWhile(Predicate) * @since 1.1.0 @@ -13472,9 +13841,10 @@ public final Observable takeUntil(@NonNull Predicate stopPredicate *
* * @param predicate - * a function that evaluates an item emitted by the current {@code Observable} and returns a Boolean + * a function that evaluates an item emitted by the current {@code Observable} and returns a {@link Boolean} * @return an {@code Observable} that emits the items from the current {@code Observable} so long as each item satisfies the * condition defined by {@code predicate}, then completes + * @throws NullPointerException if {@code predicate} is {@code null} * @see ReactiveX operators documentation: TakeWhile * @see Observable#takeUntil(Predicate) */ @@ -13491,7 +13861,7 @@ public final Observable takeWhile(@NonNull Predicate predicate) { * time windows of a specified duration. *

* This differs from {@link #throttleLast} in that this only tracks passage of time whereas - * {@link #throttleLast} ticks at scheduled intervals. + * {@code throttleLast} ticks at scheduled intervals. *

* *

@@ -13504,6 +13874,7 @@ public final Observable takeWhile(@NonNull Predicate predicate) { * @param unit * the unit of time of {@code windowDuration} * @return an {@code Observable} that performs the throttle operation + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Sample */ @CheckReturnValue @@ -13515,15 +13886,15 @@ public final Observable throttleFirst(long windowDuration, @NonNull TimeUnit /** * Returns an {@code Observable} that emits only the first item emitted by the current {@code Observable} during sequential - * time windows of a specified duration, where the windows are managed by a specified Scheduler. + * time windows of a specified duration, where the windows are managed by a specified {@link Scheduler}. *

* This differs from {@link #throttleLast} in that this only tracks passage of time whereas - * {@link #throttleLast} ticks at scheduled intervals. + * {@code throttleLast} ticks at scheduled intervals. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param skipDuration @@ -13531,9 +13902,10 @@ public final Observable throttleFirst(long windowDuration, @NonNull TimeUnit * @param unit * the unit of time of {@code skipDuration} * @param scheduler - * the {@link Scheduler} to use internally to manage the timers that handle timeout for each + * the {@code Scheduler} to use internally to manage the timers that handle timeout for each * event * @return an {@code Observable} that performs the throttle operation + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Sample */ @CheckReturnValue @@ -13550,7 +13922,7 @@ public final Observable throttleFirst(long skipDuration, @NonNull TimeUnit un * time windows of a specified duration. *

* This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval whereas - * {@link #throttleFirst} does not tick, it just tracks passage of time. + * {@code throttleFirst} does not tick, it just tracks passage of time. *

* *

@@ -13564,6 +13936,7 @@ public final Observable throttleFirst(long skipDuration, @NonNull TimeUnit un * @param unit * the unit of time of {@code intervalDuration} * @return an {@code Observable} that performs the throttle operation + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Sample * @see #sample(long, TimeUnit) */ @@ -13576,15 +13949,15 @@ public final Observable throttleLast(long intervalDuration, @NonNull TimeUnit /** * Returns an {@code Observable} that emits only the last item emitted by the current {@code Observable} during sequential - * time windows of a specified duration, where the duration is governed by a specified Scheduler. + * time windows of a specified duration, where the duration is governed by a specified {@link Scheduler}. *

* This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval whereas - * {@link #throttleFirst} does not tick, it just tracks passage of time. + * {@code throttleFirst} does not tick, it just tracks passage of time. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param intervalDuration @@ -13593,9 +13966,10 @@ public final Observable throttleLast(long intervalDuration, @NonNull TimeUnit * @param unit * the unit of time of {@code intervalDuration} * @param scheduler - * the {@link Scheduler} to use internally to manage the timers that handle timeout for each + * the {@code Scheduler} to use internally to manage the timers that handle timeout for each * event * @return an {@code Observable} that performs the throttle operation + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Sample * @see #sample(long, TimeUnit, Scheduler) */ @@ -13627,6 +14001,7 @@ public final Observable throttleLast(long intervalDuration, @NonNull TimeUnit * before trying to emit the latest item from upstream again * @param unit the time unit * @return the new {@code Observable} instance + * @throws NullPointerException if {@code unit} is {@code null} * @see #throttleLatest(long, TimeUnit, boolean) * @see #throttleLatest(long, TimeUnit, Scheduler) * @since 2.2 @@ -13660,6 +14035,7 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit) * a timeout window active or not. If {@code false}, the very last * upstream item is ignored and the flow terminates. * @return the new {@code Observable} instance + * @throws NullPointerException if {@code unit} is {@code null} * @see #throttleLatest(long, TimeUnit, Scheduler, boolean) * @since 2.2 */ @@ -13690,9 +14066,10 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, * @param timeout the time to wait after an item emission towards the downstream * before trying to emit the latest item from upstream again * @param unit the time unit - * @param scheduler the {@link Scheduler} where the timed wait and latest item + * @param scheduler the {@code Scheduler} where the timed wait and latest item * emission will be performed * @return the new {@code Observable} instance + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see #throttleLatest(long, TimeUnit, Scheduler, boolean) * @since 2.2 */ @@ -13720,13 +14097,14 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, * @param timeout the time to wait after an item emission towards the downstream * before trying to emit the latest item from upstream again * @param unit the time unit - * @param scheduler the {@link Scheduler} where the timed wait and latest item + * @param scheduler the {@code Scheduler} where the timed wait and latest item * emission will be performed * @param emitLast If {@code true}, the very last item from the upstream will be emitted * immediately when the upstream completes, regardless if there is * a timeout window active or not. If {@code false}, the very last * upstream item is ignored and the flow terminates. * @return the new {@code Observable} instance + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @since 2.2 */ @CheckReturnValue @@ -13754,12 +14132,13 @@ public final Observable throttleLatest(long timeout, @NonNull TimeUnit unit, * * @param timeout * the length of the window of time that must pass after the emission of an item from the current - * {@code Observable} in which that {@code ObservableSource} emits no items in order for the item to be emitted by the + * {@code Observable}, in which the current {@code Observable} emits no items, in order for the item to be emitted by the * resulting {@code Observable} * @param unit * the unit of time for the specified {@code timeout} * @return an {@code Observable} that filters out items from the current {@code Observable} that are too quickly followed by * newer items + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Debounce * @see #debounce(long, TimeUnit) */ @@ -13773,7 +14152,7 @@ public final Observable throttleWithTimeout(long timeout, @NonNull TimeUnit u /** * Returns an {@code Observable} that mirrors the current {@code Observable}, except that it drops items emitted by the * current {@code Observable} that are followed by newer items before a timeout value expires on a specified - * Scheduler. The timer resets on each emission (Alias to {@link #debounce(long, TimeUnit, Scheduler)}). + * {@link Scheduler}. The timer resets on each emission (Alias to {@link #debounce(long, TimeUnit, Scheduler)}). *

* Note: If items keep being emitted by the current {@code Observable} faster than the timeout then no items * will be emitted by the resulting {@code Observable}. @@ -13781,20 +14160,21 @@ public final Observable throttleWithTimeout(long timeout, @NonNull TimeUnit u * *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param timeout * the length of the window of time that must pass after the emission of an item from the current - * {@code Observable} in which that {@code ObservableSource} emits no items in order for the item to be emitted by the + * {@code Observable}, in which the current {@code Observable} emits no items, in order for the item to be emitted by the * resulting {@code Observable} * @param unit * the unit of time for the specified {@code timeout} * @param scheduler - * the {@link Scheduler} to use internally to manage the timers that handle the timeout for each + * the {@code Scheduler} to use internally to manage the timers that handle the timeout for each * item * @return an {@code Observable} that filters out items from the current {@code Observable} that are too quickly followed by * newer items + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Debounce * @see #debounce(long, TimeUnit, Scheduler) */ @@ -13834,12 +14214,13 @@ public final Observable> timeInterval() { *
*
Scheduler:
*
The operator does not operate on any particular scheduler but uses the current time - * from the specified {@link Scheduler}.
+ * from the specified {@code Scheduler}. *
* * @param scheduler - * the {@link Scheduler} used to compute time intervals + * the {@code Scheduler} used to compute time intervals * @return an {@code Observable} that emits time interval information items + * @throws NullPointerException if {@code scheduler} is {@code null} * @see ReactiveX operators documentation: TimeInterval */ @CheckReturnValue @@ -13862,6 +14243,7 @@ public final Observable> timeInterval(@NonNull Scheduler scheduler) { * * @param unit the time unit for the current time * @return an {@code Observable} that emits time interval information items + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: TimeInterval */ @CheckReturnValue @@ -13873,19 +14255,20 @@ public final Observable> timeInterval(@NonNull TimeUnit unit) { /** * Returns an {@code Observable} that emits records of the time interval between consecutive items emitted by the - * current {@code Observable}, where this interval is computed on a specified Scheduler. + * current {@code Observable}, where this interval is computed on a specified {@link Scheduler}. *

* *

*
Scheduler:
*
The operator does not operate on any particular scheduler but uses the current time - * from the specified {@link Scheduler}.
+ * from the specified {@code Scheduler}. *
* * @param unit the time unit for the current time * @param scheduler - * the {@link Scheduler} used to compute time intervals + * the {@code Scheduler} used to compute time intervals * @return an {@code Observable} that emits time interval information items + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: TimeInterval */ @CheckReturnValue @@ -13899,8 +14282,8 @@ public final Observable> timeInterval(@NonNull TimeUnit unit, @NonNull /** * Returns an {@code Observable} that mirrors the current {@code Observable}, but notifies observers of a - * {@code TimeoutException} if an item emitted by the current {@code Observable} doesn't arrive within a window of - * time after the emission of the previous item, where that period of time is measured by an {@code ObservableSource} that + * {@link TimeoutException} if an item emitted by the current {@code Observable} doesn't arrive within a window of + * time after the emission of the previous item, where that period of time is measured by an {@link ObservableSource} that * is a function of the previous item. *

* @@ -13919,6 +14302,7 @@ public final Observable> timeInterval(@NonNull TimeUnit unit, @NonNull * @return an {@code Observable} that mirrors the current {@code Observable}, but notifies observers of a * {@code TimeoutException} if an item emitted by the current {@code Observable} takes longer to arrive than * the time window defined by the selector for the previously emitted item + * @throws NullPointerException if {@code itemTimeoutIndicator} is {@code null} * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue @@ -13929,7 +14313,7 @@ public final Observable timeout(@NonNull Function Observable timeout(@NonNull FunctionReactiveX operators documentation: Timeout */ @CheckReturnValue @@ -13966,7 +14351,7 @@ public final Observable timeout(@NonNull Function * *

@@ -13976,17 +14361,18 @@ public final Observable timeout(@NonNull FunctionReactiveX operators documentation: Timeout */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) @NonNull - public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit) { - return timeout0(timeout, timeUnit, null, Schedulers.computation()); + public final Observable timeout(long timeout, @NonNull TimeUnit unit) { + return timeout0(timeout, unit, null, Schedulers.computation()); } /** @@ -14003,19 +14389,20 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit) { * * @param timeout * maximum duration between items before a timeout occurs - * @param timeUnit + * @param unit * the unit of time that applies to the {@code timeout} argument * @param other * the fallback {@code ObservableSource} to use in case of a timeout * @return the current {@code Observable} modified to switch to the fallback {@code ObservableSource} in case of a timeout + * @throws NullPointerException if {@code unit} or {@code other} is {@code null} * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) @NonNull - public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonNull ObservableSource other) { + public final Observable timeout(long timeout, @NonNull TimeUnit unit, @NonNull ObservableSource other) { Objects.requireNonNull(other, "other is null"); - return timeout0(timeout, timeUnit, other, Schedulers.computation()); + return timeout0(timeout, unit, other, Schedulers.computation()); } /** @@ -14027,47 +14414,48 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No * *
*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param timeout * maximum duration between items before a timeout occurs - * @param timeUnit + * @param unit * the unit of time that applies to the {@code timeout} argument * @param scheduler - * the {@link Scheduler} to run the timeout timers on + * the {@code Scheduler} to run the timeout timers on * @param other * the {@code ObservableSource} to use as the fallback in case of a timeout * @return the current {@code Observable} modified so that it will switch to the fallback {@code ObservableSource} in case of a * timeout + * @throws NullPointerException if {@code unit}, {@code scheduler} or {@code other} is {@code null} * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) @NonNull - public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonNull Scheduler scheduler, @NonNull ObservableSource other) { + public final Observable timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull ObservableSource other) { Objects.requireNonNull(other, "other is null"); - return timeout0(timeout, timeUnit, other, scheduler); + return timeout0(timeout, unit, other, scheduler); } /** * Returns an {@code Observable} that mirrors the current {@code Observable} 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 + * item, where this policy is governed on a specified {@link Scheduler}. If the next item isn't emitted within the * specified timeout duration starting from its predecessor, the resulting {@code Observable} terminates and - * notifies observers of a {@code TimeoutException}. + * notifies observers of a {@link TimeoutException}. *

* *

*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param timeout * maximum duration between items before a timeout occurs - * @param timeUnit + * @param unit * the unit of time that applies to the {@code timeout} argument * @param scheduler - * the Scheduler to run the timeout timers on + * the {@code Scheduler} to run the timeout timers on * @return the current {@code Observable} modified to notify observers of a {@code TimeoutException} in case of a * timeout * @see ReactiveX operators documentation: Timeout @@ -14075,14 +14463,14 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) @NonNull - public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @NonNull Scheduler scheduler) { - return timeout0(timeout, timeUnit, null, scheduler); + public final Observable timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) { + return timeout0(timeout, unit, null, scheduler); } /** * Returns an {@code Observable} that mirrors the current {@code Observable}, but notifies observers of a - * {@code TimeoutException} if either the first item emitted by the current {@code Observable} or any subsequent item - * doesn't arrive within time windows defined by other {@code ObservableSource}s. + * {@link TimeoutException} if either the first item emitted by the current {@code Observable} or any subsequent item + * doesn't arrive within time windows defined by indicator {@link ObservableSource}s. *

* *

@@ -14104,6 +14492,7 @@ public final Observable timeout(long timeout, @NonNull TimeUnit timeUnit, @No * @return an {@code Observable} that mirrors the current {@code Observable}, but notifies observers of a * {@code TimeoutException} if either the first item or any subsequent item doesn't arrive within * the time windows specified by the timeout selectors + * @throws NullPointerException if {@code firstTimeoutIndicator} or {@code itemTimeoutIndicator} is {@code null} * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue @@ -14116,9 +14505,9 @@ public final Observable timeout(@NonNull ObservableSource firstTime } /** - * Returns an {@code Observable} that mirrors the current {@code Observable}, but switches to a fallback {@code ObservableSource} if either + * Returns an {@code Observable} that mirrors the current {@code Observable}, but switches to a fallback {@link ObservableSource} if either * the first item emitted by the current {@code Observable} or any subsequent item doesn't arrive within time windows - * defined by other {@code ObservableSource}s. + * defined by indicator {@code ObservableSource}s. *

* *

@@ -14143,8 +14532,7 @@ public final Observable timeout(@NonNull ObservableSource firstTime * either the first item emitted by the current {@code Observable} or any subsequent item doesn't arrive * within time windows defined by the timeout selectors * @throws NullPointerException - * if {@code itemTimeoutIndicator} is null, or - * if {@code other} is null + * if {@code firstTimeoutIndicator}, {@code itemTimeoutIndicator} or {@code other} is {@code null} * @see ReactiveX operators documentation: Timeout */ @CheckReturnValue @@ -14160,12 +14548,12 @@ public final Observable timeout( } @NonNull - private Observable timeout0(long timeout, @NonNull TimeUnit timeUnit, + private Observable timeout0(long timeout, @NonNull TimeUnit unit, @Nullable ObservableSource other, @NonNull Scheduler scheduler) { - Objects.requireNonNull(timeUnit, "timeUnit is null"); + Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return RxJavaPlugins.onAssembly(new ObservableTimeoutTimed<>(this, timeout, timeUnit, scheduler, other)); + return RxJavaPlugins.onAssembly(new ObservableTimeoutTimed<>(this, timeout, unit, scheduler, other)); } @NonNull @@ -14200,19 +14588,20 @@ public final Observable> timestamp() { /** * Returns an {@code Observable} that emits each item emitted by the current {@code Observable}, wrapped in a - * {@link Timed} object whose timestamps are provided by a specified Scheduler. + * {@link Timed} object whose timestamps are provided by a specified {@link Scheduler}. *

* *

*
Scheduler:
*
This operator does not operate on any particular scheduler but uses the current time - * from the specified {@link Scheduler}.
+ * from the specified {@code Scheduler}. *
* * @param scheduler - * the {@link Scheduler} to use as a time source + * the {@code Scheduler} to use as a time source * @return an {@code Observable} that emits timestamped items from the current {@code Observable} with timestamps provided by * the {@code scheduler} + * @throws NullPointerException if {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Timestamp */ @CheckReturnValue @@ -14235,6 +14624,7 @@ public final Observable> timestamp(@NonNull Scheduler scheduler) { * * @param unit the time unit for the current time * @return an {@code Observable} that emits timestamped items from the current {@code Observable} + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Timestamp */ @CheckReturnValue @@ -14246,20 +14636,21 @@ public final Observable> timestamp(@NonNull TimeUnit unit) { /** * Returns an {@code Observable} that emits each item emitted by the current {@code Observable}, wrapped in a - * {@link Timed} object whose timestamps are provided by a specified Scheduler. + * {@link Timed} object whose timestamps are provided by a specified {@link Scheduler}. *

* *

*
Scheduler:
*
This operator does not operate on any particular scheduler but uses the current time - * from the specified {@link Scheduler}.
+ * from the specified {@code Scheduler}. *
* * @param unit the time unit for the current time * @param scheduler - * the {@link Scheduler} to use as a time source + * the {@code Scheduler} to use as a time source * @return an {@code Observable} that emits timestamped items from the current {@code Observable} with timestamps provided by * the {@code scheduler} + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Timestamp */ @CheckReturnValue @@ -14283,7 +14674,7 @@ public final Observable> timestamp(@NonNull TimeUnit unit, @NonNull Sch * @param the resulting object type * @param converter the function that receives the current {@code Observable} instance and returns a value * @return the converted value - * @throws NullPointerException if converter is null + * @throws NullPointerException if {@code converter} is {@code null} * @since 2.2 */ @CheckReturnValue @@ -14294,12 +14685,12 @@ public final R to(@NonNull ObservableConverter converter) { } /** - * Returns a Single that emits a single item, a list composed of all the items emitted by the - * finite source ObservableSource. + * Returns a {@link Single} that emits a single item, a {@link List} composed of all the items emitted by the + * current and finite {@code Observable}. *

* *

- * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s + * Normally, an {@link ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the * {@code ObservableSource} to compose a list of all of these items and then to invoke the {@code Observer}'s {@code onNext} * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to @@ -14307,13 +14698,13 @@ public final R to(@NonNull ObservableConverter converter) { *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulated list to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toList} does not operate by default on a particular {@link Scheduler}.
*
* - * @return a Single that emits a single item: a List containing all of the items emitted by the current + * @return a {@code Single} that emits a single item: a {@code List} containing all of the items emitted by the current * {@code Observable} * @see ReactiveX operators documentation: To */ @@ -14325,12 +14716,12 @@ public final R to(@NonNull ObservableConverter converter) { } /** - * Returns a Single that emits a single item, a list composed of all the items emitted by the - * finite source ObservableSource. + * Returns a {@link Single} that emits a single item, a {@link List} composed of all the items emitted by the + * current and finite {@code Observable}. *

* *

- * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s + * Normally, an {@link ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the * {@code ObservableSource} to compose a list of all of these items and then to invoke the {@code Observer}'s {@code onNext} * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to @@ -14338,7 +14729,7 @@ public final R to(@NonNull ObservableConverter converter) { *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulated list to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toList} does not operate by default on a particular {@link Scheduler}.
@@ -14346,8 +14737,9 @@ public final R to(@NonNull ObservableConverter converter) { * * @param capacityHint * the number of elements expected from the current {@code Observable} - * @return a Single that emits a single item: a List containing all of the items emitted by the current + * @return a {@code Single} that emits a single item: a {@code List} containing all of the items emitted by the current * {@code Observable} + * @throws IllegalArgumentException if {@code capacityHint} is non-positive * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14359,12 +14751,12 @@ public final R to(@NonNull ObservableConverter converter) { } /** - * Returns a {@link Single} that emits a single item, a list composed of all the items emitted by the + * Returns a {@link Single} that emits a single item, a {@link Collection} (subclass) composed of all the items emitted by the * finite upstream {@code Observable}. *

* *

- * Normally, an {@code ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s + * Normally, an {@link ObservableSource} that returns multiple items will do so by invoking its {@link Observer}'s * {@link Observer#onNext onNext} method for each such item. You can change this behavior, instructing the * {@code ObservableSource} to compose a list of all of these items and then to invoke the {@code Observer}'s {@code onNext} * function once, passing it the entire list, by calling the {@code ObservableSource}'s {@code toList} method prior to @@ -14372,7 +14764,7 @@ public final R to(@NonNull ObservableConverter converter) { *

* Note that this operator requires the upstream to signal {@code onComplete} for the accumulated collection to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toList} does not operate by default on a particular {@link Scheduler}.
@@ -14380,9 +14772,10 @@ public final R to(@NonNull ObservableConverter converter) { * * @param the subclass of a collection of Ts * @param collectionSupplier - * the Supplier returning the collection (for each individual Observer) to be filled in - * @return a Single that emits a single item: a List containing all of the items emitted by the current + * the {@link Supplier} returning the collection (for each individual {@code Observer}) to be filled in + * @return a {@code Single} that emits a single item: a {@code Collection} (subclass) containing all of the items emitted by the current * {@code Observable} + * @throws NullPointerException if {@code collectionSupplier} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14394,17 +14787,17 @@ public final R to(@NonNull ObservableConverter converter) { } /** - * Returns a Single that emits a single HashMap containing all items emitted by the - * finite source {@code ObservableSource}, mapped by the keys returned by a specified + * Returns a {@link Single} that emits a single {@link HashMap} containing all items emitted by the + * current and finite {@code Observable}, mapped by the keys returned by a specified * {@code keySelector} function. *

* *

- * If more than one source item maps to the same key, the HashMap will contain the latest of those items. + * If more than one source item maps to the same key, the {@code HashMap} will contain the latest of those items. *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated map to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code HashMap} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toMap} does not operate by default on a particular {@link Scheduler}.
@@ -14412,9 +14805,10 @@ public final R to(@NonNull ObservableConverter converter) { * * @param the key type of the Map * @param keySelector - * the function that extracts the key from a source item to be used in the HashMap - * @return a Single that emits a single item: a HashMap containing the mapped items from the current + * the function that extracts the key from a source item to be used in the {@code HashMap} + * @return a {@code Single} that emits a single item: a {@code HashMap} containing the mapped items from the current * {@code Observable} + * @throws NullPointerException if {@code keySelector} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14427,29 +14821,30 @@ public final R to(@NonNull ObservableConverter converter) { /** * Returns a {@link Single} that emits a single {@link HashMap} containing values corresponding to items emitted by the - * current and finite {@code Observable}, mapped by the keys returned by a specified {@code keySelector} function. + * current and finite {@code Observable}, mapped by the keys and values returned by the given selector functions. *

* *

- * If more than one source item maps to the same key, the HashMap will contain a single entry that + * If more than one source item maps to the same key, the {@code HashMap} will contain a single entry that * corresponds to the latest of those items. *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated map to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code HashMap} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toMap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the key type of the Map - * @param the value type of the Map + * @param the key type of the {@code HashMap} + * @param the value type of the {@code HashMap} * @param keySelector * the function that extracts the key from a source item to be used in the {@code HashMap} * @param valueSelector * the function that extracts the value from a source item to be used in the {@code HashMap} - * @return a Single that emits a single item: a HashMap containing the mapped items from the current + * @return a {@code Single} that emits a single item: a {@code HashMap} containing the mapped items from the current * {@code Observable} + * @throws NullPointerException if {@code keySelector} or {@code valueSelector} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14464,29 +14859,30 @@ public final Single> toMap( } /** - * Returns a Single that emits a single Map, returned by a specified {@code mapFactory} function, that - * contains keys and values extracted from the items emitted by the finite source ObservableSource. + * Returns a {@link Single} that emits a single {@link Map} (subclass), returned by a specified {@code mapFactory} function, that + * contains keys and values extracted from the items, via selector functions, emitted by the current and finite {@code Observable}. *

* *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated map to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code Map} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toMap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the key type of the Map - * @param the value type of the Map + * @param the key type of the {@code Map} + * @param the value type of the {@code Map} * @param keySelector - * the function that extracts the key from a source item to be used in the Map + * the function that extracts the key from a source item to be used in the {@code Map} * @param valueSelector - * the function that extracts the value from the source items to be used as value in the Map + * the function that extracts the value from the source items to be used as value in the {@code Map} * @param mapSupplier - * the function that returns a Map instance to be used - * @return a Single that emits a single item: a Map that contains the mapped items emitted by the + * the function that returns a {@code Map} instance to be used + * @return a {@code Single} that emits a single item: a {@code Map} (subclass) that contains the mapped items emitted by the * current {@code Observable} + * @throws NullPointerException if {@code keySelector}, {@code valueSelector} or {@code mapSupplier} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14503,24 +14899,25 @@ public final Single> toMap( } /** - * Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the - * finite source {@code ObservableSource} keyed by a specified {@code keySelector} function. + * Returns a {@link Single} that emits a single {@link HashMap} that contains an {@link ArrayList} of items emitted by the + * current and finite {@code Observable} keyed by a specified {@code keySelector} function. *

* *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated map to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code HashMap} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toMultimap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the key type of the Map + * @param the key type of the {@code HashMap} * @param keySelector - * the function that extracts the key from the source items to be used as key in the HashMap - * @return a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from + * the function that extracts the key from the source items to be used as key in the {@code HashMap} + * @return a {@code Single} that emits a single item: a {@code HashMap} that contains an {@code ArrayList} of items mapped from * the current {@code Observable} + * @throws NullPointerException if {@code keySelector} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14534,28 +14931,29 @@ public final Single> toMap( } /** - * Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a - * specified {@code valueSelector} function from items emitted by the finite source {@code ObservableSource}, + * Returns a {@link Single} that emits a single {@link HashMap} that contains an {@link ArrayList} of values extracted by a + * specified {@code valueSelector} function from items emitted by the current and finite {@code Observable}, * keyed by a specified {@code keySelector} function. *

* *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated map to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code HashMap} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toMultimap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the key type of the Map - * @param the value type of the Map + * @param the key type of the {@code HashMap} + * @param the value type of the {@code HashMap} * @param keySelector - * the function that extracts a key from the source items to be used as key in the HashMap + * the function that extracts a key from the source items to be used as key in the {@code HashMap} * @param valueSelector - * the function that extracts a value from the source items to be used as value in the HashMap - * @return a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from + * the function that extracts a value from the source items to be used as value in the {@code HashMap} + * @return a {@code Single} that emits a single item: a {@code HashMap} that contains an {@code ArrayList} of items mapped from * the current {@code Observable} + * @throws NullPointerException if {@code keySelector} or {@code valueSelector} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14568,28 +14966,33 @@ public final Single> toMap( } /** - * Returns a Single that emits a single Map, returned by a specified {@code mapFactory} function, that - * contains a custom collection of values, extracted by a specified {@code valueSelector} function from - * items emitted by the current {@code Observable}, and keyed by the {@code keySelector} function. + * Returns a {@link Single} that emits a single {@code Map} (subclass), returned by a specified {@code mapFactory} function, that + * contains a custom {@link Collection} of values, extracted by a specified {@code valueSelector} function from + * items emitted by the current and finite {@code Observable}, and keyed by the {@code keySelector} function. *

* + *

+ * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code Map} to + * be emitted. Sources that are infinite and never complete will never emit anything through this + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toMultimap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the key type of the Map - * @param the value type of the Map + * @param the key type of the {@code Map} + * @param the value type of the {@code Map} * @param keySelector - * the function that extracts a key from the source items to be used as the key in the Map + * the function that extracts a key from the source items to be used as the key in the {@code Map} * @param valueSelector - * the function that extracts a value from the source items to be used as the value in the Map + * the function that extracts a value from the source items to be used as the value in the {@code Map} * @param mapSupplier - * the function that returns a Map instance to be used + * the function that returns a {@code Map} instance to be used * @param collectionFactory - * the function that returns a Collection instance for a particular key to be used in the Map - * @return a Single that emits a single item: a Map that contains the collection of mapped items from + * the function that returns a {@code Collection} instance for a particular key to be used in the {@code Map} + * @return a {@code Single} that emits a single item: a {@code Map} that contains the {@code Collection} of mapped items from * the current {@code Observable} + * @throws NullPointerException if {@code keySelector}, {@code valueSelector}, {@code mapSupplier} or {@code collectionFactory} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14608,30 +15011,31 @@ public final Single> toMap( } /** - * Returns a Single that emits a single Map, returned by a specified {@code mapFactory} function, that - * contains an ArrayList of values, extracted by a specified {@code valueSelector} function from items - * emitted by the finite source {@code ObservableSource} and keyed by the {@code keySelector} function. + * Returns a {@link Single} that emits a single {@link Map} (subclass), returned by a specified {@code mapFactory} function, that + * contains an {@link ArrayList} of values, extracted by a specified {@code valueSelector} function from items + * emitted by the current and finite {@code Observable} and keyed by the {@code keySelector} function. *

* *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated map to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code Map} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toMultimap} does not operate by default on a particular {@link Scheduler}.
*
* - * @param the key type of the Map - * @param the value type of the Map + * @param the key type of the {@code Map} + * @param the value type of the {@code Map} * @param keySelector - * the function that extracts a key from the source items to be used as the key in the Map + * the function that extracts a key from the source items to be used as the key in the {@code Map} * @param valueSelector - * the function that extracts a value from the source items to be used as the value in the Map + * the function that extracts a value from the source items to be used as the value in the {@code Map} * @param mapSupplier - * the function that returns a Map instance to be used - * @return a Single that emits a single item: a Map that contains a list items mapped from the current + * the function that returns a {@code Map} instance to be used + * @return a {@code Single} that emits a single item: a {@code Map} that contains an {@code ArrayList} items mapped from the current * {@code Observable} + * @throws NullPointerException if {@code keySelector}, {@code valueSelector} or {@code mapSupplier} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14646,7 +15050,7 @@ public final Single> toMap( } /** - * Converts the current {@code Observable} into a Flowable by applying the specified backpressure strategy. + * Converts the current {@code Observable} into a {@link Flowable} by applying the specified backpressure strategy. *

* Marble diagrams for the various backpressure strategies are as follows: *

    @@ -14679,15 +15083,16 @@ public final Single> toMap( *
* * @param strategy the backpressure strategy to apply - * @return the new Flowable instance + * @return the new {@code Flowable} instance + * @throws NullPointerException if {@code strategy} is {@code null} */ @BackpressureSupport(BackpressureKind.SPECIAL) @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @NonNull public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { + Objects.requireNonNull(strategy, "strategy is null"); Flowable f = new FlowableFromObservable<>(this); - switch (strategy) { case DROP: return f.onBackpressureDrop(); @@ -14703,27 +15108,29 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a - * sorted order. Each item emitted by the {@code ObservableSource} must implement {@link Comparable} with respect to all + * Returns a {@link Single} that emits a {@link List} that contains the items emitted by the current and finite {@code Observable}, in a + * sorted order. Each item emitted by the current {@code Observable} must implement {@link Comparable} with respect to all * other items in the sequence. * *

- * If any item emitted by the current {@code Observable} does not implement {@link Comparable} with respect to + * If any item emitted by the current {@code Observable} does not implement {@code Comparable} with respect to * all other items emitted by the current {@code Observable}, no items will be emitted and the * sequence is terminated with a {@link ClassCastException}. *

* *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated list to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code List} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toSortedList} does not operate by default on a particular {@link Scheduler}.
*
- * @return a Single that emits a list that contains the items emitted by the current {@code Observable} in + * @return a {@code Single} that emits a list that contains the items emitted by the current {@code Observable} in * sorted order * @see ReactiveX operators documentation: To + * @see #toSortedList(int) + * @see #toSortedList(Comparator) */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -14733,24 +15140,25 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a + * Returns a {@link Single} that emits a {@link List} that contains the items emitted by the current and finite {@code Observable}, in a * sorted order based on a specified comparison function. *

* *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated list to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code List} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toSortedList} does not operate by default on a particular {@link Scheduler}.
*
* * @param comparator - * a function that compares two items emitted by the current {@code Observable} and returns an Integer + * a function that compares two items emitted by the current {@code Observable} and returns an {@code int} * that indicates their sort order - * @return a Single that emits a list that contains the items emitted by the current {@code Observable} in + * @return a {@code Single} that emits a {@code List} that contains the items emitted by the current {@code Observable} in * sorted order + * @throws NullPointerException if {@code comparator} is {@code null} * @see ReactiveX operators documentation: To */ @CheckReturnValue @@ -14762,26 +15170,28 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a + * Returns a {@link Single} that emits a {@link List} that contains the items emitted by the current and finite {@code Observable}, in a * sorted order based on a specified comparison function. *

* *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated list to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code List} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toSortedList} does not operate by default on a particular {@link Scheduler}.
*
* * @param comparator - * a function that compares two items emitted by the current {@code Observable} and returns an Integer + * a function that compares two items emitted by the current {@code Observable} and returns an {@code int} * that indicates their sort order * @param capacityHint - * the initial capacity of the ArrayList used to accumulate items before sorting - * @return a Single that emits a list that contains the items emitted by the current {@code Observable} in + * the initial capacity of the {@code List} used to accumulate items before sorting + * @return a {@code Single} that emits a {@code List} that contains the items emitted by the current {@code Observable} in * sorted order + * @throws NullPointerException if {@code comparator} is {@code null} + * @throws IllegalArgumentException if {@code capacityHint} is non-positive * @see ReactiveX operators documentation: To * @since 2.0 */ @@ -14794,30 +15204,32 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { } /** - * Returns a Single that emits a list that contains the items emitted by the finite source {@code ObservableSource}, in a - * sorted order. Each item emitted by the {@code ObservableSource} must implement {@link Comparable} with respect to all + * Returns a {@link Single} that emits a {@link List} that contains the items emitted by the current and finite {@code Observable}, in a + * sorted order. Each item emitted by the current {@code Observable} must implement {@link Comparable} with respect to all * other items in the sequence. *

- * If any item emitted by the current {@code Observable} does not implement {@link Comparable} with respect to + * If any item emitted by the current {@code Observable} does not implement {@code Comparable} with respect to * all other items emitted by the current {@code Observable}, no items will be emitted and the * sequence is terminated with a {@link ClassCastException}. *

* *

- * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated list to + * Note that this operator requires the upstream to signal {@code onComplete} for the accumulated {@code List} to * be emitted. Sources that are infinite and never complete will never emit anything through this - * operator and an infinite source may lead to a fatal {@code OutOfMemoryError}. + * operator and an infinite source may lead to a fatal {@link OutOfMemoryError}. *

*
Scheduler:
*
{@code toSortedList} does not operate by default on a particular {@link Scheduler}.
*
* * @param capacityHint - * the initial capacity of the ArrayList used to accumulate items before sorting - * @return a Single that emits a list that contains the items emitted by the current {@code Observable} in + * the initial capacity of the {@code List} used to accumulate items before sorting + * @return a {@code Single} that emits a {@code List} that contains the items emitted by the current {@code Observable} in * sorted order + * @throws IllegalArgumentException if {@code capacityHint} is non-positive * @see ReactiveX operators documentation: To * @since 2.0 + * @see #toSortedList(Comparator, int) */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) @@ -14833,12 +15245,13 @@ public final Flowable toFlowable(@NonNull BackpressureStrategy strategy) { * *
*
Scheduler:
- *
You specify which {@link Scheduler} this operator will use.
+ *
You specify which {@code Scheduler} this operator will use.
*
* * @param scheduler - * the {@link Scheduler} to perform the call to {@code dispose()} of the upstream {@link Disposable} + * the {@code Scheduler} to perform the call to {@code dispose()} of the upstream {@link Disposable} * @return the new {@code Observable} instance + * @throws NullPointerException if {@code scheduler} is {@code null} * @see ReactiveX operators documentation: SubscribeOn */ @CheckReturnValue @@ -14865,7 +15278,7 @@ public final Observable unsubscribeOn(@NonNull Scheduler scheduler) { * the maximum size of each window before it should be emitted * @return an {@code Observable} that emits connected, non-overlapping windows, each containing at most * {@code count} items from the current {@code Observable} - * @throws IllegalArgumentException if either count is non-positive + * @throws IllegalArgumentException if {@code count} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -14894,7 +15307,7 @@ public final Observable> window(long count) { * {@code count} are equal this is the same operation as {@link #window(long)}. * @return an {@code Observable} that emits windows every {@code skip} items containing at most {@code count} items * from the current {@code Observable} - * @throws IllegalArgumentException if either count or skip is non-positive + * @throws IllegalArgumentException if {@code count} or {@code skip} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -14925,7 +15338,7 @@ public final Observable> window(long count, long skip) { * the capacity hint for the buffer in the inner windows * @return an {@code Observable} that emits windows every {@code skip} items containing at most {@code count} items * from the current {@code Observable} - * @throws IllegalArgumentException if either count or skip is non-positive + * @throws IllegalArgumentException if {@code count}, {@code skip} or {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -14963,6 +15376,8 @@ public final Observable> window(long count, long skip, int bufferS * @param unit * the unit of time that applies to the {@code timespan} and {@code timeskip} arguments * @return an {@code Observable} that emits new windows periodically as a fixed timespan elapses + * @throws NullPointerException if {@code unit} is {@code null} + * @throws IllegalArgumentException if {@code timespan} or {@code timeskip} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -14997,8 +15412,10 @@ public final Observable> window(long timespan, long timeskip, @Non * @param unit * the unit of time that applies to the {@code timespan} and {@code timeskip} arguments * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a window + * the {@code Scheduler} to use when determining the end and start of a window * @return an {@code Observable} that emits new windows periodically as a fixed timespan elapses + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException if {@code timespan} or {@code timeskip} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15033,10 +15450,12 @@ public final Observable> window(long timespan, long timeskip, @Non * @param unit * the unit of time that applies to the {@code timespan} and {@code timeskip} arguments * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a window + * the {@code Scheduler} to use when determining the end and start of a window * @param bufferSize * the capacity hint for the buffer in the inner windows * @return an {@code Observable} that emits new windows periodically as a fixed timespan elapses + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException if {@code timespan}, {@code timeskip} or {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15075,6 +15494,7 @@ public final Observable> window(long timespan, long timeskip, @Non * the unit of time that applies to the {@code timespan} argument * @return an {@code Observable} that emits connected, non-overlapping windows representing items emitted by the * current {@code Observable} during fixed, consecutive durations + * @throws NullPointerException if {@code unit} is {@code null} * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15112,6 +15532,8 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) + * @throws NullPointerException if {@code unit} is {@code null} + * @throws IllegalArgumentException if {@code count} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15152,6 +15574,8 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) + * @throws NullPointerException if {@code unit} is {@code null} + * @throws IllegalArgumentException if {@code count} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15185,9 +15609,10 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @param unit * the unit of time which applies to the {@code timespan} argument * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a window + * the {@code Scheduler} to use when determining the end and start of a window * @return an {@code Observable} that emits connected, non-overlapping windows containing items emitted by the * current {@code Observable} within a fixed duration + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15224,10 +15649,12 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @param count * the maximum size of each window before it should be emitted * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a window + * the {@code Scheduler} to use when determining the end and start of a window * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException if {@code count} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15264,12 +15691,14 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @param count * the maximum size of each window before it should be emitted * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a window + * the {@code Scheduler} to use when determining the end and start of a window * @param restart * if {@code true}, when a window reaches the capacity limit, the timer is restarted as well * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException if {@code count} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15306,7 +15735,7 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @param count * the maximum size of each window before it should be emitted * @param scheduler - * the {@link Scheduler} to use when determining the end and start of a window + * the {@code Scheduler} to use when determining the end and start of a window * @param restart * if {@code true}, when a window reaches the capacity limit, the timer is restarted as well * @param bufferSize @@ -15314,6 +15743,8 @@ public final Observable> window(long timespan, @NonNull TimeUnit u * @return an {@code Observable} that emits connected, non-overlapping windows of items from the current {@code Observable} * that were emitted during a fixed duration of time or when the window has reached maximum capacity * (whichever occurs first) + * @throws NullPointerException if {@code unit} or {@code scheduler} is {@code null} + * @throws IllegalArgumentException if {@code count} or {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15332,7 +15763,7 @@ public final Observable> window( /** * Returns an {@code Observable} that emits non-overlapping windows of items it collects from the current {@code Observable} * where the boundary of each window is determined by the items emitted from a specified boundary-governing - * ObservableSource. + * {@link ObservableSource}. *

* *

@@ -15352,6 +15783,7 @@ public final Observable> window( * @return an {@code Observable} that emits non-overlapping windows of items it collects from the current {@code Observable} * where the boundary of each window is determined by the items emitted from the {@code boundary} * {@code ObservableSource} + * @throws NullPointerException if {@code boundary} is {@code null} * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15364,7 +15796,7 @@ public final Observable> window(@NonNull ObservableSource b /** * Returns an {@code Observable} that emits non-overlapping windows of items it collects from the current {@code Observable} * where the boundary of each window is determined by the items emitted from a specified boundary-governing - * ObservableSource. + * {@link ObservableSource}. *

* *

@@ -15386,6 +15818,8 @@ public final Observable> window(@NonNull ObservableSource b * @return an {@code Observable} that emits non-overlapping windows of items it collects from the current {@code Observable} * where the boundary of each window is determined by the items emitted from the {@code boundary} * {@code ObservableSource} + * @throws NullPointerException if {@code boundary} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15400,7 +15834,7 @@ public final Observable> window(@NonNull ObservableSource b /** * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting * {@code Observable} emits windows that contain those items emitted by the current {@code Observable} between the time when - * the {@code openingIndicator} {@code ObservableSource} emits an item and when the {@code ObservableSource} returned by + * the {@code openingIndicator} {@link ObservableSource} emits an item and when the {@code ObservableSource} returned by * {@code closingIndicator} emits an item. *

* @@ -15423,6 +15857,7 @@ public final Observable> window(@NonNull ObservableSource b * emits an item, the associated window is completed * @return an {@code Observable} that emits windows of items emitted by the current {@code Observable} that are governed by * the specified window-governing {@code ObservableSource}s + * @throws NullPointerException if {@code openingIndicator} or {@code closingIndicator} is {@code null} * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15437,7 +15872,7 @@ public final Observable> window( /** * Returns an {@code Observable} that emits windows of items it collects from the current {@code Observable}. The resulting * {@code Observable} emits windows that contain those items emitted by the current {@code Observable} between the time when - * the {@code openingIndicator} {@code ObservableSource} emits an item and when the {@code ObservableSource} returned by + * the {@code openingIndicator} {@link ObservableSource} emits an item and when the {@code ObservableSource} returned by * {@code closingIndicator} emits an item. *

* @@ -15462,6 +15897,8 @@ public final Observable> window( * the capacity hint for the buffer in the inner windows * @return an {@code Observable} that emits windows of items emitted by the current {@code Observable} that are governed by * the specified window-governing {@code ObservableSource}s + * @throws NullPointerException if {@code openingIndicator} or {@code closingIndicator} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @see ReactiveX operators documentation: Window */ @CheckReturnValue @@ -15477,7 +15914,7 @@ public final Observable> window( } /** - * Merges the specified {@code ObservableSource} into the current {@code Observable} sequence by using the {@code resultSelector} + * Merges the specified {@link ObservableSource} into the current {@code Observable} sequence by using the {@code resultSelector} * function only when the current {@code Observable} emits an item. *

* @@ -15497,6 +15934,7 @@ public final Observable> window( * @return an {@code Observable} that merges the specified {@code ObservableSource} into the current {@code Observable} by using the * {@code resultSelector} function only when the current {@code Observable} sequence (this instance) emits an * item + * @throws NullPointerException if {@code other} or {@code combiner} is {@code null} * @since 2.0 * @see ReactiveX operators documentation: CombineLatest */ @@ -15512,7 +15950,7 @@ public final Observable withLatestFrom(@NonNull ObservableSourceNote that this operator doesn't emit anything until all other sources have produced at * least one value. The resulting emission only happens when the current {@code Observable} emits (and @@ -15532,6 +15970,7 @@ public final Observable withLatestFrom(@NonNull ObservableSource Observable withLatestFrom( /** * Combines the value emission from the current {@code Observable} with the latest emissions from the - * other {@code ObservableSource}s via a function to produce the output item. + * other {@link ObservableSource}s via a function to produce the output item. * *

Note that this operator doesn't emit anything until all other sources have produced at * least one value. The resulting emission only happens when the current {@code Observable} emits (and @@ -15571,6 +16010,7 @@ public final Observable withLatestFrom( * @param source3 the third other {@code ObservableSource} * @param combiner the function called with an array of values from each participating {@code ObservableSource} * @return the new {@code Observable} instance + * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3} or {@code combiner} is {@code null} * @since 2.0 */ @CheckReturnValue @@ -15590,7 +16030,7 @@ public final Observable withLatestFrom( /** * Combines the value emission from the current {@code Observable} with the latest emissions from the - * other {@code ObservableSource}s via a function to produce the output item. + * other {@link ObservableSource}s via a function to produce the output item. * *

Note that this operator doesn't emit anything until all other sources have produced at * least one value. The resulting emission only happens when the current {@code Observable} emits (and @@ -15614,6 +16054,8 @@ public final Observable withLatestFrom( * @param source4 the fourth other {@code ObservableSource} * @param combiner the function called with an array of values from each participating {@code ObservableSource} * @return the new {@code Observable} instance + * @throws NullPointerException if {@code source1}, {@code source2}, {@code source3}, + * {@code source4} or {@code combiner} is {@code null} * @since 2.0 */ @CheckReturnValue @@ -15634,7 +16076,7 @@ public final Observable withLatestFrom( /** * Combines the value emission from the current {@code Observable} with the latest emissions from the - * other {@code ObservableSource}s via a function to produce the output item. + * other {@link ObservableSource}s via a function to produce the output item. * *

Note that this operator doesn't emit anything until all other sources have produced at * least one value. The resulting emission only happens when the current {@code Observable} emits (and @@ -15651,6 +16093,7 @@ public final Observable withLatestFrom( * @param others the array of other sources * @param combiner the function called with an array of values from each participating {@code ObservableSource} * @return the new {@code Observable} instance + * @throws NullPointerException if {@code others} or {@code combiner} is {@code null} * @since 2.0 */ @CheckReturnValue @@ -15664,11 +16107,11 @@ public final Observable withLatestFrom(@NonNull ObservableSource[] oth /** * Combines the value emission from the current {@code Observable} with the latest emissions from the - * other {@code ObservableSource}s via a function to produce the output item. + * other {@link ObservableSource}s via a function to produce the output item. * *

Note that this operator doesn't emit anything until all other sources have produced at * least one value. The resulting emission only happens when the current {@code Observable} emits (and - * not when any of the other sources emit, unlike combineLatest). + * not when any of the other sources emit, unlike {@code combineLatest}). * If a source doesn't produce any value and just completes, the sequence is completed immediately. *

* @@ -15681,6 +16124,7 @@ public final Observable withLatestFrom(@NonNull ObservableSource[] oth * @param others the iterable of other sources * @param combiner the function called with an array of values from each participating {@code ObservableSource} * @return the new {@code Observable} instance + * @throws NullPointerException if {@code others} or {@code combiner} is {@code null} * @since 2.0 */ @CheckReturnValue @@ -15694,11 +16138,11 @@ public final Observable withLatestFrom(@NonNull Iterable * *

- * Note that the {@code other} Iterable is evaluated as items are observed from the current {@code Observable}; it is + * Note that the {@code other} {@code Iterable} is evaluated as items are observed from the current {@code Observable}; it is * not pre-consumed. This allows you to zip infinite streams on either side. *

*
Scheduler:
@@ -15706,16 +16150,17 @@ public final Observable withLatestFrom(@NonNull Iterable * * @param - * the type of items in the {@code other} Iterable + * the type of items in the {@code other} {@code Iterable} * @param * the type of items emitted by the resulting {@code Observable} * @param other - * the Iterable sequence + * the {@code Iterable} sequence * @param zipper - * a function that combines the pairs of items from the {@code ObservableSource} and the Iterable to generate + * a function that combines the pairs of items from the current {@code Observable} and the {@code Iterable} to generate * the items to be emitted by the resulting {@code Observable} - * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} Iterable + * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} {@code Iterable} * sequence and emits the results of {@code zipFunction} applied to these pairs + * @throws NullPointerException if {@code other} or {@code zipper} is {@code null} * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -15729,7 +16174,7 @@ public final Observable zipWith(@NonNull Iterable other, @NonNull B /** * Returns an {@code Observable} that emits items that are the result of applying a specified function to pairs of - * values, one each from the current {@code Observable} and another specified ObservableSource. + * values, one each from the current {@code Observable} and another specified {@link ObservableSource}. *

* *

@@ -15756,10 +16201,11 @@ public final Observable zipWith(@NonNull Iterable other, @NonNull B * @param other * the other {@code ObservableSource} * @param zipper - * a function that combines the pairs of items from the two {@code ObservableSource}s to generate the items to + * a function that combines the pairs of items from the current {@code Observable} and the other {@code ObservableSource} to generate the items to * be emitted by the resulting {@code Observable} * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} {@code ObservableSource} * and emits the results of {@code zipFunction} applied to these pairs + * @throws NullPointerException if {@code other} or {@code zipper} is {@code null} * @see ReactiveX operators documentation: Zip */ @CheckReturnValue @@ -15773,7 +16219,7 @@ public final Observable zipWith(@NonNull ObservableSource /** * Returns an {@code Observable} that emits items that are the result of applying a specified function to pairs of - * values, one each from the current {@code Observable} and another specified ObservableSource. + * values, one each from the current {@code Observable} and another specified {@link ObservableSource}. *

* *

@@ -15800,12 +16246,13 @@ public final Observable zipWith(@NonNull ObservableSource * @param other * the other {@code ObservableSource} * @param zipper - * a function that combines the pairs of items from the two {@code ObservableSource}s to generate the items to + * a function that combines the pairs of items from the current {@code Observable} and the other {@code ObservableSource} to generate the items to * be emitted by the resulting {@code Observable} * @param delayError * if {@code true}, errors from the current {@code Observable} or the other {@code ObservableSource} is delayed until both terminate * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} {@code ObservableSource} * and emits the results of {@code zipFunction} applied to these pairs + * @throws NullPointerException if {@code other} or {@code zipper} is {@code null} * @see ReactiveX operators documentation: Zip * @since 2.0 */ @@ -15819,7 +16266,7 @@ public final Observable zipWith(@NonNull ObservableSource /** * Returns an {@code Observable} that emits items that are the result of applying a specified function to pairs of - * values, one each from the current {@code Observable} and another specified ObservableSource. + * values, one each from the current {@code Observable} and another specified {@link ObservableSource}. *

* *

@@ -15846,7 +16293,7 @@ public final Observable zipWith(@NonNull ObservableSource * @param other * the other {@code ObservableSource} * @param zipper - * a function that combines the pairs of items from the two {@code ObservableSource}s to generate the items to + * a function that combines the pairs of items from the current {@code Observable} and the other {@code ObservableSource} to generate the items to * be emitted by the resulting {@code Observable} * @param bufferSize * the capacity hint for the buffer in the inner windows @@ -15855,6 +16302,8 @@ public final Observable zipWith(@NonNull ObservableSource * @return an {@code Observable} that pairs up values from the current {@code Observable} and the {@code other} {@code ObservableSource} * and emits the results of {@code zipFunction} applied to these pairs * @see ReactiveX operators documentation: Zip + * @throws NullPointerException if {@code other} or {@code zipper} is {@code null} + * @throws IllegalArgumentException if {@code bufferSize} is non-positive * @since 2.0 */ @CheckReturnValue @@ -15874,7 +16323,7 @@ public final Observable zipWith(@NonNull ObservableSource *

Scheduler:
*
{@code test} does not operate by default on a particular {@link Scheduler}.
*
- * @return the new TestObserver instance + * @return the new {@code TestObserver} instance * @since 2.0 */ @CheckReturnValue @@ -15896,7 +16345,7 @@ public final TestObserver test() { // NoPMD *
* @param dispose indicates if the {@code TestObserver} should be disposed before * it is subscribed to the current {@code Observable} - * @return the new TestObserver instance + * @return the new {@code TestObserver} instance * @since 2.0 */ @CheckReturnValue @@ -15934,6 +16383,7 @@ public final TestObserver test(boolean dispose) { // NoPMD * @param the element type of the optional value * @param optional the optional value to convert into an {@code Observable} * @return the new {@code Observable} instance + * @throws NullPointerException if {@code optional} is {@code null} * @since 3.0.0 * @see #just(Object) * @see #empty() @@ -15966,9 +16416,10 @@ public final TestObserver test(boolean dispose) { // NoPMD *
Scheduler:
*
{@code fromCompletionStage} does not operate by default on a particular {@link Scheduler}.
*
- * @param the element type of the CompletionStage - * @param stage the CompletionStage to convert to {@code Observable} and signal its terminal value or error + * @param the element type of the {@code CompletionStage} + * @param stage the {@code CompletionStage} to convert to {@code Observable} and signal its terminal value or error * @return the new {@code Observable} instance + * @throws NullPointerException if {@code stage} is {@code null} * @since 3.0.0 */ @CheckReturnValue @@ -15984,7 +16435,7 @@ public final TestObserver test(boolean dispose) { // NoPMD *

* *

- * The operator closes the {@code Stream} upon cancellation and when it terminates. Exceptions raised when + * The operator closes the {@code Stream} upon cancellation and when it terminates. The exceptions raised when * closing a {@code Stream} are routed to the global error handler ({@link RxJavaPlugins#onError(Throwable)}. * If a {@code Stream} should not be closed, turn it into an {@link Iterable} and use {@link #fromIterable(Iterable)}: * 


@@ -16010,6 +16461,7 @@ public final TestObserver test(boolean dispose) { // NoPMD
      * @param  the element type of the source {@code Stream}
      * @param stream the {@code Stream} of values to emit
      * @return the new {@code Observable} instance
+     * @throws NullPointerException if {@code stream} is {@code null}
      * @since 3.0.0
      * @see #fromIterable(Iterable)
      */
@@ -16030,10 +16482,11 @@ public final TestObserver test(boolean dispose) { // NoPMD
      *  
Scheduler:

      *  
{@code mapOptional} does not operate by default on a particular {@link Scheduler}.

      *
- * @param the non-null output type + * @param the non-{@code null} output type * @param mapper the function that receives the upstream item and should return a non-empty {@code Optional} * to emit as the output or an empty {@code Optional} to skip to the next upstream value * @return the new {@code Observable} instance + * @throws NullPointerException if {@code mapper} is {@code null} * @since 3.0.0 * @see #map(Function) * @see #filter(Predicate) @@ -16047,8 +16500,8 @@ public final TestObserver test(boolean dispose) { // NoPMD } /** - * Collects the finite upstream's values into a container via a Stream {@link Collector} callback set and emits - * it as the success result. + * Collects the finite upstream's values into a container via a {@link Stream} {@link Collector} callback set and emits + * it as the success result as a {@link Single}. *

* * @@ -16056,11 +16509,12 @@ public final TestObserver test(boolean dispose) { // NoPMD *

Scheduler:
*
{@code collect} does not operate by default on a particular {@link Scheduler}.
*
- * @param the non-null result type + * @param the non-{@code null} result type * @param the intermediate container type used for the accumulation * @param collector the interface defining the container supplier, accumulator and finisher functions; * see {@link Collectors} for some standard implementations - * @return the new Single instance + * @return the new {@code Single} instance + * @throws NullPointerException if {@code collector} is {@code null} * @since 3.0.0 * @see Collectors * @see #collect(Supplier, BiConsumer) @@ -16095,7 +16549,8 @@ public final TestObserver test(boolean dispose) { // NoPMD *
{@code firstStage} does not operate by default on a particular {@link Scheduler}.
*
* @param defaultItem the item to signal if the upstream is empty - * @return the new CompletionStage instance + * @return the new {@code CompletionStage} instance + * @throws NullPointerException if {@code defaultItem} is {@code null} * @since 3.0.0 * @see #firstOrErrorStage() */ @@ -16129,7 +16584,8 @@ public final CompletionStage firstStage(@Nullable T defaultItem) { *
{@code singleStage} does not operate by default on a particular {@link Scheduler}.
*
* @param defaultItem the item to signal if the upstream is empty - * @return the new CompletionStage instance + * @return the new {@code CompletionStage} instance + * @throws NullPointerException if {@code defaultItem} is {@code null} * @since 3.0.0 * @see #singleOrErrorStage() */ @@ -16162,7 +16618,8 @@ public final CompletionStage singleStage(@Nullable T defaultItem) { *
{@code lastStage} does not operate by default on a particular {@link Scheduler}.
*
* @param defaultItem the item to signal if the upstream is empty - * @return the new CompletionStage instance + * @return the new {@code CompletionStage} instance + * @throws NullPointerException if {@code defaultItem} is {@code null} * @since 3.0.0 * @see #lastOrErrorStage() */ @@ -16188,7 +16645,7 @@ public final CompletionStage lastStage(@Nullable T defaultItem) { *
Scheduler:
*
{@code firstOrErrorStage} does not operate by default on a particular {@link Scheduler}.
*
- * @return the new CompletionStage instance + * @return the new {@code CompletionStage} instance * @since 3.0.0 * @see #firstStage(Object) */ @@ -16215,7 +16672,7 @@ public final CompletionStage firstOrErrorStage() { *
Scheduler:
*
{@code singleOrErrorStage} does not operate by default on a particular {@link Scheduler}.
*
- * @return the new CompletionStage instance + * @return the new {@code CompletionStage} instance * @since 3.0.0 * @see #singleStage(Object) */ @@ -16241,7 +16698,7 @@ public final CompletionStage singleOrErrorStage() { *
Scheduler:
*
{@code lastOrErrorStage} does not operate by default on a particular {@link Scheduler}.
*
- * @return the new CompletionStage instance + * @return the new {@code CompletionStage} instance * @since 3.0.0 * @see #lastStage(Object) */ @@ -16273,7 +16730,7 @@ public final CompletionStage lastOrErrorStage() { *
{@code blockingStream} does not operate by default on a particular {@link Scheduler}.
*
* - * @return the new Stream instance + * @return the new {@code Stream} instance * @since 3.0.0 * @see #blockingStream(int) */ @@ -16306,7 +16763,8 @@ public final Stream blockingStream() { *
* * @param capacityHint the expected number of items to be buffered - * @return the new Stream instance + * @return the new {@code Stream} instance + * @throws IllegalArgumentException if {@code capacityHint} is non-positive * @since 3.0.0 */ @CheckReturnValue @@ -16323,11 +16781,11 @@ public final Stream blockingStream(int capacityHint) { *

* *

- * Due to the blocking and sequential nature of Java {@link Stream}s, the streams are mapped and consumed in a sequential fashion + * Due to the blocking and sequential nature of Java {@code Stream}s, the streams are mapped and consumed in a sequential fashion * without interleaving (unlike a more general {@link #flatMap(Function)}). Therefore, {@code flatMapStream} and * {@code concatMapStream} are identical operators and are provided as aliases. *

- * The operator closes the {@code Stream} upon cancellation and when it terminates. Exceptions raised when + * The operator closes the {@code Stream} upon cancellation and when it terminates. The exceptions raised when * closing a {@code Stream} are routed to the global error handler ({@link RxJavaPlugins#onError(Throwable)}. * If a {@code Stream} should not be closed, turn it into an {@link Iterable} and use {@link #concatMapIterable(Function)}: * 


@@ -16354,6 +16812,7 @@ public final Stream blockingStream(int capacityHint) {
      * will be emitted to the downstream
      * @return the new {@code Observable} instance
      * @since 3.0.0
+     * @throws NullPointerException if {@code mapper} is {@code null}
      * @see #concatMap(Function)
      * @see #concatMapIterable(Function)
      * @see #flatMapStream(Function)
@@ -16370,11 +16829,11 @@ public final Stream blockingStream(int capacityHint) {
      * 

      * 
      * 

-     * Due to the blocking and sequential nature of Java {@link Stream}s, the streams are mapped and consumed in a sequential fashion
+     * Due to the blocking and sequential nature of Java {@code Stream}s, the streams are mapped and consumed in a sequential fashion
      * without interleaving (unlike a more general {@link #flatMap(Function)}). Therefore, {@code flatMapStream} and
      * {@code concatMapStream} are identical operators and are provided as aliases.
      * 

-     * The operator closes the {@code Stream} upon cancellation and when it terminates. Exceptions raised when
+     * The operator closes the {@code Stream} upon cancellation and when it terminates. The exceptions raised when
      * closing a {@code Stream} are routed to the global error handler ({@link RxJavaPlugins#onError(Throwable)}.
      * If a {@code Stream} should not be closed, turn it into an {@link Iterable} and use {@link #flatMapIterable(Function)}:
      * 

@@ -16401,6 +16860,7 @@ public final Stream blockingStream(int capacityHint) {
      * will be emitted to the downstream
      * @return the new {@code Observable} instance
      * @since 3.0.0
+     * @throws NullPointerException if {@code mapper} is {@code null}
      * @see #flatMap(Function)
      * @see #flatMapIterable(Function)
      */
diff --git a/src/main/java/io/reactivex/rxjava3/core/Single.java b/src/main/java/io/reactivex/rxjava3/core/Single.java
index 93779d4f5a..9b60269cd3 100644
--- a/src/main/java/io/reactivex/rxjava3/core/Single.java
+++ b/src/main/java/io/reactivex/rxjava3/core/Single.java
@@ -152,6 +152,7 @@ public static  Single amb(@NonNull Iterable Single amb(@NonNull Iterable Single ambArray(@NonNull SingleSource... sources) {
+        Objects.requireNonNull(sources, "sources is null");
         if (sources.length == 0) {
             return error(SingleInternalHelper.emptyThrower());
         }
diff --git a/src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableBlockingSubscribe.java b/src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableBlockingSubscribe.java
index 9caafbc8e5..26287a0ccc 100644
--- a/src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableBlockingSubscribe.java
+++ b/src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableBlockingSubscribe.java
@@ -36,17 +36,17 @@ private FlowableBlockingSubscribe() {
     /**
      * Subscribes to the source and calls the Subscriber methods on the current thread.
      * 

-     * @param o the source publisher
+     * @param source the source publisher
      * The cancellation and backpressure is composed through.
      * @param subscriber the subscriber to forward events and calls to in the current thread
      * @param  the value type
      */
-    public static  void subscribe(Publisher o, Subscriber subscriber) {
+    public static  void subscribe(Publisher source, Subscriber subscriber) {
         final BlockingQueue queue = new LinkedBlockingQueue<>();
 
         BlockingSubscriber bs = new BlockingSubscriber<>(queue);
 
-        o.subscribe(bs);
+        source.subscribe(bs);
 
         try {
             for (;;) {
@@ -77,15 +77,15 @@ public static  void subscribe(Publisher o, Subscriber
 
     /**
      * Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
-     * @param o the source publisher
+     * @param source the source to await
      * @param  the value type
      */
-    public static  void subscribe(Publisher o) {
+    public static  void subscribe(Publisher source) {
         BlockingIgnoringReceiver callback = new BlockingIgnoringReceiver();
         LambdaSubscriber ls = new LambdaSubscriber<>(Functions.emptyConsumer(),
         callback, callback, Functions.REQUEST_MAX);
 
-        o.subscribe(ls);
+        source.subscribe(ls);
 
         BlockingHelper.awaitForComplete(callback, ls);
         Throwable e = callback.error;
diff --git a/src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableBlockingSubscribe.java b/src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableBlockingSubscribe.java
index 2c88f007e9..fe06c2099f 100644
--- a/src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableBlockingSubscribe.java
+++ b/src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableBlockingSubscribe.java
@@ -39,6 +39,7 @@ private ObservableBlockingSubscribe() {
      * The call to dispose() is composed through.
      * @param observer the subscriber to forward events and calls to in the current thread
      * @param  the value type
+     * @throws NullPointerException if {@code observer} is {@code null}
      */
     public static  void subscribe(ObservableSource o, Observer observer) {
         final BlockingQueue queue = new LinkedBlockingQueue<>();
diff --git a/src/main/java/io/reactivex/rxjava3/parallel/ParallelFlowable.java b/src/main/java/io/reactivex/rxjava3/parallel/ParallelFlowable.java
index ea09fb53d4..df1861c032 100644
--- a/src/main/java/io/reactivex/rxjava3/parallel/ParallelFlowable.java
+++ b/src/main/java/io/reactivex/rxjava3/parallel/ParallelFlowable.java
@@ -72,8 +72,11 @@ public abstract class ParallelFlowable<@NonNull T> {
      *
      * @param subscribers the array of Subscribers
      * @return true if the number of subscribers equals to the parallelism level
+     * @throws NullPointerException if {@code subscribers} is {@code null}
+     * @throws IllegalArgumentException if {@code subscribers.length} is different from {@link #parallelism()}
      */
     protected final boolean validate(@NonNull Subscriber[] subscribers) {
+        Objects.requireNonNull(subscribers, "subscribers is null");
         int p = parallelism();
         if (subscribers.length != p) {
             Throwable iae = new IllegalArgumentException("parallelism = " + p + ", subscribers = " + subscribers.length);
@@ -156,7 +159,7 @@ public static  ParallelFlowable from(@NonNull Publisher sourc
     @BackpressureSupport(BackpressureKind.FULL)
     public static <@NonNull T> ParallelFlowable from(@NonNull Publisher source,
             int parallelism, int prefetch) {
-        Objects.requireNonNull(source, "source");
+        Objects.requireNonNull(source, "source is null");
         ObjectHelper.verifyPositive(parallelism, "parallelism");
         ObjectHelper.verifyPositive(prefetch, "prefetch");
 
@@ -183,7 +186,7 @@ public static  ParallelFlowable from(@NonNull Publisher sourc
     @SchedulerSupport(SchedulerSupport.NONE)
     @BackpressureSupport(BackpressureKind.PASS_THROUGH)
     public final  ParallelFlowable map(@NonNull Function mapper) {
-        Objects.requireNonNull(mapper, "mapper");
+        Objects.requireNonNull(mapper, "mapper is null");
         return RxJavaPlugins.onAssembly(new ParallelMap<>(this, mapper));
     }
 
@@ -212,7 +215,7 @@ public final  ParallelFlowable map(@NonNull Function ParallelFlowable map(@NonNull Function mapper, @NonNull ParallelFailureHandling errorHandler) {
-        Objects.requireNonNull(mapper, "mapper");
+        Objects.requireNonNull(mapper, "mapper is null");
         Objects.requireNonNull(errorHandler, "errorHandler is null");
         return RxJavaPlugins.onAssembly(new ParallelMapTry<>(this, mapper, errorHandler));
     }
@@ -243,7 +246,7 @@ public final  ParallelFlowable map(@NonNull Function ParallelFlowable map(@NonNull Function mapper, @NonNull BiFunction errorHandler) {
-        Objects.requireNonNull(mapper, "mapper");
+        Objects.requireNonNull(mapper, "mapper is null");
         Objects.requireNonNull(errorHandler, "errorHandler is null");
         return RxJavaPlugins.onAssembly(new ParallelMapTry<>(this, mapper, errorHandler));
     }
@@ -267,7 +270,7 @@ public final  ParallelFlowable map(@NonNull Function filter(@NonNull Predicate predicate) {
-        Objects.requireNonNull(predicate, "predicate");
+        Objects.requireNonNull(predicate, "predicate is null");
         return RxJavaPlugins.onAssembly(new ParallelFilter<>(this, predicate));
     }
 
@@ -295,7 +298,7 @@ public final ParallelFlowable filter(@NonNull Predicate predicate)
     @SchedulerSupport(SchedulerSupport.NONE)
     @BackpressureSupport(BackpressureKind.PASS_THROUGH)
     public final ParallelFlowable filter(@NonNull Predicate predicate, @NonNull ParallelFailureHandling errorHandler) {
-        Objects.requireNonNull(predicate, "predicate");
+        Objects.requireNonNull(predicate, "predicate is null");
         Objects.requireNonNull(errorHandler, "errorHandler is null");
         return RxJavaPlugins.onAssembly(new ParallelFilterTry<>(this, predicate, errorHandler));
     }
@@ -325,7 +328,7 @@ public final ParallelFlowable filter(@NonNull Predicate predicate,
     @SchedulerSupport(SchedulerSupport.NONE)
     @BackpressureSupport(BackpressureKind.PASS_THROUGH)
     public final ParallelFlowable filter(@NonNull Predicate predicate, @NonNull BiFunction errorHandler) {
-        Objects.requireNonNull(predicate, "predicate");
+        Objects.requireNonNull(predicate, "predicate is null");
         Objects.requireNonNull(errorHandler, "errorHandler is null");
         return RxJavaPlugins.onAssembly(new ParallelFilterTry<>(this, predicate, errorHandler));
     }
@@ -401,7 +404,7 @@ public final ParallelFlowable runOn(@NonNull Scheduler scheduler) {
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.CUSTOM)
     public final ParallelFlowable runOn(@NonNull Scheduler scheduler, int prefetch) {
-        Objects.requireNonNull(scheduler, "scheduler");
+        Objects.requireNonNull(scheduler, "scheduler is null");
         ObjectHelper.verifyPositive(prefetch, "prefetch");
         return RxJavaPlugins.onAssembly(new ParallelRunOn<>(this, scheduler, prefetch));
     }
@@ -426,7 +429,7 @@ public final ParallelFlowable runOn(@NonNull Scheduler scheduler, int prefetc
     @BackpressureSupport(BackpressureKind.UNBOUNDED_IN)
     @SchedulerSupport(SchedulerSupport.NONE)
     public final Flowable reduce(@NonNull BiFunction reducer) {
-        Objects.requireNonNull(reducer, "reducer");
+        Objects.requireNonNull(reducer, "reducer is null");
         return RxJavaPlugins.onAssembly(new ParallelReduceFull<>(this, reducer));
     }
 
@@ -453,8 +456,8 @@ public final Flowable reduce(@NonNull BiFunction reducer) {
     @BackpressureSupport(BackpressureKind.UNBOUNDED_IN)
     @SchedulerSupport(SchedulerSupport.NONE)
     public final  ParallelFlowable reduce(@NonNull Supplier initialSupplier, @NonNull BiFunction reducer) {
-        Objects.requireNonNull(initialSupplier, "initialSupplier");
-        Objects.requireNonNull(reducer, "reducer");
+        Objects.requireNonNull(initialSupplier, "initialSupplier is null");
+        Objects.requireNonNull(reducer, "reducer is null");
         return RxJavaPlugins.onAssembly(new ParallelReduce<>(this, initialSupplier, reducer));
     }
 
@@ -1024,6 +1027,7 @@ public final  ParallelFlowable collect(@NonNull Supplier coll
      * @param  the value type
      * @param publishers the array of publishers
      * @return the new ParallelFlowable instance
+     * @throws IllegalArgumentException if {@code publishers} is an empty array
      */
     @CheckReturnValue
     @NonNull
@@ -1031,6 +1035,7 @@ public final  ParallelFlowable collect(@NonNull Supplier coll
     @BackpressureSupport(BackpressureKind.PASS_THROUGH)
     @SchedulerSupport(SchedulerSupport.NONE)
     public static <@NonNull T> ParallelFlowable fromArray(@NonNull Publisher... publishers) {
+        Objects.requireNonNull(publishers, "publishers is null");
         if (publishers.length == 0) {
             throw new IllegalArgumentException("Zero publishers not supported");
         }
@@ -1427,7 +1432,7 @@ public final  ParallelFlowable flatMapIterable(@NonNull Function ParallelFlowable mapOptional(@NonNull Function> mapper) {
-        Objects.requireNonNull(mapper, "mapper");
+        Objects.requireNonNull(mapper, "mapper is null");
         return RxJavaPlugins.onAssembly(new ParallelMapOptional<>(this, mapper));
     }
 
@@ -1456,7 +1461,7 @@ public final  ParallelFlowable mapOptional(@NonNull Function ParallelFlowable mapOptional(@NonNull Function> mapper, @NonNull ParallelFailureHandling errorHandler) {
-        Objects.requireNonNull(mapper, "mapper");
+        Objects.requireNonNull(mapper, "mapper is null");
         Objects.requireNonNull(errorHandler, "errorHandler is null");
         return RxJavaPlugins.onAssembly(new ParallelMapTryOptional<>(this, mapper, errorHandler));
     }
@@ -1487,7 +1492,7 @@ public final  ParallelFlowable mapOptional(@NonNull Function ParallelFlowable mapOptional(@NonNull Function> mapper, @NonNull BiFunction errorHandler) {
-        Objects.requireNonNull(mapper, "mapper");
+        Objects.requireNonNull(mapper, "mapper is null");
         Objects.requireNonNull(errorHandler, "errorHandler is null");
         return RxJavaPlugins.onAssembly(new ParallelMapTryOptional<>(this, mapper, errorHandler));
     }
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSkipLastTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSkipLastTest.java
index 53e4e24a93..7b1fb2a45f 100644
--- a/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSkipLastTest.java
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSkipLastTest.java
@@ -97,7 +97,7 @@ public void skipLastWithBackpressure() {
 
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test(expected = IllegalArgumentException.class)
     public void skipLastWithNegativeCount() {
         Flowable.just("one").skipLast(-1);
     }
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTest.java
index c62ff85db0..de6a431844 100644
--- a/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTest.java
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTest.java
@@ -89,7 +89,7 @@ public void takeLastWithZeroCount() {
         verify(subscriber, times(1)).onComplete();
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test(expected = IllegalArgumentException.class)
     public void takeLastWithNegativeCount() {
         Flowable.just("one").takeLast(-1);
     }
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTimedTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTimedTest.java
index 3f8c22a47f..836700d2aa 100644
--- a/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTimedTest.java
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTimedTest.java
@@ -32,7 +32,7 @@
 
 public class FlowableTakeLastTimedTest extends RxJavaTest {
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test(expected = IllegalArgumentException.class)
     public void takeLastTimedWithNegativeCount() {
         Flowable.just("one").takeLast(-1, 1, TimeUnit.SECONDS);
     }
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatMapEagerTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatMapEagerTest.java
index ab4ba0273f..e13124bf5d 100644
--- a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatMapEagerTest.java
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatMapEagerTest.java
@@ -535,7 +535,7 @@ public void badCapacityHint() throws Exception {
         try {
             Observable.concatEager(Arrays.asList(source, source, source), 1, -99);
         } catch (IllegalArgumentException ex) {
-            assertEquals("prefetch > 0 required but it was -99", ex.getMessage());
+            assertEquals("bufferSize > 0 required but it was -99", ex.getMessage());
         }
 
     }
@@ -547,7 +547,7 @@ public void mappingBadCapacityHint() throws Exception {
         try {
             Observable.just(source, source, source).concatMapEager((Function)Functions.identity(), 10, -99);
         } catch (IllegalArgumentException ex) {
-            assertEquals("prefetch > 0 required but it was -99", ex.getMessage());
+            assertEquals("bufferSize > 0 required but it was -99", ex.getMessage());
         }
 
     }
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSkipLastTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSkipLastTest.java
index 8edf026fe1..712da24ea9 100644
--- a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSkipLastTest.java
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSkipLastTest.java
@@ -92,7 +92,7 @@ public void skipLastWithBackpressure() {
 
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test(expected = IllegalArgumentException.class)
     public void skipLastWithNegativeCount() {
         Observable.just("one").skipLast(-1);
     }
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTest.java
index 2aa9e37985..b9ed392381 100644
--- a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTest.java
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTest.java
@@ -83,7 +83,7 @@ public void takeLastWithZeroCount() {
         verify(observer, times(1)).onComplete();
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test(expected = IllegalArgumentException.class)
     public void takeLastWithNegativeCount() {
         Observable.just("one").takeLast(-1);
     }
diff --git a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTimedTest.java b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTimedTest.java
index a81fd1d9cb..f8d17474c2 100644
--- a/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTimedTest.java
+++ b/src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTimedTest.java
@@ -30,7 +30,7 @@
 
 public class ObservableTakeLastTimedTest extends RxJavaTest {
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test(expected = IllegalArgumentException.class)
     public void takeLastTimedWithNegativeCount() {
         Observable.just("one").takeLast(-1, 1, TimeUnit.SECONDS);
     }
diff --git a/src/test/java/io/reactivex/rxjava3/validators/ParamValidationCheckerTest.java b/src/test/java/io/reactivex/rxjava3/validators/ParamValidationCheckerTest.java
index 85a6c4b0bd..b46f59f42a 100644
--- a/src/test/java/io/reactivex/rxjava3/validators/ParamValidationCheckerTest.java
+++ b/src/test/java/io/reactivex/rxjava3/validators/ParamValidationCheckerTest.java
@@ -890,6 +890,12 @@ void checkClass(Class clazz) {
                                 error = ex;
                             }
 
+                            if (!success && error.getCause() instanceof NullPointerException) {
+                                if (!error.getCause().toString().contains("is null")) {
+                                    fail++;
+                                    b.append("\r\nNPEs should indicate which argument failed: " + m + " # " + i + " = " + p + ", tag = " + tag + ", params = " + Arrays.toString(callParams2));
+                                }
+                            }
                             if (success != shouldSucceed) {
                                 fail++;
                                 if (shouldSucceed) {
diff --git a/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java b/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java
index 2b43746f15..e19048f473 100644
--- a/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java
+++ b/src/test/java/io/reactivex/rxjava3/validators/ParamValidationNaming.java
@@ -229,15 +229,25 @@ static void processFile(Class clazz) throws Exception {
                         continue;
                     }
 
+                    int midx = j - 1;
+                    // find the method declaration
+                    for (; midx >= 0; midx--) {
+                        String linek = lines.get(midx).trim();
+                        if (linek.startsWith("public") || linek.startsWith("private")
+                                || linek.startsWith("protected")) {
+                            break;
+                        }
+                    }
+
                     // find JavaDoc of throws
                     boolean found = false;
-                    for (int k = j - 1; k >= 0; k--) {
+                    for (int k = midx - 1; k >= 0; k--) {
                         String linek = lines.get(k).trim();
                         if (linek.startsWith("/**")) {
                             break;
                         }
                         if (linek.startsWith("}")) {
-                            found = true; // no JavaDoc
+                            found = true; // no method JavaDoc present
                             break;
                         }
                         if (linek.startsWith(validatorStr.javadoc)) {
@@ -280,6 +290,56 @@ static void processFile(Class clazz) throws Exception {
                     }
                 }
             }
+
+            for (ValidatorStrings validatorStr : EXCEPTION_STRINGS) {
+                int strIdx = line.indexOf(validatorStr.code);
+                if (strIdx >= 0) {
+
+                    int midx = j - 1;
+                    // find the method declaration
+                    for (; midx >= 0; midx--) {
+                        String linek = lines.get(midx).trim();
+                        if (linek.startsWith("public") || linek.startsWith("private")
+                                || linek.startsWith("protected")) {
+                            break;
+                        }
+                    }
+
+                    // find JavaDoc of throws
+                    boolean found = false;
+                    for (int k = midx - 1; k >= 0; k--) {
+                        String linek = lines.get(k).trim();
+                        if (linek.startsWith("/**")) {
+                            break;
+                        }
+                        if (linek.startsWith("}")) {
+                            found = true; // no JavaDoc
+                            break;
+                        }
+                        if (linek.startsWith(validatorStr.javadoc)) {
+                            found = true;
+                        }
+                    }
+
+                    if (!found) {
+                        errorCount++;
+                        errors.append("L")
+                        .append(j)
+                        .append(" : missing '")
+                        .append(validatorStr.javadoc)
+                        .append("' for exception\r\n    ")
+                        .append(line)
+                        .append("\r\n at ")
+                        .append(fullClassName)
+                        .append(".method(")
+                        .append(f.getName())
+                        .append(":")
+                        .append(j + 1)
+                        .append(")\r\n")
+                        ;
+                    }
+                }
+            }
         }
 
         if (errorCount != 0) {
@@ -303,4 +363,10 @@ static final class ValidatorStrings {
             new ValidatorStrings("ObjectHelper.verifyPositive(", "* @throws IllegalArgumentException")
     );
 
+    static final List EXCEPTION_STRINGS = Arrays.asList(
+            new ValidatorStrings("throw new NullPointerException(", "* @throws NullPointerException"),
+            new ValidatorStrings("throw new IllegalArgumentException(", "* @throws IllegalArgumentException"),
+            new ValidatorStrings("throw new IndexOutOfBoundsException(", "* @throws IndexOutOfBoundsException")
+    );
+
 }