Debian Codegraph @

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