Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableRefCount.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.concurrent.TimeUnit;
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.functions.Consumer;
22 import io.reactivex.rxjava3.internal.disposables.*;
23 import io.reactivex.rxjava3.observables.ConnectableObservable;
24 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
25
26 /**
27 * Returns an observable sequence that stays connected to the source as long as
28 * there is at least one subscription to the observable sequence.
29 *
30 * @param <T>
31 * the value type
32 */
33 public final class ObservableRefCount<T> extends Observable<T> {
34
35 final ConnectableObservable<T> source;
36
37 final int n;
38
39 final long timeout;
40
41 final TimeUnit unit;
42
43 final Scheduler scheduler;
44
45 RefConnection connection;
46
47 public ObservableRefCount(ConnectableObservable<T> source) {
48 this(source, 1, 0L, TimeUnit.NANOSECONDS, null);
49 }
50
51 public ObservableRefCount(ConnectableObservable<T> source, int n, long timeout, TimeUnit unit,
52 Scheduler scheduler) {
53 this.source = source;
54 this.n = n;
55 this.timeout = timeout;
56 this.unit = unit;
57 this.scheduler = scheduler;
58 }
59
60 @Override
61 protected void subscribeActual(Observer<? super T> observer) {
62
63 RefConnection conn;
64
65 boolean connect = false;
66 synchronized (this) {
67 conn = connection;
68 if (conn == null) {
69 conn = new RefConnection(this);
70 connection = conn;
71 }
72
73 long c = conn.subscriberCount;
74 if (c == 0L && conn.timer != null) {
75 conn.timer.dispose();
76 }
77 conn.subscriberCount = c + 1;
78 if (!conn.connected && c + 1 == n) {
79 connect = true;
80 conn.connected = true;
81 }
82 }
83
84 source.subscribe(new RefCountObserver<>(observer, this, conn));
85
86 if (connect) {
87 source.connect(conn);
88 }
89 }
90
91 void cancel(RefConnection rc) {
92 SequentialDisposable sd;
93 synchronized (this) {
94 if (connection == null || connection != rc) {
95 return;
96 }
97 long c = rc.subscriberCount - 1;
98 rc.subscriberCount = c;
99 if (c != 0L || !rc.connected) {
100 return;
101 }
102 if (timeout == 0L) {
103 timeout(rc);
104 return;
105 }
106 sd = new SequentialDisposable();
107 rc.timer = sd;
108 }
109
110 sd.replace(scheduler.scheduleDirect(rc, timeout, unit));
111 }
112
113 void terminated(RefConnection rc) {
114 synchronized (this) {
115 if (connection == rc) {
116 if (rc.timer != null) {
117 rc.timer.dispose();
118 rc.timer = null;
119 }
120 if (--rc.subscriberCount == 0) {
121 connection = null;
122 source.reset();
123 }
124 }
125 }
126 }
127
128 void timeout(RefConnection rc) {
129 synchronized (this) {
130 if (rc.subscriberCount == 0 && rc == connection) {
131 connection = null;
132 Disposable connectionObject = rc.get();
133 DisposableHelper.dispose(rc);
134
135 if (connectionObject == null) {
136 rc.disconnectedEarly = true;
137 } else {
138 source.reset();
139 }
140 }
141 }
142 }
143
144 static final class RefConnection extends AtomicReference<Disposable>
145 implements Runnable, Consumer<Disposable> {
146
147 private static final long serialVersionUID = -4552101107598366241L;
148
149 final ObservableRefCount<?> parent;
150
151 Disposable timer;
152
153 long subscriberCount;
154
155 boolean connected;
156
157 boolean disconnectedEarly;
158
159 RefConnection(ObservableRefCount<?> parent) {
160 this.parent = parent;
161 }
162
163 @Override
164 public void run() {
165 parent.timeout(this);
166 }
167
168 @Override
169 public void accept(Disposable t) {
170 DisposableHelper.replace(this, t);
171 synchronized (parent) {
172 if (disconnectedEarly) {
173 parent.source.reset();
174 }
175 }
176 }
177 }
178
179 static final class RefCountObserver<T>
180 extends AtomicBoolean implements Observer<T>, Disposable {
181
182 private static final long serialVersionUID = -7419642935409022375L;
183
184 final Observer<? super T> downstream;
185
186 final ObservableRefCount<T> parent;
187
188 final RefConnection connection;
189
190 Disposable upstream;
191
192 RefCountObserver(Observer<? super T> downstream, ObservableRefCount<T> parent, RefConnection connection) {
193 this.downstream = downstream;
194 this.parent = parent;
195 this.connection = connection;
196 }
197
198 @Override
199 public void onNext(T t) {
200 downstream.onNext(t);
201 }
202
203 @Override
204 public void onError(Throwable t) {
205 if (compareAndSet(false, true)) {
206 parent.terminated(connection);
207 downstream.onError(t);
208 } else {
209 RxJavaPlugins.onError(t);
210 }
211 }
212
213 @Override
214 public void onComplete() {
215 if (compareAndSet(false, true)) {
216 parent.terminated(connection);
217 downstream.onComplete();
218 }
219 }
220
221 @Override
222 public void dispose() {
223 upstream.dispose();
224 if (compareAndSet(false, true)) {
225 parent.cancel(connection);
226 }
227 }
228
229 @Override
230 public boolean isDisposed() {
231 return upstream.isDisposed();
232 }
233
234 @Override
235 public void onSubscribe(Disposable d) {
236 if (DisposableHelper.validate(upstream, d)) {
237 this.upstream = d;
238
239 downstream.onSubscribe(this);
240 }
241 }
242 }
243 }