Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeUsing.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.*;
24 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
25
26 /**
27 * Creates a resource and a dependent Maybe for each incoming Observer and optionally
28 * disposes the resource eagerly (before the terminal event is send out).
29 *
30 * @param <T> the value type
31 * @param <D> the resource type
32 */
33 public final class MaybeUsing<T, D> extends Maybe<T> {
34
35 final Supplier<? extends D> resourceSupplier;
36
37 final Function<? super D, ? extends MaybeSource<? extends T>> sourceSupplier;
38
39 final Consumer<? super D> resourceDisposer;
40
41 final boolean eager;
42
43 public MaybeUsing(Supplier<? extends D> resourceSupplier,
44 Function<? super D, ? extends MaybeSource<? extends T>> sourceSupplier,
45 Consumer<? super D> resourceDisposer,
46 boolean eager) {
47 this.resourceSupplier = resourceSupplier;
48 this.sourceSupplier = sourceSupplier;
49 this.resourceDisposer = resourceDisposer;
50 this.eager = eager;
51 }
52
53 @Override
54 protected void subscribeActual(MaybeObserver<? super T> observer) {
55 D resource;
56
57 try {
58 resource = resourceSupplier.get();
59 } catch (Throwable ex) {
60 Exceptions.throwIfFatal(ex);
61 EmptyDisposable.error(ex, observer);
62 return;
63 }
64
65 MaybeSource<? extends T> source;
66
67 try {
68 source = Objects.requireNonNull(sourceSupplier.apply(resource), "The sourceSupplier returned a null MaybeSource");
69 } catch (Throwable ex) {
70 Exceptions.throwIfFatal(ex);
71 if (eager) {
72 try {
73 resourceDisposer.accept(resource);
74 } catch (Throwable exc) {
75 Exceptions.throwIfFatal(exc);
76 EmptyDisposable.error(new CompositeException(ex, exc), observer);
77 return;
78 }
79 }
80
81 EmptyDisposable.error(ex, observer);
82
83 if (!eager) {
84 try {
85 resourceDisposer.accept(resource);
86 } catch (Throwable exc) {
87 Exceptions.throwIfFatal(exc);
88 RxJavaPlugins.onError(exc);
89 }
90 }
91 return;
92 }
93
94 source.subscribe(new UsingObserver<T, D>(observer, resource, resourceDisposer, eager));
95 }
96
97 static final class UsingObserver<T, D>
98 extends AtomicReference<Object>
99 implements MaybeObserver<T>, Disposable {
100
101 private static final long serialVersionUID = -674404550052917487L;
102
103 final MaybeObserver<? super T> downstream;
104
105 final Consumer<? super D> disposer;
106
107 final boolean eager;
108
109 Disposable upstream;
110
111 UsingObserver(MaybeObserver<? super T> actual, D resource, Consumer<? super D> disposer, boolean eager) {
112 super(resource);
113 this.downstream = actual;
114 this.disposer = disposer;
115 this.eager = eager;
116 }
117
118 @Override
119 public void dispose() {
120 if (eager) {
121 disposeResource();
122 upstream.dispose();
123 upstream = DisposableHelper.DISPOSED;
124 } else {
125 upstream.dispose();
126 upstream = DisposableHelper.DISPOSED;
127 disposeResource();
128 }
129 }
130
131 @SuppressWarnings("unchecked")
132 void disposeResource() {
133 Object resource = getAndSet(this);
134 if (resource != this) {
135 try {
136 disposer.accept((D)resource);
137 } catch (Throwable ex) {
138 Exceptions.throwIfFatal(ex);
139 RxJavaPlugins.onError(ex);
140 }
141 }
142 }
143
144 @Override
145 public boolean isDisposed() {
146 return upstream.isDisposed();
147 }
148
149 @Override
150 public void onSubscribe(Disposable d) {
151 if (DisposableHelper.validate(this.upstream, d)) {
152 this.upstream = d;
153
154 downstream.onSubscribe(this);
155 }
156 }
157
158 @SuppressWarnings("unchecked")
159 @Override
160 public void onSuccess(T value) {
161 upstream = DisposableHelper.DISPOSED;
162 if (eager) {
163 Object resource = getAndSet(this);
164 if (resource != this) {
165 try {
166 disposer.accept((D)resource);
167 } catch (Throwable ex) {
168 Exceptions.throwIfFatal(ex);
169 downstream.onError(ex);
170 return;
171 }
172 } else {
173 return;
174 }
175 }
176
177 downstream.onSuccess(value);
178
179 if (!eager) {
180 disposeResource();
181 }
182 }
183
184 @SuppressWarnings("unchecked")
185 @Override
186 public void onError(Throwable e) {
187 upstream = DisposableHelper.DISPOSED;
188 if (eager) {
189 Object resource = getAndSet(this);
190 if (resource != this) {
191 try {
192 disposer.accept((D)resource);
193 } catch (Throwable ex) {
194 Exceptions.throwIfFatal(ex);
195 e = new CompositeException(e, ex);
196 }
197 } else {
198 return;
199 }
200 }
201
202 downstream.onError(e);
203
204 if (!eager) {
205 disposeResource();
206 }
207 }
208
209 @SuppressWarnings("unchecked")
210 @Override
211 public void onComplete() {
212 upstream = DisposableHelper.DISPOSED;
213 if (eager) {
214 Object resource = getAndSet(this);
215 if (resource != this) {
216 try {
217 disposer.accept((D)resource);
218 } catch (Throwable ex) {
219 Exceptions.throwIfFatal(ex);
220 downstream.onError(ex);
221 return;
222 }
223 } else {
224 return;
225 }
226 }
227
228 downstream.onComplete();
229
230 if (!eager) {
231 disposeResource();
232 }
233 }
234 }
235 }