Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatMap.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.*;
23 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
24 import io.reactivex.rxjava3.internal.util.*;
25 import io.reactivex.rxjava3.observers.SerializedObserver;
26 import io.reactivex.rxjava3.operators.QueueDisposable;
27 import io.reactivex.rxjava3.operators.SimpleQueue;
28 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
29 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
30
31 public final class ObservableConcatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
32 final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
33 final int bufferSize;
34
35 final ErrorMode delayErrors;
36
37 public ObservableConcatMap(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<? extends U>> mapper,
38 int bufferSize, ErrorMode delayErrors) {
39 super(source);
40 this.mapper = mapper;
41 this.delayErrors = delayErrors;
42 this.bufferSize = Math.max(8, bufferSize);
43 }
44
45 @Override
46 public void subscribeActual(Observer<? super U> observer) {
47
48 if (ObservableScalarXMap.tryScalarXMapSubscribe(source, observer, mapper)) {
49 return;
50 }
51
52 if (delayErrors == ErrorMode.IMMEDIATE) {
53 SerializedObserver<U> serial = new SerializedObserver<>(observer);
54 source.subscribe(new SourceObserver<>(serial, mapper, bufferSize));
55 } else {
56 source.subscribe(new ConcatMapDelayErrorObserver<>(observer, mapper, bufferSize, delayErrors == ErrorMode.END));
57 }
58 }
59
60 static final class SourceObserver<T, U> extends AtomicInteger implements Observer<T>, Disposable {
61
62 private static final long serialVersionUID = 8828587559905699186L;
63 final Observer<? super U> downstream;
64 final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
65 final InnerObserver<U> inner;
66 final int bufferSize;
67
68 SimpleQueue<T> queue;
69
70 Disposable upstream;
71
72 volatile boolean active;
73
74 volatile boolean disposed;
75
76 volatile boolean done;
77
78 int fusionMode;
79
80 SourceObserver(Observer<? super U> actual,
81 Function<? super T, ? extends ObservableSource<? extends U>> mapper, int bufferSize) {
82 this.downstream = actual;
83 this.mapper = mapper;
84 this.bufferSize = bufferSize;
85 this.inner = new InnerObserver<>(actual, this);
86 }
87
88 @Override
89 public void onSubscribe(Disposable d) {
90 if (DisposableHelper.validate(this.upstream, d)) {
91 this.upstream = d;
92 if (d instanceof QueueDisposable) {
93 @SuppressWarnings("unchecked")
94 QueueDisposable<T> qd = (QueueDisposable<T>) d;
95
96 int m = qd.requestFusion(QueueDisposable.ANY);
97 if (m == QueueDisposable.SYNC) {
98 fusionMode = m;
99 queue = qd;
100 done = true;
101
102 downstream.onSubscribe(this);
103
104 drain();
105 return;
106 }
107
108 if (m == QueueDisposable.ASYNC) {
109 fusionMode = m;
110 queue = qd;
111
112 downstream.onSubscribe(this);
113
114 return;
115 }
116 }
117
118 queue = new SpscLinkedArrayQueue<>(bufferSize);
119
120 downstream.onSubscribe(this);
121 }
122 }
123
124 @Override
125 public void onNext(T t) {
126 if (done) {
127 return;
128 }
129 if (fusionMode == QueueDisposable.NONE) {
130 queue.offer(t);
131 }
132 drain();
133 }
134
135 @Override
136 public void onError(Throwable t) {
137 if (done) {
138 RxJavaPlugins.onError(t);
139 return;
140 }
141 done = true;
142 dispose();
143 downstream.onError(t);
144 }
145
146 @Override
147 public void onComplete() {
148 if (done) {
149 return;
150 }
151 done = true;
152 drain();
153 }
154
155 void innerComplete() {
156 active = false;
157 drain();
158 }
159
160 @Override
161 public boolean isDisposed() {
162 return disposed;
163 }
164
165 @Override
166 public void dispose() {
167 disposed = true;
168 inner.dispose();
169 upstream.dispose();
170 if (getAndIncrement() == 0) {
171 queue.clear();
172 }
173 }
174
175 void drain() {
176 if (getAndIncrement() != 0) {
177 return;
178 }
179
180 for (;;) {
181 if (disposed) {
182 queue.clear();
183 return;
184 }
185 if (!active) {
186
187 boolean d = done;
188
189 T t;
190
191 try {
192 t = queue.poll();
193 } catch (Throwable ex) {
194 Exceptions.throwIfFatal(ex);
195 dispose();
196 queue.clear();
197 downstream.onError(ex);
198 return;
199 }
200
201 boolean empty = t == null;
202
203 if (d && empty) {
204 disposed = true;
205 downstream.onComplete();
206 return;
207 }
208
209 if (!empty) {
210 ObservableSource<? extends U> o;
211
212 try {
213 o = Objects.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
214 } catch (Throwable ex) {
215 Exceptions.throwIfFatal(ex);
216 dispose();
217 queue.clear();
218 downstream.onError(ex);
219 return;
220 }
221
222 active = true;
223 o.subscribe(inner);
224 }
225 }
226
227 if (decrementAndGet() == 0) {
228 break;
229 }
230 }
231 }
232
233 static final class InnerObserver<U> extends AtomicReference<Disposable> implements Observer<U> {
234
235 private static final long serialVersionUID = -7449079488798789337L;
236
237 final Observer<? super U> downstream;
238 final SourceObserver<?, ?> parent;
239
240 InnerObserver(Observer<? super U> actual, SourceObserver<?, ?> parent) {
241 this.downstream = actual;
242 this.parent = parent;
243 }
244
245 @Override
246 public void onSubscribe(Disposable d) {
247 DisposableHelper.replace(this, d);
248 }
249
250 @Override
251 public void onNext(U t) {
252 downstream.onNext(t);
253 }
254
255 @Override
256 public void onError(Throwable t) {
257 parent.dispose();
258 downstream.onError(t);
259 }
260
261 @Override
262 public void onComplete() {
263 parent.innerComplete();
264 }
265
266 void dispose() {
267 DisposableHelper.dispose(this);
268 }
269 }
270 }
271
272 static final class ConcatMapDelayErrorObserver<T, R>
273 extends AtomicInteger
274 implements Observer<T>, Disposable {
275
276 private static final long serialVersionUID = -6951100001833242599L;
277
278 final Observer<? super R> downstream;
279
280 final Function<? super T, ? extends ObservableSource<? extends R>> mapper;
281
282 final int bufferSize;
283
284 final AtomicThrowable errors;
285
286 final DelayErrorInnerObserver<R> observer;
287
288 final boolean tillTheEnd;
289
290 SimpleQueue<T> queue;
291
292 Disposable upstream;
293
294 volatile boolean active;
295
296 volatile boolean done;
297
298 volatile boolean cancelled;
299
300 int sourceMode;
301
302 ConcatMapDelayErrorObserver(Observer<? super R> actual,
303 Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize,
304 boolean tillTheEnd) {
305 this.downstream = actual;
306 this.mapper = mapper;
307 this.bufferSize = bufferSize;
308 this.tillTheEnd = tillTheEnd;
309 this.errors = new AtomicThrowable();
310 this.observer = new DelayErrorInnerObserver<>(actual, this);
311 }
312
313 @Override
314 public void onSubscribe(Disposable d) {
315 if (DisposableHelper.validate(this.upstream, d)) {
316 this.upstream = d;
317
318 if (d instanceof QueueDisposable) {
319 @SuppressWarnings("unchecked")
320 QueueDisposable<T> qd = (QueueDisposable<T>) d;
321
322 int m = qd.requestFusion(QueueDisposable.ANY);
323 if (m == QueueDisposable.SYNC) {
324 sourceMode = m;
325 queue = qd;
326 done = true;
327
328 downstream.onSubscribe(this);
329
330 drain();
331 return;
332 }
333 if (m == QueueDisposable.ASYNC) {
334 sourceMode = m;
335 queue = qd;
336
337 downstream.onSubscribe(this);
338
339 return;
340 }
341 }
342
343 queue = new SpscLinkedArrayQueue<>(bufferSize);
344
345 downstream.onSubscribe(this);
346 }
347 }
348
349 @Override
350 public void onNext(T value) {
351 if (sourceMode == QueueDisposable.NONE) {
352 queue.offer(value);
353 }
354 drain();
355 }
356
357 @Override
358 public void onError(Throwable e) {
359 if (errors.tryAddThrowableOrReport(e)) {
360 done = true;
361 drain();
362 }
363 }
364
365 @Override
366 public void onComplete() {
367 done = true;
368 drain();
369 }
370
371 @Override
372 public boolean isDisposed() {
373 return cancelled;
374 }
375
376 @Override
377 public void dispose() {
378 cancelled = true;
379 upstream.dispose();
380 observer.dispose();
381 errors.tryTerminateAndReport();
382 }
383
384 @SuppressWarnings("unchecked")
385 void drain() {
386 if (getAndIncrement() != 0) {
387 return;
388 }
389
390 Observer<? super R> downstream = this.downstream;
391 SimpleQueue<T> queue = this.queue;
392 AtomicThrowable errors = this.errors;
393
394 for (;;) {
395
396 if (!active) {
397
398 if (cancelled) {
399 queue.clear();
400 return;
401 }
402
403 if (!tillTheEnd) {
404 Throwable ex = errors.get();
405 if (ex != null) {
406 queue.clear();
407 cancelled = true;
408 errors.tryTerminateConsumer(downstream);
409 return;
410 }
411 }
412
413 boolean d = done;
414
415 T v;
416
417 try {
418 v = queue.poll();
419 } catch (Throwable ex) {
420 Exceptions.throwIfFatal(ex);
421 cancelled = true;
422 this.upstream.dispose();
423 errors.tryAddThrowableOrReport(ex);
424 errors.tryTerminateConsumer(downstream);
425 return;
426 }
427
428 boolean empty = v == null;
429
430 if (d && empty) {
431 cancelled = true;
432 errors.tryTerminateConsumer(downstream);
433 return;
434 }
435
436 if (!empty) {
437
438 ObservableSource<? extends R> o;
439
440 try {
441 o = Objects.requireNonNull(mapper.apply(v), "The mapper returned a null ObservableSource");
442 } catch (Throwable ex) {
443 Exceptions.throwIfFatal(ex);
444 cancelled = true;
445 this.upstream.dispose();
446 queue.clear();
447 errors.tryAddThrowableOrReport(ex);
448 errors.tryTerminateConsumer(downstream);
449 return;
450 }
451
452 if (o instanceof Supplier) {
453 R w;
454
455 try {
456 w = ((Supplier<R>)o).get();
457 } catch (Throwable ex) {
458 Exceptions.throwIfFatal(ex);
459 errors.tryAddThrowableOrReport(ex);
460 continue;
461 }
462
463 if (w != null && !cancelled) {
464 downstream.onNext(w);
465 }
466 continue;
467 } else {
468 active = true;
469 o.subscribe(observer);
470 }
471 }
472 }
473
474 if (decrementAndGet() == 0) {
475 break;
476 }
477 }
478 }
479
480 static final class DelayErrorInnerObserver<R> extends AtomicReference<Disposable> implements Observer<R> {
481
482 private static final long serialVersionUID = 2620149119579502636L;
483
484 final Observer<? super R> downstream;
485
486 final ConcatMapDelayErrorObserver<?, R> parent;
487
488 DelayErrorInnerObserver(Observer<? super R> actual, ConcatMapDelayErrorObserver<?, R> parent) {
489 this.downstream = actual;
490 this.parent = parent;
491 }
492
493 @Override
494 public void onSubscribe(Disposable d) {
495 DisposableHelper.replace(this, d);
496 }
497
498 @Override
499 public void onNext(R value) {
500 downstream.onNext(value);
501 }
502
503 @Override
504 public void onError(Throwable e) {
505 ConcatMapDelayErrorObserver<?, R> p = parent;
506 if (p.errors.tryAddThrowableOrReport(e)) {
507 if (!p.tillTheEnd) {
508 p.upstream.dispose();
509 }
510 p.active = false;
511 p.drain();
512 }
513 }
514
515 @Override
516 public void onComplete() {
517 ConcatMapDelayErrorObserver<?, R> p = parent;
518 p.active = false;
519 p.drain();
520 }
521
522 void dispose() {
523 DisposableHelper.dispose(this);
524 }
525 }
526 }
527 }