RxJava: Ignore some errors in a Flowable

Question

I have a Flowable<T> and errors that are subtype of IgnoreThisError I want to ignore (resulting in graceful completion), all other errors should be propagated downstream.

Kotlin example:

val f : Flowable<T> = ...
val g = f.onErrorComplete { it is IgnoreThisError }

This function onErrorComplete is what I need and does not exist...

Something like this: ```kotlin f.onErrorComplete { when (it) { is IgnoreThisError -> ... else -> throw it } } ``` — Nikita Ryanov, Apr 07 '19 at 11:55
@NickRyan The whole reason for the question is that there's no `onErrorComplete` for `Flowable`. — Alexey Romanov, Apr 07 '19 at 18:31

score 1 · Accepted Answer · answered Apr 07 '19 at 18:30

1

Something like this should work

f.onErrorResumeNext {
    if (it is IgnoreThisError)
        Flowable.empty()
    else
        Flowable.error(it)
}

I am not sure if Kotlin can infer types properly here due to overloading and Java's emulation of variance in signatures, if not you may need to be more explicit:

f.onErrorResumeNext(Function<Throwable, Publisher<T>> {
    if (it is IgnoreThisError)
        Flowable.empty()
    else
        Flowable.error(it)
})

answered Apr 07 '19 at 18:30

Alexey Romanov

167,066
35
309
487

Jepp, that’s the same solution I found. The compiler indeed went crazy without proper annotation... – user3612643 Apr 07 '19 at 18:41
Of course, if you need it more than once, you can just define `onErrorComplete` extension function. – Alexey Romanov Apr 07 '19 at 22:22
In generalized the solution in my answer. Thanks! – user3612643 Apr 08 '19 at 07:04

user3612643 · Answer 2 · 2019-04-08T15:29:00.763

1

Here is the solution for the missing onErrorComplete as an extension function:

/**
 * Errors encountered in the stream for which the provided `predicate` returns true will be silently turned into graceful completion.
 */
@CheckReturnValue
@BackpressureSupport(BackpressureKind.FULL)
@SchedulerSupport(SchedulerSupport.NONE)
inline fun <T> Flowable<T>.onErrorComplete(crossinline predicate: (Throwable) -> Boolean): Flowable<T> =
  onErrorResumeNext { error: Throwable ->
    if (predicate(error)) Flowable.empty<T>() else Flowable.error<T>(error)
  }

Note that I had to put an explicit error: Throwable ->, otherwise the compiler would complain because of the overloads of onErrorResumeNext.

edited Apr 08 '19 at 15:29

answered Apr 08 '19 at 06:52

user3612643

5,096
7
34
55

Instead of suppressing you can use a name other than `it` e.g. `error: Throwable -> ...`. `@NonNull` is also strictly speaking redundant since Kotlin will add `@org.jetbrains.annotations.NotNull` annotation. – Alexey Romanov Apr 08 '19 at 07:30
Thanks, I changed the answer. – user3612643 Apr 08 '19 at 10:44
Btw this is the underlying problem I tried to solve: https://stackoverflow.com/q/55529892/3612643 – user3612643 Apr 08 '19 at 15:28

RxJava: Ignore some errors in a Flowable

2 Answers2