Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableDebounceTimed.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 import java.util.concurrent.atomic.*;
18
19 import io.reactivex.rxjava3.core.*;
20 import io.reactivex.rxjava3.core.Scheduler.Worker;
21 import io.reactivex.rxjava3.disposables.Disposable;
22 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
23 import io.reactivex.rxjava3.observers.SerializedObserver;
24 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
25
26 public final class ObservableDebounceTimed<T> extends AbstractObservableWithUpstream<T, T> {
27 final long timeout;
28 final TimeUnit unit;
29 final Scheduler scheduler;
30
31 public ObservableDebounceTimed(ObservableSource<T> source, long timeout, TimeUnit unit, Scheduler scheduler) {
32 super(source);
33 this.timeout = timeout;
34 this.unit = unit;
35 this.scheduler = scheduler;
36 }
37
38 @Override
39 public void subscribeActual(Observer<? super T> t) {
40 source.subscribe(new DebounceTimedObserver<>(
41 new SerializedObserver<>(t),
42 timeout, unit, scheduler.createWorker()));
43 }
44
45 static final class DebounceTimedObserver<T>
46 implements Observer<T>, Disposable {
47 final Observer<? super T> downstream;
48 final long timeout;
49 final TimeUnit unit;
50 final Scheduler.Worker worker;
51
52 Disposable upstream;
53
54 Disposable timer;
55
56 volatile long index;
57
58 boolean done;
59
60 DebounceTimedObserver(Observer<? super T> actual, long timeout, TimeUnit unit, Worker worker) {
61 this.downstream = actual;
62 this.timeout = timeout;
63 this.unit = unit;
64 this.worker = worker;
65 }
66
67 @Override
68 public void onSubscribe(Disposable d) {
69 if (DisposableHelper.validate(this.upstream, d)) {
70 this.upstream = d;
71 downstream.onSubscribe(this);
72 }
73 }
74
75 @Override
76 public void onNext(T t) {
77 if (done) {
78 return;
79 }
80 long idx = index + 1;
81 index = idx;
82
83 Disposable d = timer;
84 if (d != null) {
85 d.dispose();
86 }
87
88 DebounceEmitter<T> de = new DebounceEmitter<>(t, idx, this);
89 timer = de;
90 d = worker.schedule(de, timeout, unit);
91 de.setResource(d);
92 }
93
94 @Override
95 public void onError(Throwable t) {
96 if (done) {
97 RxJavaPlugins.onError(t);
98 return;
99 }
100 Disposable d = timer;
101 if (d != null) {
102 d.dispose();
103 }
104 done = true;
105 downstream.onError(t);
106 worker.dispose();
107 }
108
109 @Override
110 public void onComplete() {
111 if (done) {
112 return;
113 }
114 done = true;
115
116 Disposable d = timer;
117 if (d != null) {
118 d.dispose();
119 }
120
121 @SuppressWarnings("unchecked")
122 DebounceEmitter<T> de = (DebounceEmitter<T>)d;
123 if (de != null) {
124 de.run();
125 }
126 downstream.onComplete();
127 worker.dispose();
128 }
129
130 @Override
131 public void dispose() {
132 upstream.dispose();
133 worker.dispose();
134 }
135
136 @Override
137 public boolean isDisposed() {
138 return worker.isDisposed();
139 }
140
141 void emit(long idx, T t, DebounceEmitter<T> emitter) {
142 if (idx == index) {
143 downstream.onNext(t);
144 emitter.dispose();
145 }
146 }
147 }
148
149 static final class DebounceEmitter<T> extends AtomicReference<Disposable> implements Runnable, Disposable {
150
151 private static final long serialVersionUID = 6812032969491025141L;
152
153 final T value;
154 final long idx;
155 final DebounceTimedObserver<T> parent;
156
157 final AtomicBoolean once = new AtomicBoolean();
158
159 DebounceEmitter(T value, long idx, DebounceTimedObserver<T> parent) {
160 this.value = value;
161 this.idx = idx;
162 this.parent = parent;
163 }
164
165 @Override
166 public void run() {
167 if (once.compareAndSet(false, true)) {
168 parent.emit(idx, value, this);
169 }
170 }
171
172 @Override
173 public void dispose() {
174 DisposableHelper.dispose(this);
175 }
176
177 @Override
178 public boolean isDisposed() {
179 return get() == DisposableHelper.DISPOSED;
180 }
181
182 public void setResource(Disposable d) {
183 DisposableHelper.replace(this, d);
184 }
185 }
186 }