Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSequenceEqualSingle.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.atomic.AtomicInteger;
17
18 import io.reactivex.rxjava3.core.*;
19 import io.reactivex.rxjava3.disposables.Disposable;
20 import io.reactivex.rxjava3.exceptions.Exceptions;
21 import io.reactivex.rxjava3.functions.BiPredicate;
22 import io.reactivex.rxjava3.internal.disposables.ArrayCompositeDisposable;
23 import io.reactivex.rxjava3.internal.fuseable.FuseToObservable;
24 import io.reactivex.rxjava3.operators.SpscLinkedArrayQueue;
25 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
26
27 public final class ObservableSequenceEqualSingle<T> extends Single<Boolean> implements FuseToObservable<Boolean> {
28 final ObservableSource<? extends T> first;
29 final ObservableSource<? extends T> second;
30 final BiPredicate<? super T, ? super T> comparer;
31 final int bufferSize;
32
33 public ObservableSequenceEqualSingle(ObservableSource<? extends T> first, ObservableSource<? extends T> second,
34 BiPredicate<? super T, ? super T> comparer, int bufferSize) {
35 this.first = first;
36 this.second = second;
37 this.comparer = comparer;
38 this.bufferSize = bufferSize;
39 }
40
41 @Override
42 public void subscribeActual(SingleObserver<? super Boolean> observer) {
43 EqualCoordinator<T> ec = new EqualCoordinator<>(observer, bufferSize, first, second, comparer);
44 observer.onSubscribe(ec);
45 ec.subscribe();
46 }
47
48 @Override
49 public Observable<Boolean> fuseToObservable() {
50 return RxJavaPlugins.onAssembly(new ObservableSequenceEqual<>(first, second, comparer, bufferSize));
51 }
52
53 static final class EqualCoordinator<T> extends AtomicInteger implements Disposable {
54
55 private static final long serialVersionUID = -6178010334400373240L;
56 final SingleObserver<? super Boolean> downstream;
57 final BiPredicate<? super T, ? super T> comparer;
58 final ArrayCompositeDisposable resources;
59 final ObservableSource<? extends T> first;
60 final ObservableSource<? extends T> second;
61 final EqualObserver<T>[] observers;
62
63 volatile boolean cancelled;
64
65 T v1;
66
67 T v2;
68
69 EqualCoordinator(SingleObserver<? super Boolean> actual, int bufferSize,
70 ObservableSource<? extends T> first, ObservableSource<? extends T> second,
71 BiPredicate<? super T, ? super T> comparer) {
72 this.downstream = actual;
73 this.first = first;
74 this.second = second;
75 this.comparer = comparer;
76 @SuppressWarnings("unchecked")
77 EqualObserver<T>[] as = new EqualObserver[2];
78 this.observers = as;
79 as[0] = new EqualObserver<>(this, 0, bufferSize);
80 as[1] = new EqualObserver<>(this, 1, bufferSize);
81 this.resources = new ArrayCompositeDisposable(2);
82 }
83
84 boolean setDisposable(Disposable d, int index) {
85 return resources.setResource(index, d);
86 }
87
88 void subscribe() {
89 EqualObserver<T>[] as = observers;
90 first.subscribe(as[0]);
91 second.subscribe(as[1]);
92 }
93
94 @Override
95 public void dispose() {
96 if (!cancelled) {
97 cancelled = true;
98 resources.dispose();
99
100 if (getAndIncrement() == 0) {
101 EqualObserver<T>[] as = observers;
102 as[0].queue.clear();
103 as[1].queue.clear();
104 }
105 }
106 }
107
108 @Override
109 public boolean isDisposed() {
110 return cancelled;
111 }
112
113 void cancel(SpscLinkedArrayQueue<T> q1, SpscLinkedArrayQueue<T> q2) {
114 cancelled = true;
115 q1.clear();
116 q2.clear();
117 }
118
119 void drain() {
120 if (getAndIncrement() != 0) {
121 return;
122 }
123
124 int missed = 1;
125 EqualObserver<T>[] as = observers;
126
127 final EqualObserver<T> observer1 = as[0];
128 final SpscLinkedArrayQueue<T> q1 = observer1.queue;
129 final EqualObserver<T> observer2 = as[1];
130 final SpscLinkedArrayQueue<T> q2 = observer2.queue;
131
132 for (;;) {
133
134 for (;;) {
135 if (cancelled) {
136 q1.clear();
137 q2.clear();
138 return;
139 }
140
141 boolean d1 = observer1.done;
142
143 if (d1) {
144 Throwable e = observer1.error;
145 if (e != null) {
146 cancel(q1, q2);
147
148 downstream.onError(e);
149 return;
150 }
151 }
152
153 boolean d2 = observer2.done;
154 if (d2) {
155 Throwable e = observer2.error;
156 if (e != null) {
157 cancel(q1, q2);
158
159 downstream.onError(e);
160 return;
161 }
162 }
163
164 if (v1 == null) {
165 v1 = q1.poll();
166 }
167 boolean e1 = v1 == null;
168
169 if (v2 == null) {
170 v2 = q2.poll();
171 }
172 boolean e2 = v2 == null;
173
174 if (d1 && d2 && e1 && e2) {
175 downstream.onSuccess(true);
176 return;
177 }
178 if ((d1 && d2) && (e1 != e2)) {
179 cancel(q1, q2);
180
181 downstream.onSuccess(false);
182 return;
183 }
184
185 if (!e1 && !e2) {
186 boolean c;
187
188 try {
189 c = comparer.test(v1, v2);
190 } catch (Throwable ex) {
191 Exceptions.throwIfFatal(ex);
192 cancel(q1, q2);
193
194 downstream.onError(ex);
195 return;
196 }
197
198 if (!c) {
199 cancel(q1, q2);
200
201 downstream.onSuccess(false);
202 return;
203 }
204
205 v1 = null;
206 v2 = null;
207 }
208
209 if (e1 || e2) {
210 break;
211 }
212 }
213
214 missed = addAndGet(-missed);
215 if (missed == 0) {
216 break;
217 }
218 }
219 }
220 }
221
222 static final class EqualObserver<T> implements Observer<T> {
223 final EqualCoordinator<T> parent;
224 final SpscLinkedArrayQueue<T> queue;
225 final int index;
226
227 volatile boolean done;
228 Throwable error;
229
230 EqualObserver(EqualCoordinator<T> parent, int index, int bufferSize) {
231 this.parent = parent;
232 this.index = index;
233 this.queue = new SpscLinkedArrayQueue<>(bufferSize);
234 }
235
236 @Override
237 public void onSubscribe(Disposable d) {
238 parent.setDisposable(d, index);
239 }
240
241 @Override
242 public void onNext(T t) {
243 queue.offer(t);
244 parent.drain();
245 }
246
247 @Override
248 public void onError(Throwable t) {
249 error = t;
250 done = true;
251 parent.drain();
252 }
253
254 @Override
255 public void onComplete() {
256 done = true;
257 parent.drain();
258 }
259 }
260 }