Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeFlatMapNotification.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.maybe;
15
16 import java.util.Objects;
17 import java.util.concurrent.atomic.AtomicReference;
18
19 import io.reactivex.rxjava3.core.*;
20 import io.reactivex.rxjava3.disposables.Disposable;
21 import io.reactivex.rxjava3.exceptions.*;
22 import io.reactivex.rxjava3.functions.*;
23 import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
24
25 /**
26 * Maps a value into a MaybeSource and relays its signal.
27 *
28 * @param <T> the source value type
29 * @param <R> the result value type
30 */
31 public final class MaybeFlatMapNotification<T, R> extends AbstractMaybeWithUpstream<T, R> {
32
33 final Function<? super T, ? extends MaybeSource<? extends R>> onSuccessMapper;
34
35 final Function<? super Throwable, ? extends MaybeSource<? extends R>> onErrorMapper;
36
37 final Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier;
38
39 public MaybeFlatMapNotification(MaybeSource<T> source,
40 Function<? super T, ? extends MaybeSource<? extends R>> onSuccessMapper,
41 Function<? super Throwable, ? extends MaybeSource<? extends R>> onErrorMapper,
42 Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier) {
43 super(source);
44 this.onSuccessMapper = onSuccessMapper;
45 this.onErrorMapper = onErrorMapper;
46 this.onCompleteSupplier = onCompleteSupplier;
47 }
48
49 @Override
50 protected void subscribeActual(MaybeObserver<? super R> observer) {
51 source.subscribe(new FlatMapMaybeObserver<>(observer, onSuccessMapper, onErrorMapper, onCompleteSupplier));
52 }
53
54 static final class FlatMapMaybeObserver<T, R>
55 extends AtomicReference<Disposable>
56 implements MaybeObserver<T>, Disposable {
57
58 private static final long serialVersionUID = 4375739915521278546L;
59
60 final MaybeObserver<? super R> downstream;
61
62 final Function<? super T, ? extends MaybeSource<? extends R>> onSuccessMapper;
63
64 final Function<? super Throwable, ? extends MaybeSource<? extends R>> onErrorMapper;
65
66 final Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier;
67
68 Disposable upstream;
69
70 FlatMapMaybeObserver(MaybeObserver<? super R> actual,
71 Function<? super T, ? extends MaybeSource<? extends R>> onSuccessMapper,
72 Function<? super Throwable, ? extends MaybeSource<? extends R>> onErrorMapper,
73 Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier) {
74 this.downstream = actual;
75 this.onSuccessMapper = onSuccessMapper;
76 this.onErrorMapper = onErrorMapper;
77 this.onCompleteSupplier = onCompleteSupplier;
78 }
79
80 @Override
81 public void dispose() {
82 DisposableHelper.dispose(this);
83 upstream.dispose();
84 }
85
86 @Override
87 public boolean isDisposed() {
88 return DisposableHelper.isDisposed(get());
89 }
90
91 @Override
92 public void onSubscribe(Disposable d) {
93 if (DisposableHelper.validate(this.upstream, d)) {
94 this.upstream = d;
95
96 downstream.onSubscribe(this);
97 }
98 }
99
100 @Override
101 public void onSuccess(T value) {
102 MaybeSource<? extends R> source;
103
104 try {
105 source = Objects.requireNonNull(onSuccessMapper.apply(value), "The onSuccessMapper returned a null MaybeSource");
106 } catch (Throwable ex) {
107 Exceptions.throwIfFatal(ex);
108 downstream.onError(ex);
109 return;
110 }
111
112 if (!isDisposed()) {
113 source.subscribe(new InnerObserver());
114 }
115 }
116
117 @Override
118 public void onError(Throwable e) {
119 MaybeSource<? extends R> source;
120
121 try {
122 source = Objects.requireNonNull(onErrorMapper.apply(e), "The onErrorMapper returned a null MaybeSource");
123 } catch (Throwable ex) {
124 Exceptions.throwIfFatal(ex);
125 downstream.onError(new CompositeException(e, ex));
126 return;
127 }
128
129 if (!isDisposed()) {
130 source.subscribe(new InnerObserver());
131 }
132 }
133
134 @Override
135 public void onComplete() {
136 MaybeSource<? extends R> source;
137
138 try {
139 source = Objects.requireNonNull(onCompleteSupplier.get(), "The onCompleteSupplier returned a null MaybeSource");
140 } catch (Throwable ex) {
141 Exceptions.throwIfFatal(ex);
142 downstream.onError(ex);
143 return;
144 }
145
146 if (!isDisposed()) {
147 source.subscribe(new InnerObserver());
148 }
149 }
150
151 final class InnerObserver implements MaybeObserver<R> {
152
153 @Override
154 public void onSubscribe(Disposable d) {
155 DisposableHelper.setOnce(FlatMapMaybeObserver.this, d);
156 }
157
158 @Override
159 public void onSuccess(R value) {
160 downstream.onSuccess(value);
161 }
162
163 @Override
164 public void onError(Throwable e) {
165 downstream.onError(e);
166 }
167
168 @Override
169 public void onComplete() {
170 downstream.onComplete();
171 }
172 }
173 }
174 }