From 851aed30289ce8a93ad5def12849af7875dec0fb Mon Sep 17 00:00:00 2001 From: makhlouf Date: Sun, 31 Jul 2016 01:10:33 +0200 Subject: [PATCH 1/3] Adds concatDelayError with multiple arguments --- src/main/java/rx/Observable.java | 264 +++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java index d2f187bef3..6c021db188 100644 --- a/src/main/java/rx/Observable.java +++ b/src/main/java/rx/Observable.java @@ -1452,6 +1452,270 @@ public static Observable concatDelayError(Iterable + *
Backpressure:
+ *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} + * sources are expected to honor backpressure as well. If the outer violates this, a + * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates + * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
Scheduler:
+ *
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
+ * + * + * @param the common element base type + * @param t1 + * an Observable to be concatenated + * @param t2 + * an Observable to be concatenated + * @return the new Observable with the concatenating behavior + */ + @Experimental + public static Observable concatDelayError(Observable t1, Observable t2) { + return concatDelayError(just(t1, t2)); + } + + /** + * Concatenates three Observables into a single sequence by subscribing to each Observable, + * one after the other, one at a time and delays any errors till all inner Observables terminate. + * + *
+ *
Backpressure:
+ *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} + * sources are expected to honor backpressure as well. If the outer violates this, a + * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates + * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
Scheduler:
+ *
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
+ *
+ * + * @param the common element base type + * @param t1 + * an Observable to be concatenated + * @param t2 + * an Observable to be concatenated + * @param t3 + * an Observable to be concatenated + * @return the new Observable with the concatenating behavior + */ + @Experimental + public static Observable concatDelayError(Observable t1, Observable t2,Observable t3 ) { + return concatDelayError(just(t1, t2, t3)); + } + + /** + * Concatenates four Observables into a single sequence by subscribing to each Observable, + * one after the other, one at a time and delays any errors till all inner Observables terminate. + * + *
+ *
Backpressure:
+ *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} + * sources are expected to honor backpressure as well. If the outer violates this, a + * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates + * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
Scheduler:
+ *
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
+ *
+ * + * @param the common element base type + * @param t1 + * an Observable to be concatenated + * @param t2 + * an Observable to be concatenated + * @param t3 + * an Observable to be concatenated + * @param t4 + * an Observable to be concatenated + * @return the new Observable with the concatenating behavior + */ + @Experimental + public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4) { + return concatDelayError(just(t1, t2, t3, t4)); + } + + /** + * Concatenates five Observables into a single sequence by subscribing to each Observable, + * one after the other, one at a time and delays any errors till all inner Observables terminate. + * + *
+ *
Backpressure:
+ *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} + * sources are expected to honor backpressure as well. If the outer violates this, a + * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates + * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
Scheduler:
+ *
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
+ *
+ * + * @param the common element base type + * @param t1 + * an Observable to be concatenated + * @param t2 + * an Observable to be concatenated + * @param t3 + * an Observable to be concatenated + * @param t4 + * an Observable to be concatenated + * @param t5 + * an Observable to be concatenated + * @return the new Observable with the concatenating behavior + */ + @Experimental + public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) { + return concatDelayError(just(t1, t2, t3, t4, t5)); + } + + /** + * Concatenates six Observables into a single sequence by subscribing to each Observable, + * one after the other, one at a time and delays any errors till all inner Observables terminate. + * + *
+ *
Backpressure:
+ *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} + * sources are expected to honor backpressure as well. If the outer violates this, a + * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates + * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
Scheduler:
+ *
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
+ *
+ * + * @param the common element base type + * @param t1 + * an Observable to be concatenated + * @param t2 + * an Observable to be concatenated + * @param t3 + * an Observable to be concatenated + * @param t4 + * an Observable to be concatenated + * @param t5 + * an Observable to be concatenated + * @param t6 + * an Observable to be concatenated + * @return the new Observable with the concatenating behavior + */ + @Experimental + public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) { + return concatDelayError(just(t1, t2, t3, t4, t5, t6)); + } + + /** + * Concatenates seven Observables into a single sequence by subscribing to each Observable, + * one after the other, one at a time and delays any errors till all inner Observables terminate. + * + *
+ *
Backpressure:
+ *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} + * sources are expected to honor backpressure as well. If the outer violates this, a + * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates + * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
Scheduler:
+ *
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
+ *
+ * + * @param the common element base type + * @param t1 + * an Observable to be concatenated + * @param t2 + * an Observable to be concatenated + * @param t3 + * an Observable to be concatenated + * @param t4 + * an Observable to be concatenated + * @param t5 + * an Observable to be concatenated + * @param t6 + * an Observable to be concatenated + * @param t7 + * an Observable to be concatenated + * @return the new Observable with the concatenating behavior + */ + @Experimental + public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) { + return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7)); + } + + /** + * Concatenates eight Observables into a single sequence by subscribing to each Observable, + * one after the other, one at a time and delays any errors till all inner Observables terminate. + * + *
+ *
Backpressure:
+ *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} + * sources are expected to honor backpressure as well. If the outer violates this, a + * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates + * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
Scheduler:
+ *
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
+ *
+ * + * @param the common element base type + * @param t1 + * an Observable to be concatenated + * @param t2 + * an Observable to be concatenated + * @param t3 + * an Observable to be concatenated + * @param t4 + * an Observable to be concatenated + * @param t5 + * an Observable to be concatenated + * @param t6 + * an Observable to be concatenated + * @param t7 + * an Observable to be concatenated + * @param t8 + * an Observable to be concatenated + * @return the new Observable with the concatenating behavior + */ + @Experimental + public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) { + return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8)); + } + + /** + * Concatenates nine Observables into a single sequence by subscribing to each Observable, + * one after the other, one at a time and delays any errors till all inner Observables terminate. + * + *
+ *
Backpressure:
+ *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} + * sources are expected to honor backpressure as well. If the outer violates this, a + * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates + * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
Scheduler:
+ *
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
+ *
+ * + * @param the common element base type + * @param t1 + * an Observable to be concatenated + * @param t2 + * an Observable to be concatenated + * @param t3 + * an Observable to be concatenated + * @param t4 + * an Observable to be concatenated + * @param t5 + * an Observable to be concatenated + * @param t6 + * an Observable to be concatenated + * @param t7 + * an Observable to be concatenated + * @param t8 + * an Observable to be concatenated + * @param t9 + * an Observable to be concatenated + * @return the new Observable with the concatenating behavior + */ + @Experimental + public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) { + return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8, t9)); + } + /** * Returns an Observable that calls an Observable factory to create an Observable for each new Observer * that subscribes. That is, for each subscriber, the actual Observable that subscriber observes is From 3c08a77e205b74fdf24a5dfb6d8a11d76bb42987 Mon Sep 17 00:00:00 2001 From: makhlouf Date: Sun, 31 Jul 2016 02:23:12 +0200 Subject: [PATCH 2/3] Adds Tests for concatDelayError multiple arguments --- .../OnSubscribeConcatDelayErrorTest.java | 313 ++++++++++++++++++ 1 file changed, 313 insertions(+) diff --git a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java index 6fd947ae60..ee768ffc1a 100644 --- a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java +++ b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java @@ -277,4 +277,317 @@ public void concatDelayErrorIterableError() { assertEquals(2, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); } + @SuppressWarnings("unchecked") + @Test + public void concatDelayError2() { + TestSubscriber ts = TestSubscriber.create(); + Observable o1 = Observable.just(1); + Observable o2 = Observable.just(2); + + Observable.concatDelayError(o1, o2) + .subscribe(ts); + + ts.assertValues(1, 2); + ts.assertNoErrors(); + ts.assertCompleted(); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError2Error() { + TestSubscriber ts = TestSubscriber.create(); + Observable withError1 = withError(Observable.just(1)); + Observable withError2 = withError(Observable.just(2)); + + Observable.concatDelayError(withError1, withError2) + .subscribe(ts); + + ts.assertValues(1, 2); + ts.assertError(CompositeException.class); + ts.assertNotCompleted(); + + assertEquals(2, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError3() { + TestSubscriber ts = TestSubscriber.create(); + Observable o1 = Observable.just(1); + Observable o2 = Observable.just(2); + Observable o3 = Observable.just(3); + + Observable.concatDelayError(o1, o2, o3) + .subscribe(ts); + + ts.assertValues(1, 2, 3); + ts.assertNoErrors(); + ts.assertCompleted(); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError3Error() { + TestSubscriber ts = TestSubscriber.create(); + Observable withError1 = withError(Observable.just(1)); + Observable withError2 = withError(Observable.just(2)); + Observable withError3 = withError(Observable.just(3)); + + Observable.concatDelayError(withError1, withError2, withError3) + .subscribe(ts); + + ts.assertValues(1, 2, 3); + ts.assertError(CompositeException.class); + ts.assertNotCompleted(); + + assertEquals(3, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError4() { + TestSubscriber ts = TestSubscriber.create(); + Observable o1 = Observable.just(1); + Observable o2 = Observable.just(2); + Observable o3 = Observable.just(3); + Observable o4 = Observable.just(4); + + Observable.concatDelayError(o1, o2, o3, o4) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4); + ts.assertNoErrors(); + ts.assertCompleted(); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError4Error() { + TestSubscriber ts = TestSubscriber.create(); + Observable withError1 = withError(Observable.just(1)); + Observable withError2 = withError(Observable.just(2)); + Observable withError3 = withError(Observable.just(3)); + Observable withError4 = withError(Observable.just(4)); + + Observable.concatDelayError(withError1, withError2, withError3, withError4) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4); + ts.assertError(CompositeException.class); + ts.assertNotCompleted(); + + assertEquals(4, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError5() { + TestSubscriber ts = TestSubscriber.create(); + Observable o1 = Observable.just(1); + Observable o2 = Observable.just(2); + Observable o3 = Observable.just(3); + Observable o4 = Observable.just(4); + Observable o5 = Observable.just(5); + + Observable.concatDelayError(o1, o2, o3, o4, o5) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5); + ts.assertNoErrors(); + ts.assertCompleted(); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError5Error() { + TestSubscriber ts = TestSubscriber.create(); + Observable withError1 = withError(Observable.just(1)); + Observable withError2 = withError(Observable.just(2)); + Observable withError3 = withError(Observable.just(3)); + Observable withError4 = withError(Observable.just(4)); + Observable withError5 = withError(Observable.just(5)); + + Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5); + ts.assertError(CompositeException.class); + ts.assertNotCompleted(); + + assertEquals(5, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError6() { + TestSubscriber ts = TestSubscriber.create(); + Observable o1 = Observable.just(1); + Observable o2 = Observable.just(2); + Observable o3 = Observable.just(3); + Observable o4 = Observable.just(4); + Observable o5 = Observable.just(5); + Observable o6 = Observable.just(6); + + Observable.concatDelayError(o1, o2, o3, o4, o5, o6) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5, 6); + ts.assertNoErrors(); + ts.assertCompleted(); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError6Error() { + TestSubscriber ts = TestSubscriber.create(); + Observable withError1 = withError(Observable.just(1)); + Observable withError2 = withError(Observable.just(2)); + Observable withError3 = withError(Observable.just(3)); + Observable withError4 = withError(Observable.just(4)); + Observable withError5 = withError(Observable.just(5)); + Observable withError6 = withError(Observable.just(6)); + + Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5, withError6) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5, 6); + ts.assertError(CompositeException.class); + ts.assertNotCompleted(); + + assertEquals(6, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError7() { + TestSubscriber ts = TestSubscriber.create(); + Observable o1 = Observable.just(1); + Observable o2 = Observable.just(2); + Observable o3 = Observable.just(3); + Observable o4 = Observable.just(4); + Observable o5 = Observable.just(5); + Observable o6 = Observable.just(6); + Observable o7 = Observable.just(7); + + Observable.concatDelayError(o1, o2, o3, o4, o5, o6, o7) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5, 6, 7); + ts.assertNoErrors(); + ts.assertCompleted(); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError7Error() { + TestSubscriber ts = TestSubscriber.create(); + Observable withError1 = withError(Observable.just(1)); + Observable withError2 = withError(Observable.just(2)); + Observable withError3 = withError(Observable.just(3)); + Observable withError4 = withError(Observable.just(4)); + Observable withError5 = withError(Observable.just(5)); + Observable withError6 = withError(Observable.just(6)); + Observable withError7 = withError(Observable.just(7)); + + Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5, withError6, withError7) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5, 6, 7); + ts.assertError(CompositeException.class); + ts.assertNotCompleted(); + + assertEquals(7, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError8() { + TestSubscriber ts = TestSubscriber.create(); + Observable o1 = Observable.just(1); + Observable o2 = Observable.just(2); + Observable o3 = Observable.just(3); + Observable o4 = Observable.just(4); + Observable o5 = Observable.just(5); + Observable o6 = Observable.just(6); + Observable o7 = Observable.just(7); + Observable o8 = Observable.just(8); + + + Observable.concatDelayError(o1, o2, o3, o4, o5, o6, o7, o8) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8); + ts.assertNoErrors(); + ts.assertCompleted(); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError8Error() { + TestSubscriber ts = TestSubscriber.create(); + Observable withError1 = withError(Observable.just(1)); + Observable withError2 = withError(Observable.just(2)); + Observable withError3 = withError(Observable.just(3)); + Observable withError4 = withError(Observable.just(4)); + Observable withError5 = withError(Observable.just(5)); + Observable withError6 = withError(Observable.just(6)); + Observable withError7 = withError(Observable.just(7)); + Observable withError8 = withError(Observable.just(8)); + + Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5, withError6, withError7, withError8) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8); + ts.assertError(CompositeException.class); + ts.assertNotCompleted(); + + assertEquals(8, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError9() { + TestSubscriber ts = TestSubscriber.create(); + Observable o1 = Observable.just(1); + Observable o2 = Observable.just(2); + Observable o3 = Observable.just(3); + Observable o4 = Observable.just(4); + Observable o5 = Observable.just(5); + Observable o6 = Observable.just(6); + Observable o7 = Observable.just(7); + Observable o8 = Observable.just(8); + Observable o9 = Observable.just(9); + + + Observable.concatDelayError(o1, o2, o3, o4, o5, o6, o7, o8, o9) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9); + ts.assertNoErrors(); + ts.assertCompleted(); + } + + @SuppressWarnings("unchecked") + @Test + public void concatDelayError9Error() { + TestSubscriber ts = TestSubscriber.create(); + Observable withError1 = withError(Observable.just(1)); + Observable withError2 = withError(Observable.just(2)); + Observable withError3 = withError(Observable.just(3)); + Observable withError4 = withError(Observable.just(4)); + Observable withError5 = withError(Observable.just(5)); + Observable withError6 = withError(Observable.just(6)); + Observable withError7 = withError(Observable.just(7)); + Observable withError8 = withError(Observable.just(8)); + Observable withError9 = withError(Observable.just(9)); + + Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5, withError6, withError7, withError8, withError9) + .subscribe(ts); + + ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9); + ts.assertError(CompositeException.class); + ts.assertNotCompleted(); + + assertEquals(9, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size()); + } } From 0d0cd281747fdb1851d97c6b9c7cff8fbcb5a28f Mon Sep 17 00:00:00 2001 From: Makhlouf Date: Sun, 31 Jul 2016 11:12:57 +0200 Subject: [PATCH 3/3] Updates wording --- src/main/java/rx/Observable.java | 112 +++++++++++++++---------------- 1 file changed, 56 insertions(+), 56 deletions(-) diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java index 6c021db188..6a52e4f2d2 100644 --- a/src/main/java/rx/Observable.java +++ b/src/main/java/rx/Observable.java @@ -1453,15 +1453,15 @@ public static Observable concatDelayError(Iterable *
Backpressure:
- *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} - * sources are expected to honor backpressure as well. If the outer violates this, a - * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates - * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
The operator honors backpressure from downstream. The {@code Observable} + * sources are expected to honor backpressure as well. + * If any of the source {@code Observable}s violate this, it may throw an + * {@code IllegalStateException} when the source {@code Observable} completes.
*
Scheduler:
*
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
* @@ -1471,7 +1471,7 @@ public static Observable concatDelayError(Iterable Observable concatDelayError(Observable t1, Observable t2) { @@ -1479,15 +1479,15 @@ public static Observable concatDelayError(Observable t1, Obs } /** - * Concatenates three Observables into a single sequence by subscribing to each Observable, - * one after the other, one at a time and delays any errors till all inner Observables terminate. + * Returns an Observable that emits the items emitted by three Observables, one after the other, without + * interleaving them, and delays any errors till all Observables terminate. * *
*
Backpressure:
- *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} - * sources are expected to honor backpressure as well. If the outer violates this, a - * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates - * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
The operator honors backpressure from downstream. The {@code Observable} + * sources are expected to honor backpressure as well. + * If any of the source {@code Observable}s violate this, it may throw an + * {@code IllegalStateException} when the source {@code Observable} completes.
*
Scheduler:
*
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
*
@@ -1499,7 +1499,7 @@ public static Observable concatDelayError(Observable t1, Obs * an Observable to be concatenated * @param t3 * an Observable to be concatenated - * @return the new Observable with the concatenating behavior + * @return an Observable with the concatenating behavior */ @Experimental public static Observable concatDelayError(Observable t1, Observable t2,Observable t3 ) { @@ -1507,15 +1507,15 @@ public static Observable concatDelayError(Observable t1, Obs } /** - * Concatenates four Observables into a single sequence by subscribing to each Observable, - * one after the other, one at a time and delays any errors till all inner Observables terminate. + * Returns an Observable that emits the items emitted by four Observables, one after the other, without + * interleaving them, and delays any errors till all Observables terminate. * *
*
Backpressure:
- *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} - * sources are expected to honor backpressure as well. If the outer violates this, a - * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates - * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
The operator honors backpressure from downstream. The {@code Observable} + * sources are expected to honor backpressure as well. + * If any of the source {@code Observable}s violate this, it may throw an + * {@code IllegalStateException} when the source {@code Observable} completes.
*
Scheduler:
*
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
*
@@ -1529,7 +1529,7 @@ public static Observable concatDelayError(Observable t1, Obs * an Observable to be concatenated * @param t4 * an Observable to be concatenated - * @return the new Observable with the concatenating behavior + * @return an Observable with the concatenating behavior */ @Experimental public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4) { @@ -1537,15 +1537,15 @@ public static Observable concatDelayError(Observable t1, Obs } /** - * Concatenates five Observables into a single sequence by subscribing to each Observable, - * one after the other, one at a time and delays any errors till all inner Observables terminate. + * Returns an Observable that emits the items emitted by five Observables, one after the other, without + * interleaving them, and delays any errors till all Observables terminate. * *
*
Backpressure:
- *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} - * sources are expected to honor backpressure as well. If the outer violates this, a - * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates - * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
The operator honors backpressure from downstream. The {@code Observable} + * sources are expected to honor backpressure as well. + * If any of the source {@code Observable}s violate this, it may throw an + * {@code IllegalStateException} when the source {@code Observable} completes.
*
Scheduler:
*
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
*
@@ -1561,7 +1561,7 @@ public static Observable concatDelayError(Observable t1, Obs * an Observable to be concatenated * @param t5 * an Observable to be concatenated - * @return the new Observable with the concatenating behavior + * @return an Observable with the concatenating behavior */ @Experimental public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) { @@ -1569,15 +1569,15 @@ public static Observable concatDelayError(Observable t1, Obs } /** - * Concatenates six Observables into a single sequence by subscribing to each Observable, - * one after the other, one at a time and delays any errors till all inner Observables terminate. + * Returns an Observable that emits the items emitted by six Observables, one after the other, without + * interleaving them, and delays any errors till all Observables terminate. * *
*
Backpressure:
- *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} - * sources are expected to honor backpressure as well. If the outer violates this, a - * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates - * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
The operator honors backpressure from downstream. The {@code Observable} + * sources are expected to honor backpressure as well. + * If any of the source {@code Observable}s violate this, it may throw an + * {@code IllegalStateException} when the source {@code Observable} completes.
*
Scheduler:
*
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
*
@@ -1595,7 +1595,7 @@ public static Observable concatDelayError(Observable t1, Obs * an Observable to be concatenated * @param t6 * an Observable to be concatenated - * @return the new Observable with the concatenating behavior + * @return an Observable with the concatenating behavior */ @Experimental public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) { @@ -1603,15 +1603,15 @@ public static Observable concatDelayError(Observable t1, Obs } /** - * Concatenates seven Observables into a single sequence by subscribing to each Observable, - * one after the other, one at a time and delays any errors till all inner Observables terminate. + * Returns an Observable that emits the items emitted by seven Observables, one after the other, without + * interleaving them, and delays any errors till all Observables terminate. * *
*
Backpressure:
- *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} - * sources are expected to honor backpressure as well. If the outer violates this, a - * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates - * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
The operator honors backpressure from downstream. The {@code Observable} + * sources are expected to honor backpressure as well. + * If any of the source {@code Observable}s violate this, it may throw an + * {@code IllegalStateException} when the source {@code Observable} completes.
*
Scheduler:
*
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
*
@@ -1631,7 +1631,7 @@ public static Observable concatDelayError(Observable t1, Obs * an Observable to be concatenated * @param t7 * an Observable to be concatenated - * @return the new Observable with the concatenating behavior + * @return an Observable with the concatenating behavior */ @Experimental public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) { @@ -1639,15 +1639,15 @@ public static Observable concatDelayError(Observable t1, Obs } /** - * Concatenates eight Observables into a single sequence by subscribing to each Observable, - * one after the other, one at a time and delays any errors till all inner Observables terminate. + * Returns an Observable that emits the items emitted by eight Observables, one after the other, without + * interleaving them, and delays any errors till all Observables terminate. * *
*
Backpressure:
- *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} - * sources are expected to honor backpressure as well. If the outer violates this, a - * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates - * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
The operator honors backpressure from downstream. The {@code Observable} + * sources are expected to honor backpressure as well. + * If any of the source {@code Observable}s violate this, it may throw an + * {@code IllegalStateException} when the source {@code Observable} completes.
*
Scheduler:
*
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
*
@@ -1669,7 +1669,7 @@ public static Observable concatDelayError(Observable t1, Obs * an Observable to be concatenated * @param t8 * an Observable to be concatenated - * @return the new Observable with the concatenating behavior + * @return an Observable with the concatenating behavior */ @Experimental public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) { @@ -1677,15 +1677,15 @@ public static Observable concatDelayError(Observable t1, Obs } /** - * Concatenates nine Observables into a single sequence by subscribing to each Observable, - * one after the other, one at a time and delays any errors till all inner Observables terminate. + * Returns an Observable that emits the items emitted by nine Observables, one after the other, without + * interleaving them, and delays any errors till all Observables terminate. * *
*
Backpressure:
- *
The operator honors backpressure from downstream. Both the outer and inner {@code Observable} - * sources are expected to honor backpressure as well. If the outer violates this, a - * {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates - * this, it may throw an {@code IllegalStateException} when an inner {@code Observable} completes.
+ *
The operator honors backpressure from downstream. The {@code Observable} + * sources are expected to honor backpressure as well. + * If any of the source {@code Observable}s violate this, it may throw an + * {@code IllegalStateException} when the source {@code Observable} completes.
*
Scheduler:
*
{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.
*
@@ -1709,7 +1709,7 @@ public static Observable concatDelayError(Observable t1, Obs * an Observable to be concatenated * @param t9 * an Observable to be concatenated - * @return the new Observable with the concatenating behavior + * @return an Observable with the concatenating behavior */ @Experimental public static Observable concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) {