Add Single.onErrorResumeNext(Single)

Author: artem-zinnatullin

src/main/java/rx/Single.java

@@ -1411,6 +1411,37 @@ public final Single<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunctio
         return lift(new OperatorOnErrorReturn<T>(resumeFunction));
     }
 
+    /**
+     * Instructs a Single to pass control to another Single rather than invoking
+     * {@link Observer#onError(Throwable)} if it encounters an error.
+     * <p/>
+     * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/onErrorResumeNext.png" alt="">
+     * <p/>
+     * By default, when a Single encounters an error that prevents it from emitting the expected item to
+     * its {@link Observer}, the Single 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 another Single ({@code resumeSingle}) to an Single's
+     * {@code onErrorResumeNext} method, if the original Single encounters an error, instead of invoking its
+     * Observer's {@code onError} method, it will instead relinquish control to {@code resumeSingle} which
+     * will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case,
+     * because no Single necessarily invokes {@code onError}, the Observer may never know that an error
+     * happened.
+     * <p/>
+     * You can use this to prevent errors from propagating or to supply fallback data should errors be
+     * encountered.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param resumeSingle a Single that will take control if source Single encounters an error.
+     * @return the original Single, with appropriately modified behavior.
+     * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
+     */
+    public final Single<T> onErrorResumeNext(Single<? extends T> resumeSingle) {
+        return lift(new SingleOperatorOnErrorResumeNextViaSingle<T>(resumeSingle));
+    }
+
     /**
      * Subscribes to a Single but ignore its emission or notification.
      * <dl>

src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNextViaSingle.java

@@ -0,0 +1,67 @@
+package rx.internal.operators;
+
+import rx.Observable.Operator;
+import rx.Producer;
+import rx.Single;
+import rx.Subscriber;
+import rx.exceptions.Exceptions;
+import rx.plugins.RxJavaPlugins;
+
+public class SingleOperatorOnErrorResumeNextViaSingle<T> implements Operator<T, T> {
+
+    final Single<? extends T> resumeSingle;
+
+    public SingleOperatorOnErrorResumeNextViaSingle(Single<? extends T> resumeSingle) {
+        this.resumeSingle = resumeSingle;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        final Subscriber<T> operatorSubscriber = new Subscriber<T>() {
+
+            private boolean done;
+
+            @Override
+            public void onError(Throwable e) {
+                if (done) {
+                    Exceptions.throwIfFatal(e);
+                } else {
+                    done = true;
+
+                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    unsubscribe();
+
+                    resumeSingle.unsafeSubscribe(child);
+                }
+            }
+
+            @Override
+            public void onNext(T t) {
+                if (!done) {
+                    child.onNext(t);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                if (!done) {
+                    done = true;
+                    child.onCompleted();
+                }
+            }
+
+            @Override
+            public void setProducer(final Producer producer) {
+                child.setProducer(new Producer() {
+                    @Override
+                    public void request(long n) {
+                        producer.request(n);
+                    }
+                });
+            }
+        };
+
+        child.add(operatorSubscriber);
+        return operatorSubscriber;
+    }
+}

src/test/java/rx/SingleTest.java

@@ -1,11 +1,11 @@
 /**
  * Copyright 2015 Netflix, Inc.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
  * compliance with the License. You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software distributed under the License is
  * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
  * the License for the specific language governing permissions and limitations under the License.
@@ -1182,6 +1182,30 @@ public void doAfterTerminateActionShouldNotBeInvokedUntilSubscriberSubscribes()
         verifyZeroInteractions(action);
     }
 
+    @Test
+    public void onErrorResumeNextViaSingleShouldNotInterruptSuccessfulSingle() {
+        TestSubscriber<String> testSubscriber = new TestSubscriber<String>();
+
+        Single
+                .just("success")
+                .onErrorResumeNext(Single.just("fail"))
+                .subscribe(testSubscriber);
+
+        testSubscriber.assertValue("success");
+    }
+
+    @Test
+    public void onErrorResumeNextViaSingleShouldResumeWithPassedSingleInCaseOfError() {
+        TestSubscriber<String> testSubscriber = new TestSubscriber<String>();
+
+        Single
+                .<String>error(new RuntimeException("test exception"))
+                .onErrorResumeNext(Single.just("fallback"))
+                .subscribe(testSubscriber);
+
+        testSubscriber.assertValue("fallback");
+    }
+
     @Test(expected = NullPointerException.class)
     public void iterableToArrayShouldThrowNullPointerExceptionIfIterableNull() {
         Single.iterableToArray(null);