Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableCombineLatest.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.Objects;
17 import java.util.concurrent.atomic.*;
18
19 import io.reactivex.rxjava3.core.*;
20 import io.reactivex.rxjava3.disposables.Disposable;
21 import io.reactivex.rxjava3.exceptions.Exceptions;
22 import io.reactivex.rxjava3.functions.Function;
23 import io.reactivex.rxjava3.internal.disposables.*;
24 import io.reactivex.rxjava3.internal.util.AtomicThrowable;
25 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
26
27 public final class ObservableCombineLatest<T, R> extends Observable<R> {
28 final ObservableSource<? extends T>[] sources;
29 final Iterable<? extends ObservableSource<? extends T>> sourcesIterable;
30 final Function<? super Object[], ? extends R> combiner;
31 final int bufferSize;
32 final boolean delayError;
33
34 public ObservableCombineLatest(ObservableSource<? extends T>[] sources,
35 Iterable<? extends ObservableSource<? extends T>> sourcesIterable,
36 Function<? super Object[], ? extends R> combiner, int bufferSize,
37 boolean delayError) {
38 this.sources = sources;
39 this.sourcesIterable = sourcesIterable;
40 this.combiner = combiner;
41 this.bufferSize = bufferSize;
42 this.delayError = delayError;
43 }
44
45 @Override
46 @SuppressWarnings("unchecked")
47 public void subscribeActual(Observer<? super R> observer) {
48 ObservableSource<? extends T>[] sources = this.sources;
49 int count = 0;
50 if (sources == null) {
51 sources = new ObservableSource[8];
52 try {
53 for (ObservableSource<? extends T> p : sourcesIterable) {
54 if (count == sources.length) {
55 ObservableSource<? extends T>[] b = new ObservableSource[count + (count >> 2)];
56 System.arraycopy(sources, 0, b, 0, count);
57 sources = b;
58 }
59 sources[count++] = Objects.requireNonNull(p, "The Iterator returned a null ObservableSource");
60 }
61 } catch (Throwable ex) {
62 Exceptions.throwIfFatal(ex);
63 EmptyDisposable.error(ex, observer);
64 return;
65 }
66 } else {
67 count = sources.length;
68 }
69
70 if (count == 0) {
71 EmptyDisposable.complete(observer);
72 return;
73 }
74
75 LatestCoordinator<T, R> lc = new LatestCoordinator<>(observer, combiner, count, bufferSize, delayError);
76 lc.subscribe(sources);
77 }
78
79 static final class LatestCoordinator<T, R> extends AtomicInteger implements Disposable {
80
81 private static final long serialVersionUID = 8567835998786448817L;
82 final Observer<? super R> downstream;
83 final Function<? super Object[], ? extends R> combiner;
84 final CombinerObserver<T, R>[] observers;
85 Object[] latest;
86 final SpscLinkedArrayQueue<Object[]> queue;
87 final boolean delayError;
88
89 volatile boolean cancelled;
90
91 volatile boolean done;
92
93 final AtomicThrowable errors = new AtomicThrowable();
94
95 int active;
96 int complete;
97
98 @SuppressWarnings("unchecked")
99 LatestCoordinator(Observer<? super R> actual,
100 Function<? super Object[], ? extends R> combiner,
101 int count, int bufferSize, boolean delayError) {
102 this.downstream = actual;
103 this.combiner = combiner;
104 this.delayError = delayError;
105 this.latest = new Object[count];
106 CombinerObserver<T, R>[] as = new CombinerObserver[count];
107 for (int i = 0; i < count; i++) {
108 as[i] = new CombinerObserver<>(this, i);
109 }
110 this.observers = as;
111 this.queue = new SpscLinkedArrayQueue<>(bufferSize);
112 }
113
114 public void subscribe(ObservableSource<? extends T>[] sources) {
115 Observer<T>[] as = observers;
116 int len = as.length;
117 downstream.onSubscribe(this);
118 for (int i = 0; i < len; i++) {
119 if (done || cancelled) {
120 return;
121 }
122 sources[i].subscribe(as[i]);
123 }
124 }
125
126 @Override
127 public void dispose() {
128 if (!cancelled) {
129 cancelled = true;
130 cancelSources();
131 drain();
132 }
133 }
134
135 @Override
136 public boolean isDisposed() {
137 return cancelled;
138 }
139
140 void cancelSources() {
141 for (CombinerObserver<T, R> observer : observers) {
142 observer.dispose();
143 }
144 }
145
146 void clear(SpscLinkedArrayQueue<?> q) {
147 synchronized (this) {
148 latest = null;
149 }
150 q.clear();
151 }
152
153 void drain() {
154 if (getAndIncrement() != 0) {
155 return;
156 }
157
158 final SpscLinkedArrayQueue<Object[]> q = queue;
159 final Observer<? super R> a = downstream;
160 final boolean delayError = this.delayError;
161
162 int missed = 1;
163 for (;;) {
164
165 for (;;) {
166 if (cancelled) {
167 clear(q);
168 errors.tryTerminateAndReport();
169 return;
170 }
171
172 if (!delayError && errors.get() != null) {
173 cancelSources();
174 clear(q);
175 errors.tryTerminateConsumer(a);
176 return;
177 }
178
179 boolean d = done;
180 Object[] s = q.poll();
181 boolean empty = s == null;
182
183 if (d && empty) {
184 clear(q);
185 errors.tryTerminateConsumer(a);
186 return;
187 }
188
189 if (empty) {
190 break;
191 }
192
193 R v;
194
195 try {
196 v = Objects.requireNonNull(combiner.apply(s), "The combiner returned a null value");
197 } catch (Throwable ex) {
198 Exceptions.throwIfFatal(ex);
199 errors.tryAddThrowableOrReport(ex);
200 cancelSources();
201 clear(q);
202 errors.tryTerminateConsumer(a);
203 return;
204 }
205
206 a.onNext(v);
207 }
208
209 missed = addAndGet(-missed);
210 if (missed == 0) {
211 break;
212 }
213 }
214 }
215
216 void innerNext(int index, T item) {
217 boolean shouldDrain = false;
218 synchronized (this) {
219 Object[] latest = this.latest;
220 if (latest == null) {
221 return;
222 }
223 Object o = latest[index];
224 int a = active;
225 if (o == null) {
226 active = ++a;
227 }
228 latest[index] = item;
229 if (a == latest.length) {
230 queue.offer(latest.clone());
231 shouldDrain = true;
232 }
233 }
234 if (shouldDrain) {
235 drain();
236 }
237 }
238
239 void innerError(int index, Throwable ex) {
240 if (errors.tryAddThrowableOrReport(ex)) {
241 boolean cancelOthers = true;
242 if (delayError) {
243 synchronized (this) {
244 Object[] latest = this.latest;
245 if (latest == null) {
246 return;
247 }
248 cancelOthers = latest[index] == null;
249 if (cancelOthers || ++complete == latest.length) {
250 done = true;
251 }
252 }
253 }
254 if (cancelOthers) {
255 cancelSources();
256 }
257 drain();
258 }
259 }
260
261 void innerComplete(int index) {
262 boolean cancelOthers = false;
263 synchronized (this) {
264 Object[] latest = this.latest;
265 if (latest == null) {
266 return;
267 }
268
269 cancelOthers = latest[index] == null;
270 if (cancelOthers || ++complete == latest.length) {
271 done = true;
272 }
273 }
274 if (cancelOthers) {
275 cancelSources();
276 }
277 drain();
278 }
279
280 }
281
282 static final class CombinerObserver<T, R> extends AtomicReference<Disposable> implements Observer<T> {
283 private static final long serialVersionUID = -4823716997131257941L;
284
285 final LatestCoordinator<T, R> parent;
286
287 final int index;
288
289 CombinerObserver(LatestCoordinator<T, R> parent, int index) {
290 this.parent = parent;
291 this.index = index;
292 }
293
294 @Override
295 public void onSubscribe(Disposable d) {
296 DisposableHelper.setOnce(this, d);
297 }
298
299 @Override
300 public void onNext(T t) {
301 parent.innerNext(index, t);
302 }
303
304 @Override
305 public void onError(Throwable t) {
306 parent.innerError(index, t);
307 }
308
309 @Override
310 public void onComplete() {
311 parent.innerComplete(index);
312 }
313
314 public void dispose() {
315 DisposableHelper.dispose(this);
316 }
317 }
318 }