Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableInterval.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.TimeUnit;
17 import java.util.concurrent.atomic.*;
18
19 import org.reactivestreams.*;
20
21 import io.reactivex.rxjava3.core.*;
22 import io.reactivex.rxjava3.core.Scheduler.Worker;
23 import io.reactivex.rxjava3.disposables.Disposable;
24 import io.reactivex.rxjava3.exceptions.MissingBackpressureException;
25 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
26 import io.reactivex.rxjava3.internal.schedulers.TrampolineScheduler;
27 import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;
28 import io.reactivex.rxjava3.internal.util.BackpressureHelper;
29
30 public final class FlowableInterval extends Flowable<Long> {
31 final Scheduler scheduler;
32 final long initialDelay;
33 final long period;
34 final TimeUnit unit;
35
36 public FlowableInterval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
37 this.initialDelay = initialDelay;
38 this.period = period;
39 this.unit = unit;
40 this.scheduler = scheduler;
41 }
42
43 @Override
44 public void subscribeActual(Subscriber<? super Long> s) {
45 IntervalSubscriber is = new IntervalSubscriber(s);
46 s.onSubscribe(is);
47
48 Scheduler sch = scheduler;
49
50 if (sch instanceof TrampolineScheduler) {
51 Worker worker = sch.createWorker();
52 is.setResource(worker);
53 worker.schedulePeriodically(is, initialDelay, period, unit);
54 } else {
55 Disposable d = sch.schedulePeriodicallyDirect(is, initialDelay, period, unit);
56 is.setResource(d);
57 }
58 }
59
60 static final class IntervalSubscriber extends AtomicLong
61 implements Subscription, Runnable {
62
63 private static final long serialVersionUID = -2809475196591179431L;
64
65 final Subscriber<? super Long> downstream;
66
67 long count;
68
69 final AtomicReference<Disposable> resource = new AtomicReference<>();
70
71 IntervalSubscriber(Subscriber<? super Long> downstream) {
72 this.downstream = downstream;
73 }
74
75 @Override
76 public void request(long n) {
77 if (SubscriptionHelper.validate(n)) {
78 BackpressureHelper.add(this, n);
79 }
80 }
81
82 @Override
83 public void cancel() {
84 DisposableHelper.dispose(resource);
85 }
86
87 @Override
88 public void run() {
89 if (resource.get() != DisposableHelper.DISPOSED) {
90 long r = get();
91
92 if (r != 0L) {
93 downstream.onNext(count++);
94 BackpressureHelper.produced(this, 1);
95 } else {
96 downstream.onError(new MissingBackpressureException("Can't deliver value " + count + " due to lack of requests"));
97 DisposableHelper.dispose(resource);
98 }
99 }
100 }
101
102 public void setResource(Disposable d) {
103 DisposableHelper.setOnce(resource, d);
104 }
105 }
106 }