Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableBufferBoundary.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.*;
17 import java.util.concurrent.atomic.*;
18
19 import io.reactivex.rxjava3.core.ObservableSource;
20 import io.reactivex.rxjava3.core.Observer;
21 import io.reactivex.rxjava3.disposables.*;
22 import io.reactivex.rxjava3.exceptions.Exceptions;
23 import io.reactivex.rxjava3.functions.*;
24 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
25 import io.reactivex.rxjava3.internal.util.AtomicThrowable;
26 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
27 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
28
29 public final class ObservableBufferBoundary<T, U extends Collection<? super T>, Open, Close>
30 extends AbstractObservableWithUpstream<T, U> {
31 final Supplier<U> bufferSupplier;
32 final ObservableSource<? extends Open> bufferOpen;
33 final Function<? super Open, ? extends ObservableSource<? extends Close>> bufferClose;
34
35 public ObservableBufferBoundary(ObservableSource<T> source, ObservableSource<? extends Open> bufferOpen,
36 Function<? super Open, ? extends ObservableSource<? extends Close>> bufferClose, Supplier<U> bufferSupplier) {
37 super(source);
38 this.bufferOpen = bufferOpen;
39 this.bufferClose = bufferClose;
40 this.bufferSupplier = bufferSupplier;
41 }
42
43 @Override
44 protected void subscribeActual(Observer<? super U> t) {
45 BufferBoundaryObserver<T, U, Open, Close> parent =
46 new BufferBoundaryObserver<>(
47 t, bufferOpen, bufferClose, bufferSupplier
48 );
49 t.onSubscribe(parent);
50 source.subscribe(parent);
51 }
52
53 static final class BufferBoundaryObserver<T, C extends Collection<? super T>, Open, Close>
54 extends AtomicInteger implements Observer<T>, Disposable {
55
56 private static final long serialVersionUID = -8466418554264089604L;
57
58 final Observer<? super C> downstream;
59
60 final Supplier<C> bufferSupplier;
61
62 final ObservableSource<? extends Open> bufferOpen;
63
64 final Function<? super Open, ? extends ObservableSource<? extends Close>> bufferClose;
65
66 final CompositeDisposable observers;
67
68 final AtomicReference<Disposable> upstream;
69
70 final AtomicThrowable errors;
71
72 volatile boolean done;
73
74 final SpscLinkedArrayQueue<C> queue;
75
76 volatile boolean cancelled;
77
78 long index;
79
80 Map<Long, C> buffers;
81
82 BufferBoundaryObserver(Observer<? super C> actual,
83 ObservableSource<? extends Open> bufferOpen,
84 Function<? super Open, ? extends ObservableSource<? extends Close>> bufferClose,
85 Supplier<C> bufferSupplier
86 ) {
87 this.downstream = actual;
88 this.bufferSupplier = bufferSupplier;
89 this.bufferOpen = bufferOpen;
90 this.bufferClose = bufferClose;
91 this.queue = new SpscLinkedArrayQueue<>(bufferSize());
92 this.observers = new CompositeDisposable();
93 this.upstream = new AtomicReference<>();
94 this.buffers = new LinkedHashMap<>();
95 this.errors = new AtomicThrowable();
96 }
97
98 @Override
99 public void onSubscribe(Disposable d) {
100 if (DisposableHelper.setOnce(this.upstream, d)) {
101
102 BufferOpenObserver<Open> open = new BufferOpenObserver<>(this);
103 observers.add(open);
104
105 bufferOpen.subscribe(open);
106 }
107 }
108
109 @Override
110 public void onNext(T t) {
111 synchronized (this) {
112 Map<Long, C> bufs = buffers;
113 if (bufs == null) {
114 return;
115 }
116 for (C b : bufs.values()) {
117 b.add(t);
118 }
119 }
120 }
121
122 @Override
123 public void onError(Throwable t) {
124 if (errors.tryAddThrowableOrReport(t)) {
125 observers.dispose();
126 synchronized (this) {
127 buffers = null;
128 }
129 done = true;
130 drain();
131 }
132 }
133
134 @Override
135 public void onComplete() {
136 observers.dispose();
137 synchronized (this) {
138 Map<Long, C> bufs = buffers;
139 if (bufs == null) {
140 return;
141 }
142 for (C b : bufs.values()) {
143 queue.offer(b);
144 }
145 buffers = null;
146 }
147 done = true;
148 drain();
149 }
150
151 @Override
152 public void dispose() {
153 if (DisposableHelper.dispose(upstream)) {
154 cancelled = true;
155 observers.dispose();
156 synchronized (this) {
157 buffers = null;
158 }
159 if (getAndIncrement() != 0) {
160 queue.clear();
161 }
162 }
163 }
164
165 @Override
166 public boolean isDisposed() {
167 return DisposableHelper.isDisposed(upstream.get());
168 }
169
170 void open(Open token) {
171 ObservableSource<? extends Close> p;
172 C buf;
173 try {
174 buf = Objects.requireNonNull(bufferSupplier.get(), "The bufferSupplier returned a null Collection");
175 p = Objects.requireNonNull(bufferClose.apply(token), "The bufferClose returned a null ObservableSource");
176 } catch (Throwable ex) {
177 Exceptions.throwIfFatal(ex);
178 DisposableHelper.dispose(upstream);
179 onError(ex);
180 return;
181 }
182
183 long idx = index;
184 index = idx + 1;
185 synchronized (this) {
186 Map<Long, C> bufs = buffers;
187 if (bufs == null) {
188 return;
189 }
190 bufs.put(idx, buf);
191 }
192
193 BufferCloseObserver<T, C> bc = new BufferCloseObserver<>(this, idx);
194 observers.add(bc);
195 p.subscribe(bc);
196 }
197
198 void openComplete(BufferOpenObserver<Open> os) {
199 observers.delete(os);
200 if (observers.size() == 0) {
201 DisposableHelper.dispose(upstream);
202 done = true;
203 drain();
204 }
205 }
206
207 void close(BufferCloseObserver<T, C> closer, long idx) {
208 observers.delete(closer);
209 boolean makeDone = false;
210 if (observers.size() == 0) {
211 makeDone = true;
212 DisposableHelper.dispose(upstream);
213 }
214 synchronized (this) {
215 Map<Long, C> bufs = buffers;
216 if (bufs == null) {
217 return;
218 }
219 queue.offer(buffers.remove(idx));
220 }
221 if (makeDone) {
222 done = true;
223 }
224 drain();
225 }
226
227 void boundaryError(Disposable observer, Throwable ex) {
228 DisposableHelper.dispose(upstream);
229 observers.delete(observer);
230 onError(ex);
231 }
232
233 void drain() {
234 if (getAndIncrement() != 0) {
235 return;
236 }
237
238 int missed = 1;
239 Observer<? super C> a = downstream;
240 SpscLinkedArrayQueue<C> q = queue;
241
242 for (;;) {
243 for (;;) {
244 if (cancelled) {
245 q.clear();
246 return;
247 }
248
249 boolean d = done;
250 if (d && errors.get() != null) {
251 q.clear();
252 errors.tryTerminateConsumer(a);
253 return;
254 }
255
256 C v = q.poll();
257 boolean empty = v == null;
258
259 if (d && empty) {
260 a.onComplete();
261 return;
262 }
263
264 if (empty) {
265 break;
266 }
267
268 a.onNext(v);
269 }
270
271 missed = addAndGet(-missed);
272 if (missed == 0) {
273 break;
274 }
275 }
276 }
277
278 static final class BufferOpenObserver<Open>
279 extends AtomicReference<Disposable>
280 implements Observer<Open>, Disposable {
281
282 private static final long serialVersionUID = -8498650778633225126L;
283
284 final BufferBoundaryObserver<?, ?, Open, ?> parent;
285
286 BufferOpenObserver(BufferBoundaryObserver<?, ?, Open, ?> parent) {
287 this.parent = parent;
288 }
289
290 @Override
291 public void onSubscribe(Disposable d) {
292 DisposableHelper.setOnce(this, d);
293 }
294
295 @Override
296 public void onNext(Open t) {
297 parent.open(t);
298 }
299
300 @Override
301 public void onError(Throwable t) {
302 lazySet(DisposableHelper.DISPOSED);
303 parent.boundaryError(this, t);
304 }
305
306 @Override
307 public void onComplete() {
308 lazySet(DisposableHelper.DISPOSED);
309 parent.openComplete(this);
310 }
311
312 @Override
313 public void dispose() {
314 DisposableHelper.dispose(this);
315 }
316
317 @Override
318 public boolean isDisposed() {
319 return get() == DisposableHelper.DISPOSED;
320 }
321 }
322 }
323
324 static final class BufferCloseObserver<T, C extends Collection<? super T>>
325 extends AtomicReference<Disposable>
326 implements Observer<Object>, Disposable {
327
328 private static final long serialVersionUID = -8498650778633225126L;
329
330 final BufferBoundaryObserver<T, C, ?, ?> parent;
331
332 final long index;
333
334 BufferCloseObserver(BufferBoundaryObserver<T, C, ?, ?> parent, long index) {
335 this.parent = parent;
336 this.index = index;
337 }
338
339 @Override
340 public void onSubscribe(Disposable d) {
341 DisposableHelper.setOnce(this, d);
342 }
343
344 @Override
345 public void onNext(Object t) {
346 Disposable upstream = get();
347 if (upstream != DisposableHelper.DISPOSED) {
348 lazySet(DisposableHelper.DISPOSED);
349 upstream.dispose();
350 parent.close(this, index);
351 }
352 }
353
354 @Override
355 public void onError(Throwable t) {
356 if (get() != DisposableHelper.DISPOSED) {
357 lazySet(DisposableHelper.DISPOSED);
358 parent.boundaryError(this, t);
359 } else {
360 RxJavaPlugins.onError(t);
361 }
362 }
363
364 @Override
365 public void onComplete() {
366 if (get() != DisposableHelper.DISPOSED) {
367 lazySet(DisposableHelper.DISPOSED);
368 parent.close(this, index);
369 }
370 }
371
372 @Override
373 public void dispose() {
374 DisposableHelper.dispose(this);
375 }
376
377 @Override
378 public boolean isDisposed() {
379 return get() == DisposableHelper.DISPOSED;
380 }
381 }
382 }