Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableCreate.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.flowable;
15
16 import java.util.concurrent.atomic.*;
17
18 import org.reactivestreams.*;
19
20 import io.reactivex.rxjava3.core.*;
21 import io.reactivex.rxjava3.disposables.Disposable;
22 import io.reactivex.rxjava3.exceptions.*;
23 import io.reactivex.rxjava3.functions.Cancellable;
24 import io.reactivex.rxjava3.internal.disposables.*;
25 import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;
26 import io.reactivex.rxjava3.internal.util.*;
27 import io.reactivex.rxjava3.operators.SimplePlainQueue;
28 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
29 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
30
31 public final class FlowableCreate<T> extends Flowable<T> {
32
33 final FlowableOnSubscribe<T> source;
34
35 final BackpressureStrategy backpressure;
36
37 public FlowableCreate(FlowableOnSubscribe<T> source, BackpressureStrategy backpressure) {
38 this.source = source;
39 this.backpressure = backpressure;
40 }
41
42 @Override
43 public void subscribeActual(Subscriber<? super T> t) {
44 BaseEmitter<T> emitter;
45
46 switch (backpressure) {
47 case MISSING: {
48 emitter = new MissingEmitter<>(t);
49 break;
50 }
51 case ERROR: {
52 emitter = new ErrorAsyncEmitter<>(t);
53 break;
54 }
55 case DROP: {
56 emitter = new DropAsyncEmitter<>(t);
57 break;
58 }
59 case LATEST: {
60 emitter = new LatestAsyncEmitter<>(t);
61 break;
62 }
63 default: {
64 emitter = new BufferAsyncEmitter<>(t, bufferSize());
65 break;
66 }
67 }
68
69 t.onSubscribe(emitter);
70 try {
71 source.subscribe(emitter);
72 } catch (Throwable ex) {
73 Exceptions.throwIfFatal(ex);
74 emitter.onError(ex);
75 }
76 }
77
78 /**
79 * Serializes calls to onNext, onError and onComplete.
80 *
81 * @param <T> the value type
82 */
83 static final class SerializedEmitter<T>
84 extends AtomicInteger
85 implements FlowableEmitter<T> {
86
87 private static final long serialVersionUID = 4883307006032401862L;
88
89 final BaseEmitter<T> emitter;
90
91 final AtomicThrowable errors;
92
93 final SimplePlainQueue<T> queue;
94
95 volatile boolean done;
96
97 SerializedEmitter(BaseEmitter<T> emitter) {
98 this.emitter = emitter;
99 this.errors = new AtomicThrowable();
100 this.queue = new SpscLinkedArrayQueue<>(16);
101 }
102
103 @Override
104 public void onNext(T t) {
105 if (emitter.isCancelled() || done) {
106 return;
107 }
108 if (t == null) {
109 onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
110 return;
111 }
112 if (get() == 0 && compareAndSet(0, 1)) {
113 emitter.onNext(t);
114 if (decrementAndGet() == 0) {
115 return;
116 }
117 } else {
118 SimplePlainQueue<T> q = queue;
119 synchronized (q) {
120 q.offer(t);
121 }
122 if (getAndIncrement() != 0) {
123 return;
124 }
125 }
126 drainLoop();
127 }
128
129 @Override
130 public void onError(Throwable t) {
131 if (!tryOnError(t)) {
132 RxJavaPlugins.onError(t);
133 }
134 }
135
136 @Override
137 public boolean tryOnError(Throwable t) {
138 if (emitter.isCancelled() || done) {
139 return false;
140 }
141 if (t == null) {
142 t = ExceptionHelper.createNullPointerException("onError called with a null Throwable.");
143 }
144 if (errors.tryAddThrowable(t)) {
145 done = true;
146 drain();
147 return true;
148 }
149 return false;
150 }
151
152 @Override
153 public void onComplete() {
154 if (emitter.isCancelled() || done) {
155 return;
156 }
157 done = true;
158 drain();
159 }
160
161 void drain() {
162 if (getAndIncrement() == 0) {
163 drainLoop();
164 }
165 }
166
167 void drainLoop() {
168 BaseEmitter<T> e = emitter;
169 SimplePlainQueue<T> q = queue;
170 AtomicThrowable errors = this.errors;
171 int missed = 1;
172 for (;;) {
173
174 for (;;) {
175 if (e.isCancelled()) {
176 q.clear();
177 return;
178 }
179
180 if (errors.get() != null) {
181 q.clear();
182 errors.tryTerminateConsumer(e);
183 return;
184 }
185
186 boolean d = done;
187
188 T v = q.poll();
189
190 boolean empty = v == null;
191
192 if (d && empty) {
193 e.onComplete();
194 return;
195 }
196
197 if (empty) {
198 break;
199 }
200
201 e.onNext(v);
202 }
203
204 missed = addAndGet(-missed);
205 if (missed == 0) {
206 break;
207 }
208 }
209 }
210
211 @Override
212 public void setDisposable(Disposable d) {
213 emitter.setDisposable(d);
214 }
215
216 @Override
217 public void setCancellable(Cancellable c) {
218 emitter.setCancellable(c);
219 }
220
221 @Override
222 public long requested() {
223 return emitter.requested();
224 }
225
226 @Override
227 public boolean isCancelled() {
228 return emitter.isCancelled();
229 }
230
231 @Override
232 public FlowableEmitter<T> serialize() {
233 return this;
234 }
235
236 @Override
237 public String toString() {
238 return emitter.toString();
239 }
240 }
241
242 abstract static class BaseEmitter<T>
243 extends AtomicLong
244 implements FlowableEmitter<T>, Subscription {
245 private static final long serialVersionUID = 7326289992464377023L;
246
247 final Subscriber<? super T> downstream;
248
249 final SequentialDisposable serial;
250
251 BaseEmitter(Subscriber<? super T> downstream) {
252 this.downstream = downstream;
253 this.serial = new SequentialDisposable();
254 }
255
256 @Override
257 public void onComplete() {
258 completeDownstream();
259 }
260
261 protected void completeDownstream() {
262 if (isCancelled()) {
263 return;
264 }
265 try {
266 downstream.onComplete();
267 } finally {
268 serial.dispose();
269 }
270 }
271
272 @Override
273 public final void onError(Throwable e) {
274 if (e == null) {
275 e = ExceptionHelper.createNullPointerException("onError called with a null Throwable.");
276 }
277 if (!signalError(e)) {
278 RxJavaPlugins.onError(e);
279 }
280 }
281
282 @Override
283 public final boolean tryOnError(Throwable e) {
284 if (e == null) {
285 e = ExceptionHelper.createNullPointerException("tryOnError called with a null Throwable.");
286 }
287 return signalError(e);
288 }
289
290 public boolean signalError(Throwable e) {
291 return errorDownstream(e);
292 }
293
294 protected boolean errorDownstream(Throwable e) {
295 if (isCancelled()) {
296 return false;
297 }
298 try {
299 downstream.onError(e);
300 } finally {
301 serial.dispose();
302 }
303 return true;
304 }
305
306 @Override
307 public final void cancel() {
308 serial.dispose();
309 onUnsubscribed();
310 }
311
312 void onUnsubscribed() {
313 // default is no-op
314 }
315
316 @Override
317 public final boolean isCancelled() {
318 return serial.isDisposed();
319 }
320
321 @Override
322 public final void request(long n) {
323 if (SubscriptionHelper.validate(n)) {
324 BackpressureHelper.add(this, n);
325 onRequested();
326 }
327 }
328
329 void onRequested() {
330 // default is no-op
331 }
332
333 @Override
334 public final void setDisposable(Disposable d) {
335 serial.update(d);
336 }
337
338 @Override
339 public final void setCancellable(Cancellable c) {
340 setDisposable(new CancellableDisposable(c));
341 }
342
343 @Override
344 public final long requested() {
345 return get();
346 }
347
348 @Override
349 public final FlowableEmitter<T> serialize() {
350 return new SerializedEmitter<>(this);
351 }
352
353 @Override
354 public String toString() {
355 return String.format("%s{%s}", getClass().getSimpleName(), super.toString());
356 }
357 }
358
359 static final class MissingEmitter<T> extends BaseEmitter<T> {
360
361 private static final long serialVersionUID = 3776720187248809713L;
362
363 MissingEmitter(Subscriber<? super T> downstream) {
364 super(downstream);
365 }
366
367 @Override
368 public void onNext(T t) {
369 if (isCancelled()) {
370 return;
371 }
372
373 if (t != null) {
374 downstream.onNext(t);
375 } else {
376 onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
377 return;
378 }
379
380 for (;;) {
381 long r = get();
382 if (r == 0L || compareAndSet(r, r - 1)) {
383 return;
384 }
385 }
386 }
387
388 }
389
390 abstract static class NoOverflowBaseAsyncEmitter<T> extends BaseEmitter<T> {
391
392 private static final long serialVersionUID = 4127754106204442833L;
393
394 NoOverflowBaseAsyncEmitter(Subscriber<? super T> downstream) {
395 super(downstream);
396 }
397
398 @Override
399 public final void onNext(T t) {
400 if (isCancelled()) {
401 return;
402 }
403
404 if (t == null) {
405 onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
406 return;
407 }
408
409 if (get() != 0) {
410 downstream.onNext(t);
411 BackpressureHelper.produced(this, 1);
412 } else {
413 onOverflow();
414 }
415 }
416
417 abstract void onOverflow();
418 }
419
420 static final class DropAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
421
422 private static final long serialVersionUID = 8360058422307496563L;
423
424 DropAsyncEmitter(Subscriber<? super T> downstream) {
425 super(downstream);
426 }
427
428 @Override
429 void onOverflow() {
430 // nothing to do
431 }
432
433 }
434
435 static final class ErrorAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
436
437 private static final long serialVersionUID = 338953216916120960L;
438
439 ErrorAsyncEmitter(Subscriber<? super T> downstream) {
440 super(downstream);
441 }
442
443 @Override
444 void onOverflow() {
445 onError(new MissingBackpressureException("create: could not emit value due to lack of requests"));
446 }
447
448 }
449
450 static final class BufferAsyncEmitter<T> extends BaseEmitter<T> {
451
452 private static final long serialVersionUID = 2427151001689639875L;
453
454 final SpscLinkedArrayQueue<T> queue;
455
456 Throwable error;
457 volatile boolean done;
458
459 final AtomicInteger wip;
460
461 BufferAsyncEmitter(Subscriber<? super T> actual, int capacityHint) {
462 super(actual);
463 this.queue = new SpscLinkedArrayQueue<>(capacityHint);
464 this.wip = new AtomicInteger();
465 }
466
467 @Override
468 public void onNext(T t) {
469 if (done || isCancelled()) {
470 return;
471 }
472
473 if (t == null) {
474 onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
475 return;
476 }
477 queue.offer(t);
478 drain();
479 }
480
481 @Override
482 public boolean signalError(Throwable e) {
483 if (done || isCancelled()) {
484 return false;
485 }
486
487 error = e;
488 done = true;
489 drain();
490 return true;
491 }
492
493 @Override
494 public void onComplete() {
495 done = true;
496 drain();
497 }
498
499 @Override
500 void onRequested() {
501 drain();
502 }
503
504 @Override
505 void onUnsubscribed() {
506 if (wip.getAndIncrement() == 0) {
507 queue.clear();
508 }
509 }
510
511 void drain() {
512 if (wip.getAndIncrement() != 0) {
513 return;
514 }
515
516 int missed = 1;
517 final Subscriber<? super T> a = downstream;
518 final SpscLinkedArrayQueue<T> q = queue;
519
520 for (;;) {
521 long r = get();
522 long e = 0L;
523
524 while (e != r) {
525 if (isCancelled()) {
526 q.clear();
527 return;
528 }
529
530 boolean d = done;
531
532 T o = q.poll();
533
534 boolean empty = o == null;
535
536 if (d && empty) {
537 Throwable ex = error;
538 if (ex != null) {
539 errorDownstream(ex);
540 } else {
541 completeDownstream();
542 }
543 return;
544 }
545
546 if (empty) {
547 break;
548 }
549
550 a.onNext(o);
551
552 e++;
553 }
554
555 if (e == r) {
556 if (isCancelled()) {
557 q.clear();
558 return;
559 }
560
561 boolean d = done;
562
563 boolean empty = q.isEmpty();
564
565 if (d && empty) {
566 Throwable ex = error;
567 if (ex != null) {
568 errorDownstream(ex);
569 } else {
570 completeDownstream();
571 }
572 return;
573 }
574 }
575
576 if (e != 0) {
577 BackpressureHelper.produced(this, e);
578 }
579
580 missed = wip.addAndGet(-missed);
581 if (missed == 0) {
582 break;
583 }
584 }
585 }
586 }
587
588 static final class LatestAsyncEmitter<T> extends BaseEmitter<T> {
589
590 private static final long serialVersionUID = 4023437720691792495L;
591
592 final AtomicReference<T> queue;
593
594 Throwable error;
595 volatile boolean done;
596
597 final AtomicInteger wip;
598
599 LatestAsyncEmitter(Subscriber<? super T> downstream) {
600 super(downstream);
601 this.queue = new AtomicReference<>();
602 this.wip = new AtomicInteger();
603 }
604
605 @Override
606 public void onNext(T t) {
607 if (done || isCancelled()) {
608 return;
609 }
610
611 if (t == null) {
612 onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
613 return;
614 }
615 queue.set(t);
616 drain();
617 }
618
619 @Override
620 public boolean signalError(Throwable e) {
621 if (done || isCancelled()) {
622 return false;
623 }
624 error = e;
625 done = true;
626 drain();
627 return true;
628 }
629
630 @Override
631 public void onComplete() {
632 done = true;
633 drain();
634 }
635
636 @Override
637 void onRequested() {
638 drain();
639 }
640
641 @Override
642 void onUnsubscribed() {
643 if (wip.getAndIncrement() == 0) {
644 queue.lazySet(null);
645 }
646 }
647
648 void drain() {
649 if (wip.getAndIncrement() != 0) {
650 return;
651 }
652
653 int missed = 1;
654 final Subscriber<? super T> a = downstream;
655 final AtomicReference<T> q = queue;
656
657 for (;;) {
658 long r = get();
659 long e = 0L;
660
661 while (e != r) {
662 if (isCancelled()) {
663 q.lazySet(null);
664 return;
665 }
666
667 boolean d = done;
668
669 T o = q.getAndSet(null);
670
671 boolean empty = o == null;
672
673 if (d && empty) {
674 Throwable ex = error;
675 if (ex != null) {
676 errorDownstream(ex);
677 } else {
678 completeDownstream();
679 }
680 return;
681 }
682
683 if (empty) {
684 break;
685 }
686
687 a.onNext(o);
688
689 e++;
690 }
691
692 if (e == r) {
693 if (isCancelled()) {
694 q.lazySet(null);
695 return;
696 }
697
698 boolean d = done;
699
700 boolean empty = q.get() == null;
701
702 if (d && empty) {
703 Throwable ex = error;
704 if (ex != null) {
705 errorDownstream(ex);
706 } else {
707 completeDownstream();
708 }
709 return;
710 }
711 }
712
713 if (e != 0) {
714 BackpressureHelper.produced(this, e);
715 }
716
717 missed = wip.addAndGet(-missed);
718 if (missed == 0) {
719 break;
720 }
721 }
722 }
723 }
724
725 }