Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableGroupBy.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.ConcurrentHashMap;
18 import java.util.concurrent.atomic.*;
19
20 import io.reactivex.rxjava3.core.ObservableSource;
21 import io.reactivex.rxjava3.core.Observer;
22 import io.reactivex.rxjava3.disposables.Disposable;
23 import io.reactivex.rxjava3.exceptions.Exceptions;
24 import io.reactivex.rxjava3.functions.Function;
25 import io.reactivex.rxjava3.internal.disposables.*;
26 import io.reactivex.rxjava3.observables.GroupedObservable;
27 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
28
29 public final class ObservableGroupBy<T, K, V> extends AbstractObservableWithUpstream<T, GroupedObservable<K, V>> {
30 final Function<? super T, ? extends K> keySelector;
31 final Function<? super T, ? extends V> valueSelector;
32 final int bufferSize;
33 final boolean delayError;
34
35 public ObservableGroupBy(ObservableSource<T> source,
36 Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector,
37 int bufferSize, boolean delayError) {
38 super(source);
39 this.keySelector = keySelector;
40 this.valueSelector = valueSelector;
41 this.bufferSize = bufferSize;
42 this.delayError = delayError;
43 }
44
45 @Override
46 public void subscribeActual(Observer<? super GroupedObservable<K, V>> t) {
47 source.subscribe(new GroupByObserver<>(t, keySelector, valueSelector, bufferSize, delayError));
48 }
49
50 public static final class GroupByObserver<T, K, V> extends AtomicInteger implements Observer<T>, Disposable {
51
52 private static final long serialVersionUID = -3688291656102519502L;
53
54 final Observer<? super GroupedObservable<K, V>> downstream;
55 final Function<? super T, ? extends K> keySelector;
56 final Function<? super T, ? extends V> valueSelector;
57 final int bufferSize;
58 final boolean delayError;
59 final Map<Object, GroupedUnicast<K, V>> groups;
60
61 static final Object NULL_KEY = new Object();
62
63 Disposable upstream;
64
65 final AtomicBoolean cancelled = new AtomicBoolean();
66
67 public GroupByObserver(Observer<? super GroupedObservable<K, V>> actual, Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError) {
68 this.downstream = actual;
69 this.keySelector = keySelector;
70 this.valueSelector = valueSelector;
71 this.bufferSize = bufferSize;
72 this.delayError = delayError;
73 this.groups = new ConcurrentHashMap<>();
74 this.lazySet(1);
75 }
76
77 @Override
78 public void onSubscribe(Disposable d) {
79 if (DisposableHelper.validate(this.upstream, d)) {
80 this.upstream = d;
81 downstream.onSubscribe(this);
82 }
83 }
84
85 @Override
86 public void onNext(T t) {
87 K key;
88 try {
89 key = keySelector.apply(t);
90 } catch (Throwable e) {
91 Exceptions.throwIfFatal(e);
92 upstream.dispose();
93 onError(e);
94 return;
95 }
96
97 Object mapKey = key != null ? key : NULL_KEY;
98 GroupedUnicast<K, V> group = groups.get(mapKey);
99 boolean newGroup = false;
100 if (group == null) {
101 // if the main has been cancelled, stop creating groups
102 // and skip this value
103 if (cancelled.get()) {
104 return;
105 }
106
107 group = GroupedUnicast.createWith(key, bufferSize, this, delayError);
108 groups.put(mapKey, group);
109
110 getAndIncrement();
111
112 newGroup = true;
113 }
114
115 V v;
116 try {
117 v = Objects.requireNonNull(valueSelector.apply(t), "The value supplied is null");
118 } catch (Throwable e) {
119 Exceptions.throwIfFatal(e);
120 upstream.dispose();
121 if (newGroup) {
122 downstream.onNext(group);
123 }
124 onError(e);
125 return;
126 }
127
128 group.onNext(v);
129
130 if (newGroup) {
131 downstream.onNext(group);
132
133 if (group.state.tryAbandon()) {
134 cancel(key);
135 group.onComplete();
136 }
137 }
138 }
139
140 @Override
141 public void onError(Throwable t) {
142 List<GroupedUnicast<K, V>> list = new ArrayList<>(groups.values());
143 groups.clear();
144
145 for (GroupedUnicast<K, V> e : list) {
146 e.onError(t);
147 }
148
149 downstream.onError(t);
150 }
151
152 @Override
153 public void onComplete() {
154 List<GroupedUnicast<K, V>> list = new ArrayList<>(groups.values());
155 groups.clear();
156
157 for (GroupedUnicast<K, V> e : list) {
158 e.onComplete();
159 }
160
161 downstream.onComplete();
162 }
163
164 @Override
165 public void dispose() {
166 // canceling the main source means we don't want any more groups
167 // but running groups still require new values
168 if (cancelled.compareAndSet(false, true)) {
169 if (decrementAndGet() == 0) {
170 upstream.dispose();
171 }
172 }
173 }
174
175 @Override
176 public boolean isDisposed() {
177 return cancelled.get();
178 }
179
180 public void cancel(K key) {
181 Object mapKey = key != null ? key : NULL_KEY;
182 groups.remove(mapKey);
183 if (decrementAndGet() == 0) {
184 upstream.dispose();
185 }
186 }
187 }
188
189 static final class GroupedUnicast<K, T> extends GroupedObservable<K, T> {
190
191 final State<T, K> state;
192
193 public static <T, K> GroupedUnicast<K, T> createWith(K key, int bufferSize, GroupByObserver<?, K, T> parent, boolean delayError) {
194 State<T, K> state = new State<>(bufferSize, parent, key, delayError);
195 return new GroupedUnicast<>(key, state);
196 }
197
198 protected GroupedUnicast(K key, State<T, K> state) {
199 super(key);
200 this.state = state;
201 }
202
203 @Override
204 protected void subscribeActual(Observer<? super T> observer) {
205 state.subscribe(observer);
206 }
207
208 public void onNext(T t) {
209 state.onNext(t);
210 }
211
212 public void onError(Throwable e) {
213 state.onError(e);
214 }
215
216 public void onComplete() {
217 state.onComplete();
218 }
219 }
220
221 static final class State<T, K> extends AtomicInteger implements Disposable, ObservableSource<T> {
222
223 private static final long serialVersionUID = -3852313036005250360L;
224
225 final K key;
226 final SpscLinkedArrayQueue<T> queue;
227 final GroupByObserver<?, K, T> parent;
228 final boolean delayError;
229
230 volatile boolean done;
231 Throwable error;
232
233 final AtomicBoolean cancelled = new AtomicBoolean();
234
235 final AtomicReference<Observer<? super T>> actual = new AtomicReference<>();
236
237 final AtomicInteger once = new AtomicInteger();
238
239 static final int FRESH = 0;
240 static final int HAS_SUBSCRIBER = 1;
241 static final int ABANDONED = 2;
242 static final int ABANDONED_HAS_SUBSCRIBER = ABANDONED | HAS_SUBSCRIBER;
243
244 State(int bufferSize, GroupByObserver<?, K, T> parent, K key, boolean delayError) {
245 this.queue = new SpscLinkedArrayQueue<>(bufferSize);
246 this.parent = parent;
247 this.key = key;
248 this.delayError = delayError;
249 }
250
251 @Override
252 public void dispose() {
253 if (cancelled.compareAndSet(false, true)) {
254 if (getAndIncrement() == 0) {
255 actual.lazySet(null);
256 cancelParent();
257 }
258 }
259 }
260
261 @Override
262 public boolean isDisposed() {
263 return cancelled.get();
264 }
265
266 @Override
267 public void subscribe(Observer<? super T> observer) {
268 for (;;) {
269 int s = once.get();
270 if ((s & HAS_SUBSCRIBER) != 0) {
271 break;
272 }
273 int u = s | HAS_SUBSCRIBER;
274 if (once.compareAndSet(s, u)) {
275 observer.onSubscribe(this);
276 actual.lazySet(observer);
277 if (cancelled.get()) {
278 actual.lazySet(null);
279 } else {
280 drain();
281 }
282 return;
283 }
284 }
285 EmptyDisposable.error(new IllegalStateException("Only one Observer allowed!"), observer);
286 }
287
288 public void onNext(T t) {
289 queue.offer(t);
290 drain();
291 }
292
293 public void onError(Throwable e) {
294 error = e;
295 done = true;
296 drain();
297 }
298
299 public void onComplete() {
300 done = true;
301 drain();
302 }
303
304 void drain() {
305 if (getAndIncrement() != 0) {
306 return;
307 }
308 int missed = 1;
309
310 final SpscLinkedArrayQueue<T> q = queue;
311 final boolean delayError = this.delayError;
312 Observer<? super T> a = actual.get();
313 for (;;) {
314 if (a != null) {
315 for (;;) {
316 boolean d = done;
317 T v = q.poll();
318 boolean empty = v == null;
319
320 if (checkTerminated(d, empty, a, delayError)) {
321 return;
322 }
323
324 if (empty) {
325 break;
326 }
327
328 a.onNext(v);
329 }
330 }
331
332 missed = addAndGet(-missed);
333 if (missed == 0) {
334 break;
335 }
336 if (a == null) {
337 a = actual.get();
338 }
339 }
340 }
341
342 void cancelParent() {
343 if ((once.get() & ABANDONED) == 0) {
344 parent.cancel(key);
345 }
346 }
347
348 boolean tryAbandon() {
349 return once.get() == FRESH && once.compareAndSet(FRESH, ABANDONED);
350 }
351
352 boolean checkTerminated(boolean d, boolean empty, Observer<? super T> a, boolean delayError) {
353 if (cancelled.get()) {
354 queue.clear();
355 actual.lazySet(null);
356 cancelParent();
357 return true;
358 }
359
360 if (d) {
361 if (delayError) {
362 if (empty) {
363 Throwable e = error;
364 actual.lazySet(null);
365 if (e != null) {
366 a.onError(e);
367 } else {
368 a.onComplete();
369 }
370 return true;
371 }
372 } else {
373 Throwable e = error;
374 if (e != null) {
375 queue.clear();
376 actual.lazySet(null);
377 a.onError(e);
378 return true;
379 } else
380 if (empty) {
381 actual.lazySet(null);
382 a.onComplete();
383 return true;
384 }
385 }
386 }
387
388 return false;
389 }
390 }
391 }