Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSkipLastTimed.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.AtomicInteger;
18
19 import io.reactivex.rxjava3.core.*;
20 import io.reactivex.rxjava3.disposables.Disposable;
21 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
22 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
23
24 public final class ObservableSkipLastTimed<T> extends AbstractObservableWithUpstream<T, T> {
25 final long time;
26 final TimeUnit unit;
27 final Scheduler scheduler;
28 final int bufferSize;
29 final boolean delayError;
30
31 public ObservableSkipLastTimed(ObservableSource<T> source,
32 long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError) {
33 super(source);
34 this.time = time;
35 this.unit = unit;
36 this.scheduler = scheduler;
37 this.bufferSize = bufferSize;
38 this.delayError = delayError;
39 }
40
41 @Override
42 public void subscribeActual(Observer<? super T> t) {
43 source.subscribe(new SkipLastTimedObserver<>(t, time, unit, scheduler, bufferSize, delayError));
44 }
45
46 static final class SkipLastTimedObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
47
48 private static final long serialVersionUID = -5677354903406201275L;
49 final Observer<? super T> downstream;
50 final long time;
51 final TimeUnit unit;
52 final Scheduler scheduler;
53 final SpscLinkedArrayQueue<Object> queue;
54 final boolean delayError;
55
56 Disposable upstream;
57
58 volatile boolean cancelled;
59
60 volatile boolean done;
61 Throwable error;
62
63 SkipLastTimedObserver(Observer<? super T> actual, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError) {
64 this.downstream = actual;
65 this.time = time;
66 this.unit = unit;
67 this.scheduler = scheduler;
68 this.queue = new SpscLinkedArrayQueue<>(bufferSize);
69 this.delayError = delayError;
70 }
71
72 @Override
73 public void onSubscribe(Disposable d) {
74 if (DisposableHelper.validate(this.upstream, d)) {
75 this.upstream = d;
76 downstream.onSubscribe(this);
77 }
78 }
79
80 @Override
81 public void onNext(T t) {
82 final SpscLinkedArrayQueue<Object> q = queue;
83
84 long now = scheduler.now(unit);
85
86 q.offer(now, t);
87
88 drain();
89 }
90
91 @Override
92 public void onError(Throwable t) {
93 error = t;
94 done = true;
95 drain();
96 }
97
98 @Override
99 public void onComplete() {
100 done = true;
101 drain();
102 }
103
104 @Override
105 public void dispose() {
106 if (!cancelled) {
107 cancelled = true;
108 upstream.dispose();
109
110 if (getAndIncrement() == 0) {
111 queue.clear();
112 }
113 }
114 }
115
116 @Override
117 public boolean isDisposed() {
118 return cancelled;
119 }
120
121 void drain() {
122 if (getAndIncrement() != 0) {
123 return;
124 }
125
126 int missed = 1;
127
128 final Observer<? super T> a = downstream;
129 final SpscLinkedArrayQueue<Object> q = queue;
130 final boolean delayError = this.delayError;
131 final TimeUnit unit = this.unit;
132 final Scheduler scheduler = this.scheduler;
133 final long time = this.time;
134
135 for (;;) {
136
137 for (;;) {
138 if (cancelled) {
139 queue.clear();
140 return;
141 }
142
143 boolean d = done;
144
145 Long ts = (Long)q.peek();
146
147 boolean empty = ts == null;
148
149 long now = scheduler.now(unit);
150
151 if (!empty && ts > now - time) {
152 empty = true;
153 }
154
155 if (d) {
156 if (delayError) {
157 if (empty) {
158 Throwable e = error;
159 if (e != null) {
160 a.onError(e);
161 } else {
162 a.onComplete();
163 }
164 return;
165 }
166 } else {
167 Throwable e = error;
168 if (e != null) {
169 queue.clear();
170 a.onError(e);
171 return;
172 } else
173 if (empty) {
174 a.onComplete();
175 return;
176 }
177 }
178 }
179
180 if (empty) {
181 break;
182 }
183
184 q.poll();
185 @SuppressWarnings("unchecked")
186 T v = (T)q.poll();
187
188 a.onNext(v);
189 }
190
191 missed = addAndGet(-missed);
192 if (missed == 0) {
193 break;
194 }
195 }
196 }
197 }
198 }