Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableObserveOn.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 io.reactivex.rxjava3.annotations.Nullable;
17 import io.reactivex.rxjava3.core.*;
18 import io.reactivex.rxjava3.disposables.Disposable;
19 import io.reactivex.rxjava3.exceptions.Exceptions;
20 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
21 import io.reactivex.rxjava3.internal.observers.BasicIntQueueDisposable;
22 import io.reactivex.rxjava3.internal.schedulers.TrampolineScheduler;
23 import io.reactivex.rxjava3.operators.QueueDisposable;
24 import io.reactivex.rxjava3.operators.SimpleQueue;
25 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
26 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
27
28 public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
29 final Scheduler scheduler;
30 final boolean delayError;
31 final int bufferSize;
32 public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
33 super(source);
34 this.scheduler = scheduler;
35 this.delayError = delayError;
36 this.bufferSize = bufferSize;
37 }
38
39 @Override
40 protected void subscribeActual(Observer<? super T> observer) {
41 if (scheduler instanceof TrampolineScheduler) {
42 source.subscribe(observer);
43 } else {
44 Scheduler.Worker w = scheduler.createWorker();
45
46 source.subscribe(new ObserveOnObserver<>(observer, w, delayError, bufferSize));
47 }
48 }
49
50 static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
51 implements Observer<T>, Runnable {
52
53 private static final long serialVersionUID = 6576896619930983584L;
54 final Observer<? super T> downstream;
55 final Scheduler.Worker worker;
56 final boolean delayError;
57 final int bufferSize;
58
59 SimpleQueue<T> queue;
60
61 Disposable upstream;
62
63 Throwable error;
64 volatile boolean done;
65
66 volatile boolean disposed;
67
68 int sourceMode;
69
70 boolean outputFused;
71
72 ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
73 this.downstream = actual;
74 this.worker = worker;
75 this.delayError = delayError;
76 this.bufferSize = bufferSize;
77 }
78
79 @Override
80 public void onSubscribe(Disposable d) {
81 if (DisposableHelper.validate(this.upstream, d)) {
82 this.upstream = d;
83 if (d instanceof QueueDisposable) {
84 @SuppressWarnings("unchecked")
85 QueueDisposable<T> qd = (QueueDisposable<T>) d;
86
87 int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);
88
89 if (m == QueueDisposable.SYNC) {
90 sourceMode = m;
91 queue = qd;
92 done = true;
93 downstream.onSubscribe(this);
94 schedule();
95 return;
96 }
97 if (m == QueueDisposable.ASYNC) {
98 sourceMode = m;
99 queue = qd;
100 downstream.onSubscribe(this);
101 return;
102 }
103 }
104
105 queue = new SpscLinkedArrayQueue<>(bufferSize);
106
107 downstream.onSubscribe(this);
108 }
109 }
110
111 @Override
112 public void onNext(T t) {
113 if (done) {
114 return;
115 }
116
117 if (sourceMode != QueueDisposable.ASYNC) {
118 queue.offer(t);
119 }
120 schedule();
121 }
122
123 @Override
124 public void onError(Throwable t) {
125 if (done) {
126 RxJavaPlugins.onError(t);
127 return;
128 }
129 error = t;
130 done = true;
131 schedule();
132 }
133
134 @Override
135 public void onComplete() {
136 if (done) {
137 return;
138 }
139 done = true;
140 schedule();
141 }
142
143 @Override
144 public void dispose() {
145 if (!disposed) {
146 disposed = true;
147 upstream.dispose();
148 worker.dispose();
149 if (!outputFused && getAndIncrement() == 0) {
150 queue.clear();
151 }
152 }
153 }
154
155 @Override
156 public boolean isDisposed() {
157 return disposed;
158 }
159
160 void schedule() {
161 if (getAndIncrement() == 0) {
162 worker.schedule(this);
163 }
164 }
165
166 void drainNormal() {
167 int missed = 1;
168
169 final SimpleQueue<T> q = queue;
170 final Observer<? super T> a = downstream;
171
172 for (;;) {
173 if (checkTerminated(done, q.isEmpty(), a)) {
174 return;
175 }
176
177 for (;;) {
178 boolean d = done;
179 T v;
180
181 try {
182 v = q.poll();
183 } catch (Throwable ex) {
184 Exceptions.throwIfFatal(ex);
185 disposed = true;
186 upstream.dispose();
187 q.clear();
188 a.onError(ex);
189 worker.dispose();
190 return;
191 }
192 boolean empty = v == null;
193
194 if (checkTerminated(d, empty, a)) {
195 return;
196 }
197
198 if (empty) {
199 break;
200 }
201
202 a.onNext(v);
203 }
204
205 missed = addAndGet(-missed);
206 if (missed == 0) {
207 break;
208 }
209 }
210 }
211
212 void drainFused() {
213 int missed = 1;
214
215 for (;;) {
216 if (disposed) {
217 return;
218 }
219
220 boolean d = done;
221 Throwable ex = error;
222
223 if (!delayError && d && ex != null) {
224 disposed = true;
225 downstream.onError(error);
226 worker.dispose();
227 return;
228 }
229
230 downstream.onNext(null);
231
232 if (d) {
233 disposed = true;
234 ex = error;
235 if (ex != null) {
236 downstream.onError(ex);
237 } else {
238 downstream.onComplete();
239 }
240 worker.dispose();
241 return;
242 }
243
244 missed = addAndGet(-missed);
245 if (missed == 0) {
246 break;
247 }
248 }
249 }
250
251 @Override
252 public void run() {
253 if (outputFused) {
254 drainFused();
255 } else {
256 drainNormal();
257 }
258 }
259
260 boolean checkTerminated(boolean d, boolean empty, Observer<? super T> a) {
261 if (disposed) {
262 queue.clear();
263 return true;
264 }
265 if (d) {
266 Throwable e = error;
267 if (delayError) {
268 if (empty) {
269 disposed = true;
270 if (e != null) {
271 a.onError(e);
272 } else {
273 a.onComplete();
274 }
275 worker.dispose();
276 return true;
277 }
278 } else {
279 if (e != null) {
280 disposed = true;
281 queue.clear();
282 a.onError(e);
283 worker.dispose();
284 return true;
285 } else
286 if (empty) {
287 disposed = true;
288 a.onComplete();
289 worker.dispose();
290 return true;
291 }
292 }
293 }
294 return false;
295 }
296
297 @Override
298 public int requestFusion(int mode) {
299 if ((mode & ASYNC) != 0) {
300 outputFused = true;
301 return ASYNC;
302 }
303 return NONE;
304 }
305
306 @Nullable
307 @Override
308 public T poll() throws Throwable {
309 return queue.poll();
310 }
311
312 @Override
313 public void clear() {
314 queue.clear();
315 }
316
317 @Override
318 public boolean isEmpty() {
319 return queue.isEmpty();
320 }
321 }
322 }