io.reactivex.internal.operators.flowable.FlowablePublishMulticast 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.*;
import org.reactivestreams.*;
import io.reactivex.*;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.*;
import io.reactivex.functions.Function;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.fuseable.*;
import io.reactivex.internal.subscriptions.*;
import io.reactivex.internal.util.*;
import io.reactivex.plugins.RxJavaPlugins;
/**
* Multicasts a Flowable over a selector function.
*
* @param the input value type
* @param the output value type
*/
public final class FlowablePublishMulticast extends AbstractFlowableWithUpstream {
final Function, ? extends Publisher> selector;
final int prefetch;
final boolean delayError;
public FlowablePublishMulticast(Flowable source,
Function, ? extends Publisher> selector, int prefetch,
boolean delayError) {
super(source);
this.selector = selector;
this.prefetch = prefetch;
this.delayError = delayError;
}
@Override
protected void subscribeActual(Subscriber s) {
MulticastProcessor mp = new MulticastProcessor(prefetch, delayError);
Publisher other;
try {
other = ObjectHelper.requireNonNull(selector.apply(mp), "selector returned a null Publisher");
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
EmptySubscription.error(ex, s);
return;
}
OutputCanceller out = new OutputCanceller(s, mp);
other.subscribe(out);
source.subscribe(mp);
}
static final class OutputCanceller implements FlowableSubscriber, Subscription {
final Subscriber downstream;
final MulticastProcessor processor;
Subscription upstream;
OutputCanceller(Subscriber actual, MulticastProcessor processor) {
this.downstream = actual;
this.processor = processor;
}
@Override
public void onSubscribe(Subscription s) {
if (SubscriptionHelper.validate(this.upstream, s)) {
this.upstream = s;
downstream.onSubscribe(this);
}
}
@Override
public void onNext(R t) {
downstream.onNext(t);
}
@Override
public void onError(Throwable t) {
downstream.onError(t);
processor.dispose();
}
@Override
public void onComplete() {
downstream.onComplete();
processor.dispose();
}
@Override
public void request(long n) {
upstream.request(n);
}
@Override
public void cancel() {
upstream.cancel();
processor.dispose();
}
}
static final class MulticastProcessor extends Flowable implements FlowableSubscriber, Disposable {
@SuppressWarnings("rawtypes")
static final MulticastSubscription[] EMPTY = new MulticastSubscription[0];
@SuppressWarnings("rawtypes")
static final MulticastSubscription[] TERMINATED = new MulticastSubscription[0];
final AtomicInteger wip;
final AtomicReference[]> subscribers;
final int prefetch;
final int limit;
final boolean delayError;
final AtomicReference upstream;
volatile SimpleQueue queue;
int sourceMode;
volatile boolean done;
Throwable error;
int consumed;
@SuppressWarnings("unchecked")
MulticastProcessor(int prefetch, boolean delayError) {
this.prefetch = prefetch;
this.limit = prefetch - (prefetch >> 2); // request after 75% consumption
this.delayError = delayError;
this.wip = new AtomicInteger();
this.upstream = new AtomicReference();
this.subscribers = new AtomicReference[]>(EMPTY);
}
@Override
public void onSubscribe(Subscription s) {
if (SubscriptionHelper.setOnce(this.upstream, s)) {
if (s instanceof QueueSubscription) {
@SuppressWarnings("unchecked")
QueueSubscription qs = (QueueSubscription) s;
int m = qs.requestFusion(QueueSubscription.ANY);
if (m == QueueSubscription.SYNC) {
sourceMode = m;
queue = qs;
done = true;
drain();
return;
}
if (m == QueueSubscription.ASYNC) {
sourceMode = m;
queue = qs;
QueueDrainHelper.request(s, prefetch);
return;
}
}
queue = QueueDrainHelper.createQueue(prefetch);
QueueDrainHelper.request(s, prefetch);
}
}
@Override
public void dispose() {
SubscriptionHelper.cancel(upstream);
if (wip.getAndIncrement() == 0) {
SimpleQueue q = queue;
if (q != null) {
q.clear();
}
}
}
@Override
public boolean isDisposed() {
return upstream.get() == SubscriptionHelper.CANCELLED;
}
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode == QueueSubscription.NONE && !queue.offer(t)) {
upstream.get().cancel();
onError(new MissingBackpressureException());
return;
}
drain();
}
@Override
public void onError(Throwable t) {
if (done) {
RxJavaPlugins.onError(t);
return;
}
error = t;
done = true;
drain();
}
@Override
public void onComplete() {
if (!done) {
done = true;
drain();
}
}
boolean add(MulticastSubscription s) {
for (;;) {
MulticastSubscription[] current = subscribers.get();
if (current == TERMINATED) {
return false;
}
int n = current.length;
@SuppressWarnings("unchecked")
MulticastSubscription[] next = new MulticastSubscription[n + 1];
System.arraycopy(current, 0, next, 0, n);
next[n] = s;
if (subscribers.compareAndSet(current, next)) {
return true;
}
}
}
@SuppressWarnings("unchecked")
void remove(MulticastSubscription s) {
for (;;) {
MulticastSubscription[] current = subscribers.get();
int n = current.length;
if (n == 0) {
return;
}
int j = -1;
for (int i = 0; i < n; i++) {
if (current[i] == s) {
j = i;
break;
}
}
if (j < 0) {
return;
}
MulticastSubscription[] next;
if (n == 1) {
next = EMPTY;
} else {
next = new MulticastSubscription[n - 1];
System.arraycopy(current, 0, next, 0, j);
System.arraycopy(current, j + 1, next, j, n - j - 1);
}
if (subscribers.compareAndSet(current, next)) {
return;
}
}
}
@Override
protected void subscribeActual(Subscriber s) {
MulticastSubscription ms = new MulticastSubscription(s, this);
s.onSubscribe(ms);
if (add(ms)) {
if (ms.isCancelled()) {
remove(ms);
return;
}
drain();
} else {
Throwable ex = error;
if (ex != null) {
s.onError(ex);
} else {
s.onComplete();
}
}
}
void drain() {
if (wip.getAndIncrement() != 0) {
return;
}
int missed = 1;
SimpleQueue q = queue;
int upstreamConsumed = consumed;
int localLimit = limit;
boolean canRequest = sourceMode != QueueSubscription.SYNC;
AtomicReference[]> subs = subscribers;
MulticastSubscription[] array = subs.get();
outer:
for (;;) {
int n = array.length;
if (q != null && n != 0) {
long r = Long.MAX_VALUE;
for (MulticastSubscription ms : array) {
long u = ms.get() - ms.emitted;
if (u != Long.MIN_VALUE) {
if (r > u) {
r = u;
}
} else {
n--;
}
}
if (n == 0) {
r = 0;
}
while (r != 0) {
if (isDisposed()) {
q.clear();
return;
}
boolean d = done;
if (d && !delayError) {
Throwable ex = error;
if (ex != null) {
errorAll(ex);
return;
}
}
T v;
try {
v = q.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
SubscriptionHelper.cancel(upstream);
errorAll(ex);
return;
}
boolean empty = v == null;
if (d && empty) {
Throwable ex = error;
if (ex != null) {
errorAll(ex);
} else {
completeAll();
}
return;
}
if (empty) {
break;
}
boolean subscribersChange = false;
for (MulticastSubscription ms : array) {
long msr = ms.get();
if (msr != Long.MIN_VALUE) {
if (msr != Long.MAX_VALUE) {
ms.emitted++;
}
ms.downstream.onNext(v);
} else {
subscribersChange = true;
}
}
r--;
if (canRequest && ++upstreamConsumed == localLimit) {
upstreamConsumed = 0;
upstream.get().request(localLimit);
}
MulticastSubscription[] freshArray = subs.get();
if (subscribersChange || freshArray != array) {
array = freshArray;
continue outer;
}
}
if (r == 0) {
if (isDisposed()) {
q.clear();
return;
}
boolean d = done;
if (d && !delayError) {
Throwable ex = error;
if (ex != null) {
errorAll(ex);
return;
}
}
if (d && q.isEmpty()) {
Throwable ex = error;
if (ex != null) {
errorAll(ex);
} else {
completeAll();
}
return;
}
}
}
consumed = upstreamConsumed;
missed = wip.addAndGet(-missed);
if (missed == 0) {
break;
}
if (q == null) {
q = queue;
}
array = subs.get();
}
}
@SuppressWarnings("unchecked")
void errorAll(Throwable ex) {
for (MulticastSubscription ms : subscribers.getAndSet(TERMINATED)) {
if (ms.get() != Long.MIN_VALUE) {
ms.downstream.onError(ex);
}
}
}
@SuppressWarnings("unchecked")
void completeAll() {
for (MulticastSubscription ms : subscribers.getAndSet(TERMINATED)) {
if (ms.get() != Long.MIN_VALUE) {
ms.downstream.onComplete();
}
}
}
}
static final class MulticastSubscription
extends AtomicLong
implements Subscription {
private static final long serialVersionUID = 8664815189257569791L;
final Subscriber downstream;
final MulticastProcessor parent;
long emitted;
MulticastSubscription(Subscriber actual, MulticastProcessor parent) {
this.downstream = actual;
this.parent = parent;
}
@Override
public void request(long n) {
if (SubscriptionHelper.validate(n)) {
BackpressureHelper.addCancel(this, n);
parent.drain();
}
}
@Override
public void cancel() {
if (getAndSet(Long.MIN_VALUE) != Long.MIN_VALUE) {
parent.remove(this);
parent.drain(); // unblock the others
}
}
public boolean isCancelled() {
return get() == Long.MIN_VALUE;
}
}
}