Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableUsing.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.AtomicBoolean;
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 ObservableUsing<T, D> extends Observable<T> {
27 final Supplier<? extends D> resourceSupplier;
28 final Function<? super D, ? extends ObservableSource<? extends T>> sourceSupplier;
29 final Consumer<? super D> disposer;
30 final boolean eager;
31
32 public ObservableUsing(Supplier<? extends D> resourceSupplier,
33 Function<? super D, ? extends ObservableSource<? extends T>> sourceSupplier,
34 Consumer<? super D> disposer,
35 boolean eager) {
36 this.resourceSupplier = resourceSupplier;
37 this.sourceSupplier = sourceSupplier;
38 this.disposer = disposer;
39 this.eager = eager;
40 }
41
42 @Override
43 public void subscribeActual(Observer<? super T> observer) {
44 D resource;
45
46 try {
47 resource = resourceSupplier.get();
48 } catch (Throwable e) {
49 Exceptions.throwIfFatal(e);
50 EmptyDisposable.error(e, observer);
51 return;
52 }
53
54 ObservableSource<? extends T> source;
55 try {
56 source = Objects.requireNonNull(sourceSupplier.apply(resource), "The sourceSupplier returned a null ObservableSource");
57 } catch (Throwable e) {
58 Exceptions.throwIfFatal(e);
59 try {
60 disposer.accept(resource);
61 } catch (Throwable ex) {
62 Exceptions.throwIfFatal(ex);
63 EmptyDisposable.error(new CompositeException(e, ex), observer);
64 return;
65 }
66 EmptyDisposable.error(e, observer);
67 return;
68 }
69
70 UsingObserver<T, D> us = new UsingObserver<>(observer, resource, disposer, eager);
71
72 source.subscribe(us);
73 }
74
75 static final class UsingObserver<T, D> extends AtomicBoolean implements Observer<T>, Disposable {
76
77 private static final long serialVersionUID = 5904473792286235046L;
78
79 final Observer<? super T> downstream;
80 final D resource;
81 final Consumer<? super D> disposer;
82 final boolean eager;
83
84 Disposable upstream;
85
86 UsingObserver(Observer<? super T> actual, D resource, Consumer<? super D> disposer, boolean eager) {
87 this.downstream = actual;
88 this.resource = resource;
89 this.disposer = disposer;
90 this.eager = eager;
91 }
92
93 @Override
94 public void onSubscribe(Disposable d) {
95 if (DisposableHelper.validate(this.upstream, d)) {
96 this.upstream = d;
97 downstream.onSubscribe(this);
98 }
99 }
100
101 @Override
102 public void onNext(T t) {
103 downstream.onNext(t);
104 }
105
106 @Override
107 public void onError(Throwable t) {
108 if (eager) {
109 if (compareAndSet(false, true)) {
110 try {
111 disposer.accept(resource);
112 } catch (Throwable e) {
113 Exceptions.throwIfFatal(e);
114 t = new CompositeException(t, e);
115 }
116 }
117
118 downstream.onError(t);
119 } else {
120 downstream.onError(t);
121 disposeResource();
122 }
123 }
124
125 @Override
126 public void onComplete() {
127 if (eager) {
128 if (compareAndSet(false, true)) {
129 try {
130 disposer.accept(resource);
131 } catch (Throwable e) {
132 Exceptions.throwIfFatal(e);
133 downstream.onError(e);
134 return;
135 }
136 }
137
138 downstream.onComplete();
139 } else {
140 downstream.onComplete();
141 disposeResource();
142 }
143 }
144
145 @Override
146 public void dispose() {
147 if (eager) {
148 disposeResource();
149 upstream.dispose();
150 upstream = DisposableHelper.DISPOSED;
151 } else {
152 upstream.dispose();
153 upstream = DisposableHelper.DISPOSED;
154 disposeResource();
155 }
156 }
157
158 @Override
159 public boolean isDisposed() {
160 return get();
161 }
162
163 void disposeResource() {
164 if (compareAndSet(false, true)) {
165 try {
166 disposer.accept(resource);
167 } catch (Throwable e) {
168 Exceptions.throwIfFatal(e);
169 // can't call actual.onError unless it is serialized, which is expensive
170 RxJavaPlugins.onError(e);
171 }
172 }
173 }
174 }
175 }