Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSwitchMap.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.observable;
15
16 import java.util.Objects;
17 import java.util.concurrent.atomic.*;
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.operators.QueueDisposable;
26 import io.reactivex.rxjava3.operators.SimpleQueue;
27 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
28 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
29
30 public final class ObservableSwitchMap<T, R> extends AbstractObservableWithUpstream<T, R> {
31 final Function<? super T, ? extends ObservableSource<? extends R>> mapper;
32 final int bufferSize;
33
34 final boolean delayErrors;
35
36 public ObservableSwitchMap(ObservableSource<T> source,
37 Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize,
38 boolean delayErrors) {
39 super(source);
40 this.mapper = mapper;
41 this.bufferSize = bufferSize;
42 this.delayErrors = delayErrors;
43 }
44
45 @Override
46 public void subscribeActual(Observer<? super R> t) {
47
48 if (ObservableScalarXMap.tryScalarXMapSubscribe(source, t, mapper)) {
49 return;
50 }
51
52 source.subscribe(new SwitchMapObserver<>(t, mapper, bufferSize, delayErrors));
53 }
54
55 static final class SwitchMapObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
56
57 private static final long serialVersionUID = -3491074160481096299L;
58 final Observer<? super R> downstream;
59 final Function<? super T, ? extends ObservableSource<? extends R>> mapper;
60 final int bufferSize;
61
62 final boolean delayErrors;
63
64 final AtomicThrowable errors;
65
66 volatile boolean done;
67
68 volatile boolean cancelled;
69
70 Disposable upstream;
71
72 final AtomicReference<SwitchMapInnerObserver<T, R>> active = new AtomicReference<>();
73
74 static final SwitchMapInnerObserver<Object, Object> CANCELLED;
75 static {
76 CANCELLED = new SwitchMapInnerObserver<>(null, -1L, 1);
77 CANCELLED.cancel();
78 }
79
80 volatile long unique;
81
82 SwitchMapObserver(Observer<? super R> actual,
83 Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize,
84 boolean delayErrors) {
85 this.downstream = actual;
86 this.mapper = mapper;
87 this.bufferSize = bufferSize;
88 this.delayErrors = delayErrors;
89 this.errors = new AtomicThrowable();
90 }
91
92 @Override
93 public void onSubscribe(Disposable d) {
94 if (DisposableHelper.validate(this.upstream, d)) {
95 this.upstream = d;
96 downstream.onSubscribe(this);
97 }
98 }
99
100 @Override
101 public void onNext(T t) {
102 long c = unique + 1;
103 unique = c;
104
105 SwitchMapInnerObserver<T, R> inner = active.get();
106 if (inner != null) {
107 inner.cancel();
108 }
109
110 ObservableSource<? extends R> p;
111 try {
112 p = Objects.requireNonNull(mapper.apply(t), "The ObservableSource returned is null");
113 } catch (Throwable e) {
114 Exceptions.throwIfFatal(e);
115 upstream.dispose();
116 onError(e);
117 return;
118 }
119
120 SwitchMapInnerObserver<T, R> nextInner = new SwitchMapInnerObserver<>(this, c, bufferSize);
121
122 for (;;) {
123 inner = active.get();
124 if (inner == CANCELLED) {
125 break;
126 }
127 if (active.compareAndSet(inner, nextInner)) {
128 p.subscribe(nextInner);
129 break;
130 }
131 }
132 }
133
134 @Override
135 public void onError(Throwable t) {
136 if (!done && errors.tryAddThrowable(t)) {
137 if (!delayErrors) {
138 disposeInner();
139 }
140 done = true;
141 drain();
142 } else {
143 RxJavaPlugins.onError(t);
144 }
145 }
146
147 @Override
148 public void onComplete() {
149 if (!done) {
150 done = true;
151 drain();
152 }
153 }
154
155 @Override
156 public void dispose() {
157 if (!cancelled) {
158 cancelled = true;
159 upstream.dispose();
160 disposeInner();
161
162 errors.tryTerminateAndReport();
163 }
164 }
165
166 @Override
167 public boolean isDisposed() {
168 return cancelled;
169 }
170
171 @SuppressWarnings("unchecked")
172 void disposeInner() {
173 SwitchMapInnerObserver<T, R> a = active.getAndSet((SwitchMapInnerObserver<T, R>)CANCELLED);
174 if (a != null) {
175 a.cancel();
176 }
177 }
178
179 void drain() {
180 if (getAndIncrement() != 0) {
181 return;
182 }
183
184 final Observer<? super R> a = downstream;
185 final AtomicReference<SwitchMapInnerObserver<T, R>> active = this.active;
186 final boolean delayErrors = this.delayErrors;
187
188 int missing = 1;
189
190 for (;;) {
191
192 if (cancelled) {
193 return;
194 }
195
196 if (done) {
197 boolean empty = active.get() == null;
198 if (delayErrors) {
199 if (empty) {
200 Throwable ex = errors.get();
201 if (ex != null) {
202 a.onError(ex);
203 } else {
204 a.onComplete();
205 }
206 return;
207 }
208 } else {
209 Throwable ex = errors.get();
210 if (ex != null) {
211 errors.tryTerminateConsumer(a);
212 return;
213 }
214 if (empty) {
215 a.onComplete();
216 return;
217 }
218 }
219 }
220
221 SwitchMapInnerObserver<T, R> inner = active.get();
222
223 if (inner != null) {
224 SimpleQueue<R> q = inner.queue;
225
226 if (q != null) {
227
228 boolean retry = false;
229
230 for (;;) {
231 if (cancelled) {
232 return;
233 }
234 if (inner != active.get()) {
235 retry = true;
236 break;
237 }
238
239 if (!delayErrors) {
240 Throwable ex = errors.get();
241 if (ex != null) {
242 errors.tryTerminateConsumer(a);
243 return;
244 }
245 }
246
247 boolean d = inner.done;
248 R v;
249
250 try {
251 v = q.poll();
252 } catch (Throwable ex) {
253 Exceptions.throwIfFatal(ex);
254 errors.tryAddThrowableOrReport(ex);
255 active.compareAndSet(inner, null);
256 if (!delayErrors) {
257 disposeInner();
258 upstream.dispose();
259 done = true;
260 } else {
261 inner.cancel();
262 }
263 v = null;
264 retry = true;
265 }
266 boolean empty = v == null;
267
268 if (d && empty) {
269 active.compareAndSet(inner, null);
270 retry = true;
271 break;
272 }
273
274 if (empty) {
275 break;
276 }
277
278 a.onNext(v);
279 }
280
281 if (retry) {
282 continue;
283 }
284 }
285 }
286
287 missing = addAndGet(-missing);
288 if (missing == 0) {
289 break;
290 }
291 }
292 }
293
294 void innerError(SwitchMapInnerObserver<T, R> inner, Throwable ex) {
295 if (inner.index == unique && errors.tryAddThrowable(ex)) {
296 if (!delayErrors) {
297 upstream.dispose();
298 done = true;
299 }
300 inner.done = true;
301 drain();
302 } else {
303 RxJavaPlugins.onError(ex);
304 }
305 }
306 }
307
308 static final class SwitchMapInnerObserver<T, R> extends AtomicReference<Disposable> implements Observer<R> {
309
310 private static final long serialVersionUID = 3837284832786408377L;
311 final SwitchMapObserver<T, R> parent;
312 final long index;
313
314 final int bufferSize;
315
316 volatile SimpleQueue<R> queue;
317
318 volatile boolean done;
319
320 SwitchMapInnerObserver(SwitchMapObserver<T, R> parent, long index, int bufferSize) {
321 this.parent = parent;
322 this.index = index;
323 this.bufferSize = bufferSize;
324 }
325
326 @Override
327 public void onSubscribe(Disposable d) {
328 if (DisposableHelper.setOnce(this, d)) {
329 if (d instanceof QueueDisposable) {
330 @SuppressWarnings("unchecked")
331 QueueDisposable<R> qd = (QueueDisposable<R>) d;
332
333 int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);
334 if (m == QueueDisposable.SYNC) {
335 queue = qd;
336 done = true;
337 parent.drain();
338 return;
339 }
340 if (m == QueueDisposable.ASYNC) {
341 queue = qd;
342 return;
343 }
344 }
345
346 queue = new SpscLinkedArrayQueue<>(bufferSize);
347 }
348 }
349
350 @Override
351 public void onNext(R t) {
352 if (index == parent.unique) {
353 if (t != null) {
354 queue.offer(t);
355 }
356 parent.drain();
357 }
358 }
359
360 @Override
361 public void onError(Throwable t) {
362 parent.innerError(this, t);
363 }
364
365 @Override
366 public void onComplete() {
367 if (index == parent.unique) {
368 done = true;
369 parent.drain();
370 }
371 }
372
373 public void cancel() {
374 DisposableHelper.dispose(this);
375 }
376 }
377 }