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

Go to download
package rx.lang.kotlin

import rx.SingleSubscriber
import rx.Subscriber
import rx.exceptions.OnErrorNotImplementedException
import rx.observers.SerializedSubscriber
import rx.subscriptions.Subscriptions
import java.util.*

class FunctionSubscriber() : Subscriber() {
    private val onCompletedFunctions = ArrayList<() -> Unit>()
    private val onErrorFunctions = ArrayList<(e: Throwable) -> Unit>()
    private val onNextFunctions = ArrayList<(value: T) -> Unit>()
    private val onStartFunctions = ArrayList<() -> Unit>()

    override fun onCompleted() = onCompletedFunctions.forEach { it() }

    override fun onError(e: Throwable?) = (e ?: RuntimeException("exception is unknown")).let { ex ->
        if (onErrorFunctions.isEmpty()) {
            throw OnErrorNotImplementedException(ex)
        } else {
            onErrorFunctions.forEach { it(ex) }
        }
    }

    override fun onNext(t: T) = onNextFunctions.forEach { it(t) }

    override fun onStart() = onStartFunctions.forEach { it() }

    fun onCompleted(onCompletedFunction: () -> Unit): FunctionSubscriber = copy { onCompletedFunctions.add(onCompletedFunction) }
    fun onError(onErrorFunction: (t: Throwable) -> Unit): FunctionSubscriber = copy { onErrorFunctions.add(onErrorFunction) }
    fun onNext(onNextFunction: (t: T) -> Unit): FunctionSubscriber = copy { onNextFunctions.add(onNextFunction) }
    fun onStart(onStartFunction : () -> Unit) : FunctionSubscriber = copy { onStartFunctions.add(onStartFunction) }

    private fun copy(block: FunctionSubscriber.() -> Unit): FunctionSubscriber {
        val newSubscriber = FunctionSubscriber()
        newSubscriber.onCompletedFunctions.addAll(onCompletedFunctions)
        newSubscriber.onErrorFunctions.addAll(onErrorFunctions)
        newSubscriber.onNextFunctions.addAll(onNextFunctions)
        newSubscriber.onStartFunctions.addAll(onStartFunctions)

        newSubscriber.block()

        return newSubscriber
    }
}

class FunctionSingleSubscriber() : SingleSubscriber() {
    private val onSuccessFunctions = ArrayList<(value: T) -> Unit>()
    private val onErrorFunctions = ArrayList<(e: Throwable) -> Unit>()

    override fun onSuccess(t: T) = onSuccessFunctions.forEach { it(t) }

    override fun onError(e: Throwable?) = (e ?: RuntimeException("exception is unknown")).let { ex ->
        if (onErrorFunctions.isEmpty()) {
            throw OnErrorNotImplementedException(ex)
        } else {
            onErrorFunctions.forEach { it(ex) }
        }
    }

    fun onSuccess(onSuccessFunction: (t: T) -> Unit): FunctionSingleSubscriber = copy { onSuccessFunctions.add(onSuccessFunction) }
    fun onError(onErrorFunction: (e: Throwable) -> Unit): FunctionSingleSubscriber = copy { onErrorFunctions.add(onErrorFunction) }

    private fun copy(block: FunctionSingleSubscriber.() -> Unit): FunctionSingleSubscriber {
        val newSubscriber = FunctionSingleSubscriber()
        newSubscriber.onSuccessFunctions.addAll(onSuccessFunctions)
        newSubscriber.onErrorFunctions.addAll(onErrorFunctions)

        newSubscriber.block()

        return newSubscriber
    }
}

class FunctionSubscriberModifier(init: FunctionSubscriber = subscriber()) {
    var subscriber: FunctionSubscriber = init
        private set

    fun onCompleted(onCompletedFunction: () -> Unit) : Unit { subscriber = subscriber.onCompleted(onCompletedFunction) }
    fun onError(onErrorFunction: (t : Throwable) -> Unit) : Unit { subscriber = subscriber.onError(onErrorFunction) }
    fun onNext(onNextFunction: (t : T) -> Unit) : Unit { subscriber = subscriber.onNext(onNextFunction) }
    fun onStart(onStartFunction : () -> Unit) : Unit { subscriber = subscriber.onStart(onStartFunction) }
}

class FunctionSingleSubscriberModifier(init: FunctionSingleSubscriber = singleSubscriber()) {
    var subscriber: FunctionSingleSubscriber = init
        private set

    fun onSuccess(onSuccessFunction: (t: T) -> Unit): Unit { subscriber = subscriber.onSuccess(onSuccessFunction) }
    fun onError(onErrorFunction: (r: Throwable) -> Unit): Unit {subscriber = subscriber.onError(onErrorFunction) }
}

fun  subscriber(): FunctionSubscriber = FunctionSubscriber()
fun  singleSubscriber(): FunctionSingleSubscriber = FunctionSingleSubscriber()
fun  Subscriber.synchronized(): Subscriber = SerializedSubscriber(this)
fun Subscriber<*>.add(action: () -> Unit) = add(Subscriptions.create(action))