Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapMaybe.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.*;
21 import io.reactivex.rxjava3.exceptions.Exceptions;
22 import io.reactivex.rxjava3.functions.Function;
23 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
24 import io.reactivex.rxjava3.internal.util.AtomicThrowable;
25 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
26
27 /**
28 * Maps upstream values into MaybeSources and merges their signals into one sequence.
29 * @param <T> the source value type
30 * @param <R> the result value type
31 */
32 public final class ObservableFlatMapMaybe<T, R> extends AbstractObservableWithUpstream<T, R> {
33
34 final Function<? super T, ? extends MaybeSource<? extends R>> mapper;
35
36 final boolean delayErrors;
37
38 public ObservableFlatMapMaybe(ObservableSource<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper,
39 boolean delayError) {
40 super(source);
41 this.mapper = mapper;
42 this.delayErrors = delayError;
43 }
44
45 @Override
46 protected void subscribeActual(Observer<? super R> observer) {
47 source.subscribe(new FlatMapMaybeObserver<>(observer, mapper, delayErrors));
48 }
49
50 static final class FlatMapMaybeObserver<T, R>
51 extends AtomicInteger
52 implements Observer<T>, Disposable {
53
54 private static final long serialVersionUID = 8600231336733376951L;
55
56 final Observer<? super R> downstream;
57
58 final boolean delayErrors;
59
60 final CompositeDisposable set;
61
62 final AtomicInteger active;
63
64 final AtomicThrowable errors;
65
66 final Function<? super T, ? extends MaybeSource<? extends R>> mapper;
67
68 final AtomicReference<SpscLinkedArrayQueue<R>> queue;
69
70 Disposable upstream;
71
72 volatile boolean cancelled;
73
74 FlatMapMaybeObserver(Observer<? super R> actual,
75 Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors) {
76 this.downstream = actual;
77 this.mapper = mapper;
78 this.delayErrors = delayErrors;
79 this.set = new CompositeDisposable();
80 this.errors = new AtomicThrowable();
81 this.active = new AtomicInteger(1);
82 this.queue = new AtomicReference<>();
83 }
84
85 @Override
86 public void onSubscribe(Disposable d) {
87 if (DisposableHelper.validate(this.upstream, d)) {
88 this.upstream = d;
89
90 downstream.onSubscribe(this);
91 }
92 }
93
94 @Override
95 public void onNext(T t) {
96 MaybeSource<? extends R> ms;
97
98 try {
99 ms = Objects.requireNonNull(mapper.apply(t), "The mapper returned a null MaybeSource");
100 } catch (Throwable ex) {
101 Exceptions.throwIfFatal(ex);
102 upstream.dispose();
103 onError(ex);
104 return;
105 }
106
107 active.getAndIncrement();
108
109 InnerObserver inner = new InnerObserver();
110
111 if (!cancelled && set.add(inner)) {
112 ms.subscribe(inner);
113 }
114 }
115
116 @Override
117 public void onError(Throwable t) {
118 active.decrementAndGet();
119 if (errors.tryAddThrowableOrReport(t)) {
120 if (!delayErrors) {
121 set.dispose();
122 }
123 drain();
124 }
125 }
126
127 @Override
128 public void onComplete() {
129 active.decrementAndGet();
130 drain();
131 }
132
133 @Override
134 public void dispose() {
135 cancelled = true;
136 upstream.dispose();
137 set.dispose();
138 errors.tryTerminateAndReport();
139 }
140
141 @Override
142 public boolean isDisposed() {
143 return cancelled;
144 }
145
146 void innerSuccess(InnerObserver inner, R value) {
147 set.delete(inner);
148 if (get() == 0 && compareAndSet(0, 1)) {
149 downstream.onNext(value);
150
151 boolean d = active.decrementAndGet() == 0;
152 SpscLinkedArrayQueue<R> q = queue.get();
153
154 if (d && (q == null || q.isEmpty())) {
155 errors.tryTerminateConsumer(downstream);
156 return;
157 }
158 if (decrementAndGet() == 0) {
159 return;
160 }
161 } else {
162 SpscLinkedArrayQueue<R> q = getOrCreateQueue();
163 synchronized (q) {
164 q.offer(value);
165 }
166 active.decrementAndGet();
167 if (getAndIncrement() != 0) {
168 return;
169 }
170 }
171 drainLoop();
172 }
173
174 SpscLinkedArrayQueue<R> getOrCreateQueue() {
175 SpscLinkedArrayQueue<R> current = queue.get();
176 if (current != null) {
177 return current;
178 }
179 current = new SpscLinkedArrayQueue<>(Observable.bufferSize());
180 if (queue.compareAndSet(null, current)) {
181 return current;
182 }
183 return queue.get();
184 }
185
186 void innerError(InnerObserver inner, Throwable e) {
187 set.delete(inner);
188 if (errors.tryAddThrowableOrReport(e)) {
189 if (!delayErrors) {
190 upstream.dispose();
191 set.dispose();
192 }
193 active.decrementAndGet();
194 drain();
195 }
196 }
197
198 void innerComplete(InnerObserver inner) {
199 set.delete(inner);
200
201 if (get() == 0 && compareAndSet(0, 1)) {
202 boolean d = active.decrementAndGet() == 0;
203 SpscLinkedArrayQueue<R> q = queue.get();
204
205 if (d && (q == null || q.isEmpty())) {
206 errors.tryTerminateConsumer(downstream);
207 return;
208 }
209 if (decrementAndGet() == 0) {
210 return;
211 }
212 drainLoop();
213 } else {
214 active.decrementAndGet();
215 drain();
216 }
217 }
218
219 void drain() {
220 if (getAndIncrement() == 0) {
221 drainLoop();
222 }
223 }
224
225 void clear() {
226 SpscLinkedArrayQueue<R> q = queue.get();
227 if (q != null) {
228 q.clear();
229 }
230 }
231
232 void drainLoop() {
233 int missed = 1;
234 Observer<? super R> a = downstream;
235 AtomicInteger n = active;
236 AtomicReference<SpscLinkedArrayQueue<R>> qr = queue;
237
238 for (;;) {
239 for (;;) {
240 if (cancelled) {
241 clear();
242 return;
243 }
244
245 if (!delayErrors) {
246 Throwable ex = errors.get();
247 if (ex != null) {
248 clear();
249 errors.tryTerminateConsumer(a);
250 return;
251 }
252 }
253
254 boolean d = n.get() == 0;
255 SpscLinkedArrayQueue<R> q = qr.get();
256 R v = q != null ? q.poll() : null;
257 boolean empty = v == null;
258
259 if (d && empty) {
260 errors.tryTerminateConsumer(a);
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 final class InnerObserver extends AtomicReference<Disposable>
279 implements MaybeObserver<R>, Disposable {
280 private static final long serialVersionUID = -502562646270949838L;
281
282 @Override
283 public void onSubscribe(Disposable d) {
284 DisposableHelper.setOnce(this, d);
285 }
286
287 @Override
288 public void onSuccess(R value) {
289 innerSuccess(this, value);
290 }
291
292 @Override
293 public void onError(Throwable e) {
294 innerError(this, e);
295 }
296
297 @Override
298 public void onComplete() {
299 innerComplete(this);
300 }
301
302 @Override
303 public boolean isDisposed() {
304 return DisposableHelper.isDisposed(get());
305 }
306
307 @Override
308 public void dispose() {
309 DisposableHelper.dispose(this);
310 }
311 }
312 }
313 }