org.neo4j.driver.internal.shaded.reactor.core.publisher.FluxFirstWithSignal Maven / Gradle / Ivy
/*
* Copyright (c) 2016-2021 VMware Inc. or its affiliates, All Rights Reserved.
*
* 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
*
* https://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 reactor.core.publisher;
import java.util.Iterator;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.stream.Stream;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscription;
import reactor.core.CoreSubscriber;
import reactor.core.Scannable;
import reactor.util.annotation.Nullable;
/**
* Given a set of source Publishers the values of that Publisher is forwarded to the
* subscriber which responds first with any signal.
*
* @param the value type
*
* @see Reactive-Streams-Commons
*/
final class FluxFirstWithSignal extends Flux implements SourceProducer {
final Publisher[] array;
final Iterable> iterable;
@SafeVarargs
FluxFirstWithSignal(Publisher... array) {
this.array = Objects.requireNonNull(array, "array");
this.iterable = null;
}
FluxFirstWithSignal(Iterable> iterable) {
this.array = null;
this.iterable = Objects.requireNonNull(iterable);
}
@SuppressWarnings("unchecked")
@Override
public void subscribe(CoreSubscriber actual) {
Publisher[] a = array;
int n;
if (a == null) {
n = 0;
a = new Publisher[8];
Iterator> it;
try {
it = Objects.requireNonNull(iterable.iterator(),
"The iterator returned is null");
}
catch (Throwable e) {
Operators.error(actual, Operators.onOperatorError(e,
actual.currentContext()));
return;
}
for (; ; ) {
boolean b;
try {
b = it.hasNext();
}
catch (Throwable e) {
Operators.error(actual, Operators.onOperatorError(e,
actual.currentContext()));
return;
}
if (!b) {
break;
}
Publisher p;
try {
p = Objects.requireNonNull(it.next(),
"The Publisher returned by the iterator is null");
}
catch (Throwable e) {
Operators.error(actual, Operators.onOperatorError(e,
actual.currentContext()));
return;
}
if (n == a.length) {
Publisher[] c = new Publisher[n + (n >> 2)];
System.arraycopy(a, 0, c, 0, n);
a = c;
}
a[n++] = p;
}
}
else {
n = a.length;
}
if (n == 0) {
Operators.complete(actual);
return;
}
if (n == 1) {
Publisher p = a[0];
if (p == null) {
Operators.error(actual,
new NullPointerException("The single source Publisher is null"));
}
else {
p.subscribe(actual);
}
return;
}
RaceCoordinator coordinator = new RaceCoordinator<>(n);
coordinator.subscribe(a, n, actual);
}
/**
* Returns a new instance which has the additional source to be amb'd together with
* the current array of sources.
*
* This operation doesn't change the current {@link FluxFirstWithSignal} instance.
*
* @param source the new source to merge with the others
*
* @return the new {@link FluxFirstWithSignal} instance or null if the Amb runs with an Iterable
*/
@Nullable
FluxFirstWithSignal orAdditionalSource(Publisher source) {
if (array != null) {
int n = array.length;
@SuppressWarnings("unchecked") Publisher[] newArray =
new Publisher[n + 1];
System.arraycopy(array, 0, newArray, 0, n);
newArray[n] = source;
return new FluxFirstWithSignal<>(newArray);
}
return null;
}
@Override
public Object scanUnsafe(Attr key) {
if (key == Attr.RUN_STYLE) return Attr.RunStyle.SYNC;
return null;
}
static final class RaceCoordinator
implements Subscription, Scannable {
final FirstEmittingSubscriber[] subscribers;
volatile boolean cancelled;
volatile int winner;
@SuppressWarnings("rawtypes")
static final AtomicIntegerFieldUpdater WINNER =
AtomicIntegerFieldUpdater.newUpdater(RaceCoordinator.class, "winner");
@SuppressWarnings("unchecked")
RaceCoordinator(int n) {
subscribers = new FirstEmittingSubscriber[n];
winner = Integer.MIN_VALUE;
}
@Override
public Stream inners() {
return Stream.of(subscribers);
}
@Override
@Nullable
public Object scanUnsafe(Attr key) {
if (key == Attr.CANCELLED) return cancelled;
return null;
}
void subscribe(Publisher[] sources,
int n,
CoreSubscriber actual) {
FirstEmittingSubscriber[] a = subscribers;
for (int i = 0; i < n; i++) {
a[i] = new FirstEmittingSubscriber<>(actual, this, i);
}
actual.onSubscribe(this);
for (int i = 0; i < n; i++) {
if (cancelled || winner != Integer.MIN_VALUE) {
return;
}
Publisher p = sources[i];
if (p == null) {
if (WINNER.compareAndSet(this, Integer.MIN_VALUE, -1)) {
actual.onError(new NullPointerException("The " + i + " th Publisher source is null"));
}
return;
}
p.subscribe(a[i]);
}
}
@Override
public void request(long n) {
if (Operators.validate(n)) {
int w = winner;
if (w >= 0) {
subscribers[w].request(n);
}
else {
for (FirstEmittingSubscriber s : subscribers) {
s.request(n);
}
}
}
}
@Override
public void cancel() {
if (cancelled) {
return;
}
cancelled = true;
int w = winner;
if (w >= 0) {
subscribers[w].cancel();
}
else {
for (FirstEmittingSubscriber s : subscribers) {
s.cancel();
}
}
}
boolean tryWin(int index) {
if (winner == Integer.MIN_VALUE) {
if (WINNER.compareAndSet(this, Integer.MIN_VALUE, index)) {
FirstEmittingSubscriber[] a = subscribers;
int n = a.length;
for (int i = 0; i < n; i++) {
if (i != index) {
a[i].cancel();
}
}
return true;
}
}
return false;
}
}
static final class FirstEmittingSubscriber extends Operators.DeferredSubscription
implements InnerOperator {
final RaceCoordinator parent;
final CoreSubscriber actual;
final int index;
boolean won;
FirstEmittingSubscriber(CoreSubscriber actual,
RaceCoordinator parent,
int index) {
this.actual = actual;
this.parent = parent;
this.index = index;
}
@Override
@Nullable
public Object scanUnsafe(Attr key) {
if (key == Attr.PARENT) return s;
if (key == Attr.CANCELLED) return parent.cancelled;
if (key == Attr.RUN_STYLE) return Attr.RunStyle.SYNC;
return InnerOperator.super.scanUnsafe(key);
}
@Override
public void onSubscribe(Subscription s) {
set(s);
}
@Override
public CoreSubscriber actual() {
return actual;
}
@Override
public void onNext(T t) {
if (won) {
actual.onNext(t);
}
else if (parent.tryWin(index)) {
won = true;
actual.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (won) {
actual.onError(t);
}
else if (parent.tryWin(index)) {
won = true;
actual.onError(t);
}
}
@Override
public void onComplete() {
if (won) {
actual.onComplete();
}
else if (parent.tryWin(index)) {
won = true;
actual.onComplete();
}
}
}
}