rx.internal.operators.OperatorScan Maven / Gradle / Ivy
Show all versions of rxjava-core Show documentation
/**
* Copyright 2014 Netflix, Inc.
*
* 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 rx.internal.operators;
import java.util.concurrent.atomic.AtomicBoolean;
import rx.Observable.Operator;
import rx.Producer;
import rx.Subscriber;
import rx.exceptions.OnErrorThrowable;
import rx.functions.Func2;
/**
* Returns an Observable that applies a function to the first item emitted by a source Observable, then feeds
* the result of that function along with the second item emitted by an Observable into the same function, and
* so on until all items have been emitted by the source Observable, emitting the result of each of these
* iterations.
*
* 
*
* This sort of function is sometimes called an accumulator.
*
* Note that when you pass a seed to {@code scan} the resulting Observable will emit that seed as its
* first emitted item.
*/
public final class OperatorScan implements Operator {
private final R initialValue;
private final Func2 accumulator;
// sentinel if we don't receive an initial value
private static final Object NO_INITIAL_VALUE = new Object();
/**
* Applies an accumulator function over an observable sequence and returns each intermediate result with the
* specified source and accumulator.
*
* @param initialValue
* the initial (seed) accumulator value
* @param accumulator
* an accumulator function to be invoked on each element from the sequence
* @see Observable.Scan(TSource, TAccumulate) Method (IObservable(TSource), TAccumulate, Func(TAccumulate, TSource,
* TAccumulate))
*/
public OperatorScan(R initialValue, Func2 accumulator) {
this.initialValue = initialValue;
this.accumulator = accumulator;
}
/**
* Applies an accumulator function over an observable sequence and returns each intermediate result with the
* specified source and accumulator.
*
* @param accumulator
* an accumulator function to be invoked on each element from the sequence
* @see Observable.Scan(TSource) Method (IObservable(TSource), Func(TSource, TSource, TSource))
*/
@SuppressWarnings("unchecked")
public OperatorScan(final Func2 accumulator) {
this((R) NO_INITIAL_VALUE, accumulator);
}
@Override
public Subscriber call(final Subscriber child) {
return new Subscriber(child) {
private R value = initialValue;
boolean initialized = false;
@SuppressWarnings("unchecked")
@Override
public void onNext(T currentValue) {
emitInitialValueIfNeeded(child);
if (this.value == NO_INITIAL_VALUE) {
// if there is NO_INITIAL_VALUE then we know it is type T for both so cast T to R
this.value = (R) currentValue;
} else {
try {
this.value = accumulator.call(this.value, currentValue);
} catch (Throwable e) {
child.onError(OnErrorThrowable.addValueAsLastCause(e, currentValue));
}
}
child.onNext(this.value);
}
@Override
public void onError(Throwable e) {
child.onError(e);
}
@Override
public void onCompleted() {
emitInitialValueIfNeeded(child);
child.onCompleted();
}
private void emitInitialValueIfNeeded(final Subscriber child) {
if (!initialized) {
initialized = true;
// we emit first time through if we have an initial value
if (initialValue != NO_INITIAL_VALUE) {
child.onNext(initialValue);
}
}
}
/**
* We want to adjust the requested value by subtracting 1 if we have an initial value
*/
@Override
public void setProducer(final Producer producer) {
child.setProducer(new Producer() {
final AtomicBoolean once = new AtomicBoolean();
@Override
public void request(long n) {
if (once.compareAndSet(false, true)) {
if (initialValue == NO_INITIAL_VALUE || n == Long.MAX_VALUE) {
producer.request(n);
} else {
producer.request(n - 1);
}
} else {
// pass-thru after first time
producer.request(n);
}
}
});
}
};
}
}