io.reactivex.observable.internal.operators.ObservableConcatMapEager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of rxjava3-observable Show documentation
Show all versions of rxjava3-observable Show documentation
rxjava3-observable developed by David Karnok
The newest version!
/**
* 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.observable.internal.operators;
import java.util.ArrayDeque;
import java.util.concurrent.atomic.AtomicInteger;
import io.reactivex.common.*;
import io.reactivex.common.exceptions.Exceptions;
import io.reactivex.common.functions.Function;
import io.reactivex.common.internal.disposables.DisposableHelper;
import io.reactivex.common.internal.functions.ObjectHelper;
import io.reactivex.common.internal.utils.AtomicThrowable;
import io.reactivex.observable.*;
import io.reactivex.observable.extensions.*;
import io.reactivex.observable.internal.observers.*;
import io.reactivex.observable.internal.utils.QueueDrainHelper;
public final class ObservableConcatMapEager extends AbstractObservableWithUpstream {
final Function> mapper;
final ErrorMode errorMode;
final int maxConcurrency;
final int prefetch;
public ObservableConcatMapEager(ObservableSource source,
Function> mapper,
ErrorMode errorMode,
int maxConcurrency, int prefetch) {
super(source);
this.mapper = mapper;
this.errorMode = errorMode;
this.maxConcurrency = maxConcurrency;
this.prefetch = prefetch;
}
@Override
protected void subscribeActual(Observer observer) {
source.subscribe(new ConcatMapEagerMainObserver(observer, mapper, maxConcurrency, prefetch, errorMode));
}
static final class ConcatMapEagerMainObserver
extends AtomicInteger
implements Observer, Disposable, InnerQueuedObserverSupport {
private static final long serialVersionUID = 8080567949447303262L;
final Observer actual;
final Function> mapper;
final int maxConcurrency;
final int prefetch;
final ErrorMode errorMode;
final AtomicThrowable error;
final ArrayDeque> observers;
SimpleQueue queue;
Disposable d;
volatile boolean done;
int sourceMode;
volatile boolean cancelled;
InnerQueuedObserver current;
int activeCount;
ConcatMapEagerMainObserver(Observer actual,
Function> mapper,
int maxConcurrency, int prefetch, ErrorMode errorMode) {
this.actual = actual;
this.mapper = mapper;
this.maxConcurrency = maxConcurrency;
this.prefetch = prefetch;
this.errorMode = errorMode;
this.error = new AtomicThrowable();
this.observers = new ArrayDeque>();
}
@SuppressWarnings("unchecked")
@Override
public void onSubscribe(Disposable d) {
if (DisposableHelper.validate(this.d, d)) {
this.d = d;
if (d instanceof QueueDisposable) {
QueueDisposable qd = (QueueDisposable) d;
int m = qd.requestFusion(QueueDisposable.ANY);
if (m == QueueDisposable.SYNC) {
sourceMode = m;
queue = qd;
done = true;
actual.onSubscribe(this);
drain();
return;
}
if (m == QueueDisposable.ASYNC) {
sourceMode = m;
queue = qd;
actual.onSubscribe(this);
return;
}
}
queue = QueueDrainHelper.createQueue(prefetch);
actual.onSubscribe(this);
}
}
@Override
public void onNext(T value) {
if (sourceMode == QueueDisposable.NONE) {
queue.offer(value);
}
drain();
}
@Override
public void onError(Throwable e) {
if (error.addThrowable(e)) {
done = true;
drain();
} else {
RxJavaCommonPlugins.onError(e);
}
}
@Override
public void onComplete() {
done = true;
drain();
}
@Override
public void dispose() {
cancelled = true;
if (getAndIncrement() == 0) {
queue.clear();
disposeAll();
}
}
@Override
public boolean isDisposed() {
return cancelled;
}
void disposeAll() {
InnerQueuedObserver inner = current;
if (inner != null) {
inner.dispose();
}
for (;;) {
inner = observers.poll();
if (inner == null) {
return;
}
inner.dispose();
}
}
@Override
public void innerNext(InnerQueuedObserver inner, R value) {
inner.queue().offer(value);
drain();
}
@Override
public void innerError(InnerQueuedObserver inner, Throwable e) {
if (error.addThrowable(e)) {
if (errorMode == ErrorMode.IMMEDIATE) {
d.dispose();
}
inner.setDone();
drain();
} else {
RxJavaCommonPlugins.onError(e);
}
}
@Override
public void innerComplete(InnerQueuedObserver inner) {
inner.setDone();
drain();
}
@Override
public void drain() {
if (getAndIncrement() != 0) {
return;
}
int missed = 1;
SimpleQueue q = queue;
ArrayDeque> observers = this.observers;
Observer a = this.actual;
ErrorMode errorMode = this.errorMode;
outer:
for (;;) {
int ac = activeCount;
while (ac != maxConcurrency) {
if (cancelled) {
q.clear();
disposeAll();
return;
}
if (errorMode == ErrorMode.IMMEDIATE) {
Throwable ex = error.get();
if (ex != null) {
q.clear();
disposeAll();
a.onError(error.terminate());
return;
}
}
T v;
ObservableSource source;
try {
v = q.poll();
if (v == null) {
break;
}
source = ObjectHelper.requireNonNull(mapper.apply(v), "The mapper returned a null ObservableSource");
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
d.dispose();
q.clear();
disposeAll();
error.addThrowable(ex);
a.onError(error.terminate());
return;
}
InnerQueuedObserver inner = new InnerQueuedObserver(this, prefetch);
observers.offer(inner);
source.subscribe(inner);
ac++;
}
activeCount = ac;
if (cancelled) {
q.clear();
disposeAll();
return;
}
if (errorMode == ErrorMode.IMMEDIATE) {
Throwable ex = error.get();
if (ex != null) {
q.clear();
disposeAll();
a.onError(error.terminate());
return;
}
}
InnerQueuedObserver active = current;
if (active == null) {
if (errorMode == ErrorMode.BOUNDARY) {
Throwable ex = error.get();
if (ex != null) {
q.clear();
disposeAll();
a.onError(error.terminate());
return;
}
}
boolean d = done;
active = observers.poll();
boolean empty = active == null;
if (d && empty) {
Throwable ex = error.get();
if (ex != null) {
q.clear();
disposeAll();
a.onError(error.terminate());
} else {
a.onComplete();
}
return;
}
if (!empty) {
current = active;
}
}
if (active != null) {
SimpleQueue aq = active.queue();
for (;;) {
if (cancelled) {
q.clear();
disposeAll();
return;
}
boolean d = active.isDone();
if (errorMode == ErrorMode.IMMEDIATE) {
Throwable ex = error.get();
if (ex != null) {
q.clear();
disposeAll();
a.onError(error.terminate());
return;
}
}
R w;
try {
w = aq.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
error.addThrowable(ex);
current = null;
activeCount--;
continue outer;
}
boolean empty = w == null;
if (d && empty) {
current = null;
activeCount--;
continue outer;
}
if (empty) {
break;
}
a.onNext(w);
}
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
}
}