rx.lang.kotlin.observables.kt Maven / Gradle / Ivy

Go to download
package rx.lang.kotlin

import rx.Observable
import rx.Subscriber
import rx.Subscription
import rx.observables.BlockingObservable

fun  emptyObservable() : Observable = Observable.empty()
fun  observable(body : (s : Subscriber) -> Unit) : Observable = Observable.create(body)
/**
 * Create deferred observable
 * @see [rx.Observable.defer] and [http://reactivex.io/documentation/operators/defer.html]
 */
fun  deferredObservable(body : () -> Observable) : Observable = Observable.defer(body)
private fun  Iterator.toIterable() = object : Iterable {
    override fun iterator(): Iterator = this@toIterable
}

fun BooleanArray.toObservable() : Observable = this.toList().toObservable()
fun ByteArray.toObservable() : Observable = this.toList().toObservable()
fun ShortArray.toObservable() : Observable = this.toList().toObservable()
fun IntArray.toObservable() : Observable = this.toList().toObservable()
fun LongArray.toObservable() : Observable = this.toList().toObservable()
fun FloatArray.toObservable() : Observable = this.toList().toObservable()
fun DoubleArray.toObservable() : Observable = this.toList().toObservable()
fun  Array.toObservable() : Observable = Observable.from(this)

fun IntProgression.toObservable() : Observable =
        if (step == 1 && last.toLong() - first < Integer.MAX_VALUE) Observable.range(first, Math.max(0, last - first + 1))
        else Observable.from(this)

fun  Iterator.toObservable() : Observable = toIterable().toObservable()
fun  Iterable.toObservable() : Observable = Observable.from(this)
fun  Sequence.toObservable() : Observable = Observable.from(object : Iterable {
    override fun iterator(): Iterator = [email protected]()
})

fun  T.toSingletonObservable() : Observable = Observable.just(this)
fun  Throwable.toObservable() : Observable = Observable.error(this)

fun  Iterable>.merge() : Observable = Observable.merge(this.toObservable())
fun  Iterable>.mergeDelayError() : Observable = Observable.mergeDelayError(this.toObservable())


fun  Observable.fold(initial : R, body : (R, T) -> R) : Observable = reduce(initial, {a, e -> body(a, e)})
fun  Observable.onError(block : (Throwable) -> Unit) : Observable = doOnError(block)
@Suppress("BASE_WITH_NULLABLE_UPPER_BOUND") fun  Observable.firstOrNull() : Observable = firstOrDefault(null)
fun  BlockingObservable.firstOrNull() : T = firstOrDefault(null)

@Suppress("BASE_WITH_NULLABLE_UPPER_BOUND") fun  Observable.onErrorReturnNull() : Observable = onErrorReturn {null}

fun  Observable.lift(operator : (Subscriber) -> Subscriber) : Observable = lift { t1 -> operator(t1!!) }

/**
 * Returns [Observable] that requires all objects to be non null. Raising [NullPointerException] in case of null object
 */
fun  Observable.requireNoNulls() : Observable = map { it ?: throw NullPointerException("null element found in rx observable") }

/**
 * Returns [Observable] with non-null generic type T. Returned observable filter out null values
 */
@Suppress("CAST_NEVER_SUCCEEDS") fun  Observable.filterNotNull(): Observable = filter { it != null } as Observable

/**
 * Returns Observable that wrap all values into [IndexedValue] and populates corresponding index value.
 * Works similar to [kotlin.withIndex]
 */
fun  Observable.withIndex() : Observable> =
        zipWith(Observable.range(0, Int.MAX_VALUE)) { value, index -> IndexedValue(index,value) }

/**
 * Returns Observable that emits objects from kotlin [Sequence] returned by function you provided by parameter [body] for
 * each input object and merges all produced elements into one observable.
 * Works similar to [Observable.flatMap] and [Observable.flatMapIterable] but with [Sequence]
 *
 * @param body is a function that applied for each item emitted by source observable that returns [Sequence]
 *  @returns Observable that merges all [Sequence]s produced by [body] functions
 */
fun  Observable.flatMapSequence( body : (T) -> Sequence ) : Observable = flatMap { body(it).toObservable() }

/**
 * Subscribe with a subscriber that is configured inside body
 */
inline fun  Observable.subscribeWith( body : FunctionSubscriberModifier.() -> Unit ) : Subscription {
    val modifier = FunctionSubscriberModifier(subscriber())
    modifier.body()
    return subscribe(modifier.subscriber)
}

fun  Observable>.switchOnNext(): Observable = Observable.switchOnNext(this)

/**
 * Observable.combineLatest(List> sources, FuncN combineFunction)
 */
@Suppress("UNCHECKED_CAST")
fun  List>.combineLatest(combineFunction: (args: List) -> R): Observable =
        Observable.combineLatest(this, { combineFunction(it.asList() as List) })

/**
 * Observable.zip(List> sources, FuncN combineFunction)
 */
@Suppress("UNCHECKED_CAST")
fun  List>.zip(zipFunction: (args: List) -> R): Observable =
        Observable.zip(this, { zipFunction(it.asList() as List) })

/**
 * Returns an Observable that emits the items emitted by the source Observable, converted to the specified type.
 */
inline fun  Observable<*>.cast(): Observable = cast(R::class.java)