Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableDelay.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.concurrent.TimeUnit;
17
18 import io.reactivex.rxjava3.core.*;
19 import io.reactivex.rxjava3.core.Scheduler.Worker;
20 import io.reactivex.rxjava3.disposables.Disposable;
21 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
22 import io.reactivex.rxjava3.observers.SerializedObserver;
23
24 public final class ObservableDelay<T> extends AbstractObservableWithUpstream<T, T> {
25 final long delay;
26 final TimeUnit unit;
27 final Scheduler scheduler;
28 final boolean delayError;
29
30 public ObservableDelay(ObservableSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {
31 super(source);
32 this.delay = delay;
33 this.unit = unit;
34 this.scheduler = scheduler;
35 this.delayError = delayError;
36 }
37
38 @Override
39 @SuppressWarnings("unchecked")
40 public void subscribeActual(Observer<? super T> t) {
41 Observer<T> observer;
42 if (delayError) {
43 observer = (Observer<T>)t;
44 } else {
45 observer = new SerializedObserver<>(t);
46 }
47
48 Scheduler.Worker w = scheduler.createWorker();
49
50 source.subscribe(new DelayObserver<>(observer, delay, unit, w, delayError));
51 }
52
53 static final class DelayObserver<T> implements Observer<T>, Disposable {
54 final Observer<? super T> downstream;
55 final long delay;
56 final TimeUnit unit;
57 final Scheduler.Worker w;
58 final boolean delayError;
59
60 Disposable upstream;
61
62 DelayObserver(Observer<? super T> actual, long delay, TimeUnit unit, Worker w, boolean delayError) {
63 super();
64 this.downstream = actual;
65 this.delay = delay;
66 this.unit = unit;
67 this.w = w;
68 this.delayError = delayError;
69 }
70
71 @Override
72 public void onSubscribe(Disposable d) {
73 if (DisposableHelper.validate(this.upstream, d)) {
74 this.upstream = d;
75 downstream.onSubscribe(this);
76 }
77 }
78
79 @Override
80 public void onNext(final T t) {
81 w.schedule(new OnNext(t), delay, unit);
82 }
83
84 @Override
85 public void onError(final Throwable t) {
86 w.schedule(new OnError(t), delayError ? delay : 0, unit);
87 }
88
89 @Override
90 public void onComplete() {
91 w.schedule(new OnComplete(), delay, unit);
92 }
93
94 @Override
95 public void dispose() {
96 upstream.dispose();
97 w.dispose();
98 }
99
100 @Override
101 public boolean isDisposed() {
102 return w.isDisposed();
103 }
104
105 final class OnNext implements Runnable {
106 private final T t;
107
108 OnNext(T t) {
109 this.t = t;
110 }
111
112 @Override
113 public void run() {
114 downstream.onNext(t);
115 }
116 }
117
118 final class OnError implements Runnable {
119 private final Throwable throwable;
120
121 OnError(Throwable throwable) {
122 this.throwable = throwable;
123 }
124
125 @Override
126 public void run() {
127 try {
128 downstream.onError(throwable);
129 } finally {
130 w.dispose();
131 }
132 }
133 }
134
135 final class OnComplete implements Runnable {
136 @Override
137 public void run() {
138 try {
139 downstream.onComplete();
140 } finally {
141 w.dispose();
142 }
143 }
144 }
145 }
146 }