Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableUsing.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.completable;
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 public final class CompletableUsing<R> extends Completable {
27
28 final Supplier<R> resourceSupplier;
29 final Function<? super R, ? extends CompletableSource> completableFunction;
30 final Consumer<? super R> disposer;
31 final boolean eager;
32
33 public CompletableUsing(Supplier<R> resourceSupplier,
34 Function<? super R, ? extends CompletableSource> completableFunction, Consumer<? super R> disposer,
35 boolean eager) {
36 this.resourceSupplier = resourceSupplier;
37 this.completableFunction = completableFunction;
38 this.disposer = disposer;
39 this.eager = eager;
40 }
41
42 @Override
43 protected void subscribeActual(CompletableObserver observer) {
44 R resource;
45
46 try {
47 resource = resourceSupplier.get();
48 } catch (Throwable ex) {
49 Exceptions.throwIfFatal(ex);
50 EmptyDisposable.error(ex, observer);
51 return;
52 }
53
54 CompletableSource source;
55
56 try {
57 source = Objects.requireNonNull(completableFunction.apply(resource), "The completableFunction returned a null CompletableSource");
58 } catch (Throwable ex) {
59 Exceptions.throwIfFatal(ex);
60 if (eager) {
61 try {
62 disposer.accept(resource);
63 } catch (Throwable exc) {
64 Exceptions.throwIfFatal(exc);
65 EmptyDisposable.error(new CompositeException(ex, exc), observer);
66 return;
67 }
68 }
69
70 EmptyDisposable.error(ex, observer);
71
72 if (!eager) {
73 try {
74 disposer.accept(resource);
75 } catch (Throwable exc) {
76 Exceptions.throwIfFatal(exc);
77 RxJavaPlugins.onError(exc);
78 }
79 }
80 return;
81 }
82
83 source.subscribe(new UsingObserver<>(observer, resource, disposer, eager));
84 }
85
86 static final class UsingObserver<R>
87 extends AtomicReference<Object>
88 implements CompletableObserver, Disposable {
89
90 private static final long serialVersionUID = -674404550052917487L;
91
92 final CompletableObserver downstream;
93
94 final Consumer<? super R> disposer;
95
96 final boolean eager;
97
98 Disposable upstream;
99
100 UsingObserver(CompletableObserver actual, R resource, Consumer<? super R> disposer, boolean eager) {
101 super(resource);
102 this.downstream = actual;
103 this.disposer = disposer;
104 this.eager = eager;
105 }
106
107 @Override
108 public void dispose() {
109 if (eager) {
110 disposeResource();
111 upstream.dispose();
112 upstream = DisposableHelper.DISPOSED;
113 } else {
114 upstream.dispose();
115 upstream = DisposableHelper.DISPOSED;
116 disposeResource();
117 }
118 }
119
120 @SuppressWarnings("unchecked")
121 void disposeResource() {
122 Object resource = getAndSet(this);
123 if (resource != this) {
124 try {
125 disposer.accept((R)resource);
126 } catch (Throwable ex) {
127 Exceptions.throwIfFatal(ex);
128 RxJavaPlugins.onError(ex);
129 }
130 }
131 }
132
133 @Override
134 public boolean isDisposed() {
135 return upstream.isDisposed();
136 }
137
138 @Override
139 public void onSubscribe(Disposable d) {
140 if (DisposableHelper.validate(this.upstream, d)) {
141 this.upstream = d;
142
143 downstream.onSubscribe(this);
144 }
145 }
146
147 @SuppressWarnings("unchecked")
148 @Override
149 public void onError(Throwable e) {
150 upstream = DisposableHelper.DISPOSED;
151 if (eager) {
152 Object resource = getAndSet(this);
153 if (resource != this) {
154 try {
155 disposer.accept((R)resource);
156 } catch (Throwable ex) {
157 Exceptions.throwIfFatal(ex);
158 e = new CompositeException(e, ex);
159 }
160 } else {
161 return;
162 }
163 }
164
165 downstream.onError(e);
166
167 if (!eager) {
168 disposeResource();
169 }
170 }
171
172 @SuppressWarnings("unchecked")
173 @Override
174 public void onComplete() {
175 upstream = DisposableHelper.DISPOSED;
176 if (eager) {
177 Object resource = getAndSet(this);
178 if (resource != this) {
179 try {
180 disposer.accept((R)resource);
181 } catch (Throwable ex) {
182 Exceptions.throwIfFatal(ex);
183 downstream.onError(ex);
184 return;
185 }
186 } else {
187 return;
188 }
189 }
190
191 downstream.onComplete();
192
193 if (!eager) {
194 disposeResource();
195 }
196 }
197 }
198
199 }