eungju

import io.github.resilience4j.bulkhead.Bulkhead
import io.github.resilience4j.bulkhead.utils.BulkheadUtils
import io.grpc.CallOptions
import io.grpc.Channel
import io.grpc.ClientCall
import io.grpc.ClientInterceptor
import io.grpc.ClientInterceptors
import io.grpc.ForwardingClientCallListener
import io.grpc.Metadata
import io.grpc.MethodDescriptor

eungju

import com.athaydes.rawhttp.core.EagerBodyReader;
import com.athaydes.rawhttp.core.EagerHttpResponse;
import com.athaydes.rawhttp.core.MethodLine;
import com.athaydes.rawhttp.core.RawHttp;
import com.athaydes.rawhttp.core.RawHttpHeaders;
import com.athaydes.rawhttp.core.RawHttpRequest;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

eungju

interface CircuitBreakerMetrics {
    fun executionCompleted(name: String, latency: Double) = Unit
}

eungju

    @Test
    fun simple() {
        val observable = Observable.create<Int> { emitter ->
            emitter.onNext(1)
            emitter.onError(IOException("Timeout"))
        }
        observable
                .take(1)
                .subscribe({ assertEquals(1, it) }, { assertTrue(it is UndeliverableException) })
    }

eungju

    override fun connectDevice(userDeviceRef: UserDeviceRef, deviceAttributes: DeviceAttributes, nodeRef: PilsnerRef): Completable
            = Completable.fromRunnable {
        rwLock.write {
            devicePresences[userDeviceRef.deviceId] = Presence(userDeviceRef, deviceAttributes, nodeRef)
            userDevices.put(userDeviceRef.userId, userDeviceRef.deviceId)
        }
    }

    override fun getPresencesOfUser(userId: UserId): Single<List<Presence>>
            = Single.fromCallable {

eungju

class Http {
    data class HeaderName(val name: String) : Comparable<HeaderName> {
        override fun compareTo(other: HeaderName): Int = name.compareTo(other.name, true)

        fun get(headers: MultiMap): String? = headers.get(name)
        fun set(headers: MultiMap, value: String): Unit { headers.set(name, value) }

        fun copyIfExist(from: MultiMap, to: MultiMap) {
            get(from)?.let { set(to, it) }
        }

eungju

let

inline fun <T, R> T.let(block: (T) -> R): R = block(this)

run

inline fun <T, R> T.run(block: T.() -> R): R = block()

apply

eungju

    @Test
    fun withLatestFromCausesNoSuchElementException() {
        val state = Observable.just(42).cacheWithInitialCapacity(1)
        var error = 0
        val threads = (0..4 - 1)
                .map {
                    Thread {
                        Observable.just(Unit)
                                .withLatestFrom(state, BiFunction { _: Unit, state: Int -> state })
                                .firstOrError()

eungju

/**
 * https://github.com/ultimate-deej/FlowLayout-for-Android/blob/master/src/org/deejdev/android/FlowLayout.java
 */
public class FlowLayout extends ViewGroup {
    public static final int LEFT_TO_RIGHT = 0;
    public static final int TOP_DOWN = 1;
    public static final int RIGHT_TO_LEFT = 2;
    public static final int BOTTOM_UP = 3;

    private int mGravity;

eungju

import rx.Observable

interface RxPermission {
    val isGranted: Boolean

    fun request(): Observable<Boolean>
}