Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/mixed/ObservableSwitchMapMaybe.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.mixed;
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.DisposableHelper;
24 import io.reactivex.rxjava3.internal.util.AtomicThrowable;
25 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
26
27 /**
28 * Maps the upstream items into {@link MaybeSource}s and switches (subscribes) to the newer ones
29 * while disposing the older ones and emits the latest success value if available, optionally delaying
30 * errors from the main source or the inner sources.
31 * <p>History: 2.1.11 - experimental
32 * @param <T> the upstream value type
33 * @param <R> the downstream value type
34 * @since 2.2
35 */
36 public final class ObservableSwitchMapMaybe<T, R> extends Observable<R> {
37
38 final Observable<T> source;
39
40 final Function<? super T, ? extends MaybeSource<? extends R>> mapper;
41
42 final boolean delayErrors;
43
44 public ObservableSwitchMapMaybe(Observable<T> source,
45 Function<? super T, ? extends MaybeSource<? extends R>> mapper,
46 boolean delayErrors) {
47 this.source = source;
48 this.mapper = mapper;
49 this.delayErrors = delayErrors;
50 }
51
52 @Override
53 protected void subscribeActual(Observer<? super R> observer) {
54 if (!ScalarXMapZHelper.tryAsMaybe(source, mapper, observer)) {
55 source.subscribe(new SwitchMapMaybeMainObserver<>(observer, mapper, delayErrors));
56 }
57 }
58
59 static final class SwitchMapMaybeMainObserver<T, R> extends AtomicInteger
60 implements Observer<T>, Disposable {
61
62 private static final long serialVersionUID = -5402190102429853762L;
63
64 final Observer<? super R> downstream;
65
66 final Function<? super T, ? extends MaybeSource<? extends R>> mapper;
67
68 final boolean delayErrors;
69
70 final AtomicThrowable errors;
71
72 final AtomicReference<SwitchMapMaybeObserver<R>> inner;
73
74 static final SwitchMapMaybeObserver<Object> INNER_DISPOSED =
75 new SwitchMapMaybeObserver<>(null);
76
77 Disposable upstream;
78
79 volatile boolean done;
80
81 volatile boolean cancelled;
82
83 SwitchMapMaybeMainObserver(Observer<? super R> downstream,
84 Function<? super T, ? extends MaybeSource<? extends R>> mapper,
85 boolean delayErrors) {
86 this.downstream = downstream;
87 this.mapper = mapper;
88 this.delayErrors = delayErrors;
89 this.errors = new AtomicThrowable();
90 this.inner = new AtomicReference<>();
91 }
92
93 @Override
94 public void onSubscribe(Disposable d) {
95 if (DisposableHelper.validate(upstream, d)) {
96 upstream = d;
97 downstream.onSubscribe(this);
98 }
99 }
100
101 @Override
102 @SuppressWarnings({ "unchecked", "rawtypes" })
103 public void onNext(T t) {
104 SwitchMapMaybeObserver<R> current = inner.get();
105 if (current != null) {
106 current.dispose();
107 }
108
109 MaybeSource<? extends R> ms;
110
111 try {
112 ms = Objects.requireNonNull(mapper.apply(t), "The mapper returned a null MaybeSource");
113 } catch (Throwable ex) {
114 Exceptions.throwIfFatal(ex);
115 upstream.dispose();
116 inner.getAndSet((SwitchMapMaybeObserver)INNER_DISPOSED);
117 onError(ex);
118 return;
119 }
120
121 SwitchMapMaybeObserver<R> observer = new SwitchMapMaybeObserver<>(this);
122
123 for (;;) {
124 current = inner.get();
125 if (current == INNER_DISPOSED) {
126 break;
127 }
128 if (inner.compareAndSet(current, observer)) {
129 ms.subscribe(observer);
130 break;
131 }
132 }
133 }
134
135 @Override
136 public void onError(Throwable t) {
137 if (errors.tryAddThrowableOrReport(t)) {
138 if (!delayErrors) {
139 disposeInner();
140 }
141 done = true;
142 drain();
143 }
144 }
145
146 @Override
147 public void onComplete() {
148 done = true;
149 drain();
150 }
151
152 @SuppressWarnings({ "unchecked", "rawtypes" })
153 void disposeInner() {
154 SwitchMapMaybeObserver<R> current = inner.getAndSet((SwitchMapMaybeObserver)INNER_DISPOSED);
155 if (current != null && current != INNER_DISPOSED) {
156 current.dispose();
157 }
158 }
159
160 @Override
161 public void dispose() {
162 cancelled = true;
163 upstream.dispose();
164 disposeInner();
165 errors.tryTerminateAndReport();
166 }
167
168 @Override
169 public boolean isDisposed() {
170 return cancelled;
171 }
172
173 void innerError(SwitchMapMaybeObserver<R> sender, Throwable ex) {
174 if (inner.compareAndSet(sender, null)) {
175 if (errors.tryAddThrowableOrReport(ex)) {
176 if (!delayErrors) {
177 upstream.dispose();
178 disposeInner();
179 }
180 drain();
181 }
182 } else {
183 RxJavaPlugins.onError(ex);
184 }
185 }
186
187 void innerComplete(SwitchMapMaybeObserver<R> sender) {
188 if (inner.compareAndSet(sender, null)) {
189 drain();
190 }
191 }
192
193 void drain() {
194 if (getAndIncrement() != 0) {
195 return;
196 }
197
198 int missed = 1;
199 Observer<? super R> downstream = this.downstream;
200 AtomicThrowable errors = this.errors;
201 AtomicReference<SwitchMapMaybeObserver<R>> inner = this.inner;
202
203 for (;;) {
204
205 for (;;) {
206 if (cancelled) {
207 return;
208 }
209
210 if (errors.get() != null) {
211 if (!delayErrors) {
212 errors.tryTerminateConsumer(downstream);
213 return;
214 }
215 }
216
217 boolean d = done;
218 SwitchMapMaybeObserver<R> current = inner.get();
219 boolean empty = current == null;
220
221 if (d && empty) {
222 errors.tryTerminateConsumer(downstream);
223 return;
224 }
225
226 if (empty || current.item == null) {
227 break;
228 }
229
230 inner.compareAndSet(current, null);
231
232 downstream.onNext(current.item);
233 }
234
235 missed = addAndGet(-missed);
236 if (missed == 0) {
237 break;
238 }
239 }
240 }
241
242 static final class SwitchMapMaybeObserver<R>
243 extends AtomicReference<Disposable> implements MaybeObserver<R> {
244
245 private static final long serialVersionUID = 8042919737683345351L;
246
247 final SwitchMapMaybeMainObserver<?, R> parent;
248
249 volatile R item;
250
251 SwitchMapMaybeObserver(SwitchMapMaybeMainObserver<?, R> parent) {
252 this.parent = parent;
253 }
254
255 @Override
256 public void onSubscribe(Disposable d) {
257 DisposableHelper.setOnce(this, d);
258 }
259
260 @Override
261 public void onSuccess(R t) {
262 item = t;
263 parent.drain();
264 }
265
266 @Override
267 public void onError(Throwable e) {
268 parent.innerError(this, e);
269 }
270
271 @Override
272 public void onComplete() {
273 parent.innerComplete(this);
274 }
275
276 void dispose() {
277 DisposableHelper.dispose(this);
278 }
279 }
280 }
281 }