Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableCache.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.concurrent.atomic.*;
17
18 import io.reactivex.rxjava3.core.*;
19 import io.reactivex.rxjava3.disposables.Disposable;
20
21 /**
22 * Consume the upstream source exactly once and cache its terminal event.
23 * <p>History: 2.0.4 - experimental
24 * @since 2.1
25 */
26 public final class CompletableCache extends Completable implements CompletableObserver {
27
28 static final InnerCompletableCache[] EMPTY = new InnerCompletableCache[0];
29
30 static final InnerCompletableCache[] TERMINATED = new InnerCompletableCache[0];
31
32 final CompletableSource source;
33
34 final AtomicReference<InnerCompletableCache[]> observers;
35
36 final AtomicBoolean once;
37
38 Throwable error;
39
40 public CompletableCache(CompletableSource source) {
41 this.source = source;
42 this.observers = new AtomicReference<>(EMPTY);
43 this.once = new AtomicBoolean();
44 }
45
46 @Override
47 protected void subscribeActual(CompletableObserver observer) {
48 InnerCompletableCache inner = new InnerCompletableCache(observer);
49 observer.onSubscribe(inner);
50
51 if (add(inner)) {
52 if (inner.isDisposed()) {
53 remove(inner);
54 }
55
56 if (once.compareAndSet(false, true)) {
57 source.subscribe(this);
58 }
59 } else {
60 Throwable ex = error;
61 if (ex != null) {
62 observer.onError(ex);
63 } else {
64 observer.onComplete();
65 }
66 }
67 }
68
69 @Override
70 public void onSubscribe(Disposable d) {
71 // not used
72 }
73
74 @Override
75 public void onError(Throwable e) {
76 error = e;
77 for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) {
78 if (!inner.get()) {
79 inner.downstream.onError(e);
80 }
81 }
82 }
83
84 @Override
85 public void onComplete() {
86 for (InnerCompletableCache inner : observers.getAndSet(TERMINATED)) {
87 if (!inner.get()) {
88 inner.downstream.onComplete();
89 }
90 }
91 }
92
93 boolean add(InnerCompletableCache inner) {
94 for (;;) {
95 InnerCompletableCache[] a = observers.get();
96 if (a == TERMINATED) {
97 return false;
98 }
99 int n = a.length;
100 InnerCompletableCache[] b = new InnerCompletableCache[n + 1];
101 System.arraycopy(a, 0, b, 0, n);
102 b[n] = inner;
103 if (observers.compareAndSet(a, b)) {
104 return true;
105 }
106 }
107 }
108
109 void remove(InnerCompletableCache inner) {
110 for (;;) {
111 InnerCompletableCache[] a = observers.get();
112 int n = a.length;
113 if (n == 0) {
114 return;
115 }
116
117 int j = -1;
118
119 for (int i = 0; i < n; i++) {
120 if (a[i] == inner) {
121 j = i;
122 break;
123 }
124 }
125
126 if (j < 0) {
127 return;
128 }
129
130 InnerCompletableCache[] b;
131
132 if (n == 1) {
133 b = EMPTY;
134 } else {
135 b = new InnerCompletableCache[n - 1];
136 System.arraycopy(a, 0, b, 0, j);
137 System.arraycopy(a, j + 1, b, j, n - j - 1);
138 }
139
140 if (observers.compareAndSet(a, b)) {
141 break;
142 }
143 }
144 }
145
146 final class InnerCompletableCache
147 extends AtomicBoolean
148 implements Disposable {
149
150 private static final long serialVersionUID = 8943152917179642732L;
151
152 final CompletableObserver downstream;
153
154 InnerCompletableCache(CompletableObserver downstream) {
155 this.downstream = downstream;
156 }
157
158 @Override
159 public boolean isDisposed() {
160 return get();
161 }
162
163 @Override
164 public void dispose() {
165 if (compareAndSet(false, true)) {
166 remove(this);
167 }
168 }
169 }
170 }