RxJava - Opposite of switchMap() Operator?

Question

I am wondering if there is a way to compose existing operators to perform the opposite of a switchMap().

The switchMap() will chase after the latest emission it receives and cancel any Observable it previously was executing. Let's say I flipped it, and I want to ignore all emissions coming to a xxxMap() operator while it is busy with the first emission it received. It will keep ignoring emissions until it finishes emitting the current Observable inside of it. Then it will process the next emission it receives.

Observable.interval(1, TimeUnit.SECONDS)
        .doOnNext(i -> System.out.println("Source Emitted Value: " + i))
        .ignoreWhileBusyMap(i -> doIntensiveProcess(i).subcribeOn(Schedulers.computation())) 
        .subscribe(i -> System.out.println("Subscriber received Value: " + i));

Is there a way to accomplish this? In the above example, if intensiveProcess() were to last three seconds, the ignoreWhileBusyMap() would process 0 but likely ignore emissions 1 and 2 coming from interval().It would then process 3 but likely ignore 4 and 5, and so on...

Answer 1

Sure, gate the processing of a value by a boolean that is set after the processing finished:

AtomicBoolean gate = new AtomicBoolean(true);

Observable.interval(200, TimeUnit.MILLISECONDS)
.flatMap(v -> {
    if (gate.get()) {
        gate.set(false);

        return Observable.just(v).delay(500, TimeUnit.MILLISECONDS)
                .doAfterTerminate(() -> gate.set(true));
    } else {
        return Observable.empty();
    }
})
.take(10)
.toBlocking()
.subscribe(System.out::println, Throwable::printStackTrace);

Edit

Alternative:

Observable.interval(200, TimeUnit.MILLISECONDS)
.onBackpressureDrop()
.flatMap(v -> {
    return Observable.just(v).delay(500, TimeUnit.MILLISECONDS);
}, 1)
.take(10)
.toBlocking()
.subscribe(System.out::println, Throwable::printStackTrace);

You can change onBackpressureDrop to onBackpressureLatest to continue immediately with the latest value.