Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/mixed/ObservableSwitchMapCompletable.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.mixed;
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.Exceptions;
22 import io.reactivex.rxjava3.functions.Function;
23 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
24 import io.reactivex.rxjava3.internal.util.AtomicThrowable;
25 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
26
27 /**
28 * Maps the upstream values into {@link CompletableSource}s, subscribes to the newer one while
29 * disposing the subscription to the previous {@code CompletableSource}, thus keeping at most one
30 * active {@code CompletableSource} running.
31 * <p>History: 2.1.11 - experimental
32 * @param <T> the upstream value type
33 * @since 2.2
34 */
35 public final class ObservableSwitchMapCompletable<T> extends Completable {
36
37 final Observable<T> source;
38
39 final Function<? super T, ? extends CompletableSource> mapper;
40
41 final boolean delayErrors;
42
43 public ObservableSwitchMapCompletable(Observable<T> source,
44 Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors) {
45 this.source = source;
46 this.mapper = mapper;
47 this.delayErrors = delayErrors;
48 }
49
50 @Override
51 protected void subscribeActual(CompletableObserver observer) {
52 if (!ScalarXMapZHelper.tryAsCompletable(source, mapper, observer)) {
53 source.subscribe(new SwitchMapCompletableObserver<>(observer, mapper, delayErrors));
54 }
55 }
56
57 static final class SwitchMapCompletableObserver<T> implements Observer<T>, Disposable {
58
59 final CompletableObserver downstream;
60
61 final Function<? super T, ? extends CompletableSource> mapper;
62
63 final boolean delayErrors;
64
65 final AtomicThrowable errors;
66
67 final AtomicReference<SwitchMapInnerObserver> inner;
68
69 static final SwitchMapInnerObserver INNER_DISPOSED = new SwitchMapInnerObserver(null);
70
71 volatile boolean done;
72
73 Disposable upstream;
74
75 SwitchMapCompletableObserver(CompletableObserver downstream,
76 Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors) {
77 this.downstream = downstream;
78 this.mapper = mapper;
79 this.delayErrors = delayErrors;
80 this.errors = new AtomicThrowable();
81 this.inner = new AtomicReference<>();
82 }
83
84 @Override
85 public void onSubscribe(Disposable d) {
86 if (DisposableHelper.validate(upstream, d)) {
87 this.upstream = d;
88 downstream.onSubscribe(this);
89 }
90 }
91
92 @Override
93 public void onNext(T t) {
94 CompletableSource c;
95
96 try {
97 c = Objects.requireNonNull(mapper.apply(t), "The mapper returned a null CompletableSource");
98 } catch (Throwable ex) {
99 Exceptions.throwIfFatal(ex);
100 upstream.dispose();
101 onError(ex);
102 return;
103 }
104
105 SwitchMapInnerObserver o = new SwitchMapInnerObserver(this);
106
107 for (;;) {
108 SwitchMapInnerObserver current = inner.get();
109 if (current == INNER_DISPOSED) {
110 break;
111 }
112 if (inner.compareAndSet(current, o)) {
113 if (current != null) {
114 current.dispose();
115 }
116 c.subscribe(o);
117 break;
118 }
119 }
120 }
121
122 @Override
123 public void onError(Throwable t) {
124 if (errors.tryAddThrowableOrReport(t)) {
125 if (delayErrors) {
126 onComplete();
127 } else {
128 disposeInner();
129 errors.tryTerminateConsumer(downstream);
130 }
131 }
132 }
133
134 @Override
135 public void onComplete() {
136 done = true;
137 if (inner.get() == null) {
138 errors.tryTerminateConsumer(downstream);
139 }
140 }
141
142 void disposeInner() {
143 SwitchMapInnerObserver o = inner.getAndSet(INNER_DISPOSED);
144 if (o != null && o != INNER_DISPOSED) {
145 o.dispose();
146 }
147 }
148
149 @Override
150 public void dispose() {
151 upstream.dispose();
152 disposeInner();
153 errors.tryTerminateAndReport();
154 }
155
156 @Override
157 public boolean isDisposed() {
158 return inner.get() == INNER_DISPOSED;
159 }
160
161 void innerError(SwitchMapInnerObserver sender, Throwable error) {
162 if (inner.compareAndSet(sender, null)) {
163 if (errors.tryAddThrowableOrReport(error)) {
164 if (delayErrors) {
165 if (done) {
166 errors.tryTerminateConsumer(downstream);
167 }
168 } else {
169 upstream.dispose();
170 disposeInner();
171 errors.tryTerminateConsumer(downstream);
172 }
173 }
174 } else {
175 RxJavaPlugins.onError(error);
176 }
177 }
178
179 void innerComplete(SwitchMapInnerObserver sender) {
180 if (inner.compareAndSet(sender, null)) {
181 if (done) {
182 errors.tryTerminateConsumer(downstream);
183 }
184 }
185 }
186
187 static final class SwitchMapInnerObserver extends AtomicReference<Disposable>
188 implements CompletableObserver {
189
190 private static final long serialVersionUID = -8003404460084760287L;
191
192 final SwitchMapCompletableObserver<?> parent;
193
194 SwitchMapInnerObserver(SwitchMapCompletableObserver<?> parent) {
195 this.parent = parent;
196 }
197
198 @Override
199 public void onSubscribe(Disposable d) {
200 DisposableHelper.setOnce(this, d);
201 }
202
203 @Override
204 public void onError(Throwable e) {
205 parent.innerError(this, e);
206 }
207
208 @Override
209 public void onComplete() {
210 parent.innerComplete(this);
211 }
212
213 void dispose() {
214 DisposableHelper.dispose(this);
215 }
216 }
217 }
218 }