cy6erGn0m

private val XFrameOptionsAttribute = AttributeKey<XFrameOptions>("X-Frame-Options")

sealed class XFrameOptions {
    object Deny : XFrameOptions() {
        override fun toString() = "deny"
    }
    object SameOrigin : XFrameOptions() {
        override fun toString() = "sameorigin"
    }
    class AllowFrom(val url: String) : XFrameOptions() {

cy6erGn0m

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import java.util.concurrent.locks.*
import kotlin.coroutines.*

private val MyEventLoop: CoroutineDispatcher = TODO()

/**
 * This is simplified blocking adapter example. 
 * NEVER use in production as it is just clarification, not actual implementation

cy6erGn0m

// Please note that you don't even need kotlin-reflect.jar

class C {
    val f: String
        get() = "ok"
}

fun usage() {
    val fn = makeFunction(C::f)
    println(fn(C()))

cy6erGn0m

fun <T : Comparable<T>> mergeSort(input: Array<T>) {
    mergeSort(input, naturalOrder())
}

fun <T> mergeSort(input: Array<T>, comparator: Comparator<T>) {
    if (input.size < 2) return
    val tempSpace = input.copyOf()

    for (windowSize in generateSequence(1) { it * 2 }.takeWhile { it < input.size }) {
        for (segment in 0 until input.size / windowSize step 2) {

cy6erGn0m

private fun <K, V> Map<K, V>.mergeReduce(other: Map<K, V>, reduce: (V, V) -> V = { a, b -> b }): Map<K, V> {
    val result = LinkedHashMap<K, V>(this.size() + other.size())
    result.putAll(this)
    other.forEach { e ->
        val existing = result[e.key]

        if (existing == null) {
            result[e.key] = e.value
        }
        else {

cy6erGn0m

fun findFreePort() = ServerSocket(0).use { it.localPort }

cy6erGn0m

import org.w3c.dom.MessageEvent
import org.w3c.dom.WebSocket
import kotlin.browser.window

class KWebSocketImpl(val url : String, val reconnectDelayMillis: Int, val listener : (dynamic) -> Unit) {
    private var currentSocket : WebSocket? = null
    private val queue = arrayListOf<String>()
    private var closed = false

    init {

cy6erGn0m

import kotlinx.cinterop.*
import org.ssh.*

fun main(): Unit = memScoped {
    val session = ssh_new() ?: return
    val port = alloc<IntVar>()
    port.value = 22
    val verbosity = alloc<UIntVar>()
    verbosity.value = SSH_LOG_PROTOCOL

cy6erGn0m

val cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
            .with(CacheManagerPersistenceConfiguration(storagePath))
            .withCache("kweetsCache",
                    CacheConfigurationBuilder.newCacheConfigurationBuilder<Int, Kweet>()
                            .withResourcePools(ResourcePoolsBuilder.newResourcePoolsBuilder()
                                    .heap(1000, EntryUnit.ENTRIES)
                                    .offheap(10, MemoryUnit.MB)
                                    .disk(100, MemoryUnit.MB, true)
                            )
                            .buildConfig(Int::class.javaObjectType, Kweet::class.java))