Debian Codegraph @

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