io.reactivex.observable.internal.operators.ObservableGenerate 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.concurrent.Callable;
import io.reactivex.common.*;
import io.reactivex.common.exceptions.Exceptions;
import io.reactivex.common.functions.*;
import io.reactivex.observable.*;
import io.reactivex.observable.internal.disposables.EmptyDisposable;
public final class ObservableGenerate extends Observable {
final Callable stateSupplier;
final BiFunction, S> generator;
final Consumer disposeState;
public ObservableGenerate(Callable stateSupplier, BiFunction, S> generator,
Consumer disposeState) {
this.stateSupplier = stateSupplier;
this.generator = generator;
this.disposeState = disposeState;
}
@Override
public void subscribeActual(Observer s) {
S state;
try {
state = stateSupplier.call();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
EmptyDisposable.error(e, s);
return;
}
GeneratorDisposable gd = new GeneratorDisposable(s, generator, disposeState, state);
s.onSubscribe(gd);
gd.run();
}
static final class GeneratorDisposable
implements Emitter, Disposable {
final Observer actual;
final BiFunction, S> generator;
final Consumer disposeState;
S state;
volatile boolean cancelled;
boolean terminate;
boolean hasNext;
GeneratorDisposable(Observer actual,
BiFunction, S> generator,
Consumer disposeState, S initialState) {
this.actual = actual;
this.generator = generator;
this.disposeState = disposeState;
this.state = initialState;
}
public void run() {
S s = state;
if (cancelled) {
state = null;
dispose(s);
return;
}
final BiFunction, S> f = generator;
for (;;) {
if (cancelled) {
state = null;
dispose(s);
return;
}
hasNext = false;
try {
s = f.apply(s, this);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
state = null;
cancelled = true;
onError(ex);
dispose(s);
return;
}
if (terminate) {
cancelled = true;
state = null;
dispose(s);
return;
}
}
}
private void dispose(S s) {
try {
disposeState.accept(s);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
RxJavaCommonPlugins.onError(ex);
}
}
@Override
public void dispose() {
cancelled = true;
}
@Override
public boolean isDisposed() {
return cancelled;
}
@Override
public void onNext(T t) {
if (!terminate) {
if (hasNext) {
onError(new IllegalStateException("onNext already called in this generate turn"));
} else {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
} else {
hasNext = true;
actual.onNext(t);
}
}
}
}
@Override
public void onError(Throwable t) {
if (terminate) {
RxJavaCommonPlugins.onError(t);
} else {
if (t == null) {
t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
terminate = true;
actual.onError(t);
}
}
@Override
public void onComplete() {
if (!terminate) {
terminate = true;
actual.onComplete();
}
}
}
}