io.reactivex.internal.operators.flowable.FlowableSequenceEqualSingle Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of rxjava Show documentation
Show all versions of rxjava Show documentation
Reactive Extensions for Java
/**
* Copyright (c) 2016-present, RxJava Contributors.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is
* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
* the License for the specific language governing permissions and limitations under the License.
*/
package io.reactivex.internal.operators.flowable;
import java.util.concurrent.atomic.AtomicInteger;
import org.reactivestreams.Publisher;
import io.reactivex.*;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BiPredicate;
import io.reactivex.internal.fuseable.*;
import io.reactivex.internal.operators.flowable.FlowableSequenceEqual.*;
import io.reactivex.internal.subscriptions.SubscriptionHelper;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.plugins.RxJavaPlugins;
public final class FlowableSequenceEqualSingle extends Single implements FuseToFlowable {
final Publisher first;
final Publisher second;
final BiPredicate comparer;
final int prefetch;
public FlowableSequenceEqualSingle(Publisher first, Publisher second,
BiPredicate comparer, int prefetch) {
this.first = first;
this.second = second;
this.comparer = comparer;
this.prefetch = prefetch;
}
@Override
public void subscribeActual(SingleObserver observer) {
EqualCoordinator parent = new EqualCoordinator(observer, prefetch, comparer);
observer.onSubscribe(parent);
parent.subscribe(first, second);
}
@Override
public Flowable fuseToFlowable() {
return RxJavaPlugins.onAssembly(new FlowableSequenceEqual(first, second, comparer, prefetch));
}
static final class EqualCoordinator
extends AtomicInteger
implements Disposable, EqualCoordinatorHelper {
private static final long serialVersionUID = -6178010334400373240L;
final SingleObserver downstream;
final BiPredicate comparer;
final EqualSubscriber first;
final EqualSubscriber second;
final AtomicThrowable error;
T v1;
T v2;
EqualCoordinator(SingleObserver actual, int prefetch, BiPredicate comparer) {
this.downstream = actual;
this.comparer = comparer;
this.first = new EqualSubscriber(this, prefetch);
this.second = new EqualSubscriber(this, prefetch);
this.error = new AtomicThrowable();
}
void subscribe(Publisher source1, Publisher source2) {
source1.subscribe(first);
source2.subscribe(second);
}
@Override
public void dispose() {
first.cancel();
second.cancel();
if (getAndIncrement() == 0) {
first.clear();
second.clear();
}
}
@Override
public boolean isDisposed() {
return first.get() == SubscriptionHelper.CANCELLED;
}
void cancelAndClear() {
first.cancel();
first.clear();
second.cancel();
second.clear();
}
@Override
public void drain() {
if (getAndIncrement() != 0) {
return;
}
int missed = 1;
for (;;) {
SimpleQueue q1 = first.queue;
SimpleQueue q2 = second.queue;
if (q1 != null && q2 != null) {
for (;;) {
if (isDisposed()) {
first.clear();
second.clear();
return;
}
Throwable ex = error.get();
if (ex != null) {
cancelAndClear();
downstream.onError(error.terminate());
return;
}
boolean d1 = first.done;
T a = v1;
if (a == null) {
try {
a = q1.poll();
} catch (Throwable exc) {
Exceptions.throwIfFatal(exc);
cancelAndClear();
error.addThrowable(exc);
downstream.onError(error.terminate());
return;
}
v1 = a;
}
boolean e1 = a == null;
boolean d2 = second.done;
T b = v2;
if (b == null) {
try {
b = q2.poll();
} catch (Throwable exc) {
Exceptions.throwIfFatal(exc);
cancelAndClear();
error.addThrowable(exc);
downstream.onError(error.terminate());
return;
}
v2 = b;
}
boolean e2 = b == null;
if (d1 && d2 && e1 && e2) {
downstream.onSuccess(true);
return;
}
if ((d1 && d2) && (e1 != e2)) {
cancelAndClear();
downstream.onSuccess(false);
return;
}
if (e1 || e2) {
break;
}
boolean c;
try {
c = comparer.test(a, b);
} catch (Throwable exc) {
Exceptions.throwIfFatal(exc);
cancelAndClear();
error.addThrowable(exc);
downstream.onError(error.terminate());
return;
}
if (!c) {
cancelAndClear();
downstream.onSuccess(false);
return;
}
v1 = null;
v2 = null;
first.request();
second.request();
}
} else {
if (isDisposed()) {
first.clear();
second.clear();
return;
}
Throwable ex = error.get();
if (ex != null) {
cancelAndClear();
downstream.onError(error.terminate());
return;
}
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
@Override
public void innerError(Throwable t) {
if (error.addThrowable(t)) {
drain();
} else {
RxJavaPlugins.onError(t);
}
}
}
}