Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableResumeNext.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.completable;
15
16 import java.util.Objects;
17 import java.util.concurrent.atomic.AtomicReference;
18
19 import io.reactivex.rxjava3.core.*;
20 import io.reactivex.rxjava3.disposables.Disposable;
21 import io.reactivex.rxjava3.exceptions.*;
22 import io.reactivex.rxjava3.functions.Function;
23 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
24
25 public final class CompletableResumeNext extends Completable {
26
27 final CompletableSource source;
28
29 final Function<? super Throwable, ? extends CompletableSource> errorMapper;
30
31 public CompletableResumeNext(CompletableSource source,
32 Function<? super Throwable, ? extends CompletableSource> errorMapper) {
33 this.source = source;
34 this.errorMapper = errorMapper;
35 }
36
37 @Override
38 protected void subscribeActual(final CompletableObserver observer) {
39 ResumeNextObserver parent = new ResumeNextObserver(observer, errorMapper);
40 observer.onSubscribe(parent);
41 source.subscribe(parent);
42 }
43
44 static final class ResumeNextObserver
45 extends AtomicReference<Disposable>
46 implements CompletableObserver, Disposable {
47
48 private static final long serialVersionUID = 5018523762564524046L;
49
50 final CompletableObserver downstream;
51
52 final Function<? super Throwable, ? extends CompletableSource> errorMapper;
53
54 boolean once;
55
56 ResumeNextObserver(CompletableObserver observer, Function<? super Throwable, ? extends CompletableSource> errorMapper) {
57 this.downstream = observer;
58 this.errorMapper = errorMapper;
59 }
60
61 @Override
62 public void onSubscribe(Disposable d) {
63 DisposableHelper.replace(this, d);
64 }
65
66 @Override
67 public void onComplete() {
68 downstream.onComplete();
69 }
70
71 @Override
72 public void onError(Throwable e) {
73 if (once) {
74 downstream.onError(e);
75 return;
76 }
77 once = true;
78
79 CompletableSource c;
80
81 try {
82 c = Objects.requireNonNull(errorMapper.apply(e), "The errorMapper returned a null CompletableSource");
83 } catch (Throwable ex) {
84 Exceptions.throwIfFatal(ex);
85 downstream.onError(new CompositeException(e, ex));
86 return;
87 }
88
89 c.subscribe(this);
90 }
91
92 @Override
93 public boolean isDisposed() {
94 return DisposableHelper.isDisposed(get());
95 }
96
97 @Override
98 public void dispose() {
99 DisposableHelper.dispose(this);
100 }
101 }
102 }