korlibs-concurrent/korlibs.io.async

Package-level declarations

Types

AsyncEntryPointResult

actual typealias AsyncEntryPointResult = Unit

typealias AsyncEntryPointResult = Unit

expect class AsyncEntryPointResult

actual external class AsyncEntryPointResult

actual typealias AsyncEntryPointResult = Unit

typealias AsyncEntryPointResult = Unit

actual typealias AsyncEntryPointResult = Unit

typealias AsyncEntryPointResult = Unit

actual external class AsyncEntryPointResult

AsyncInvokable

interface AsyncInvokable

AsyncQueue

class AsyncQueue

AsyncQueueWithContext

class AsyncQueueWithContext(val queue: AsyncQueue, val context: CoroutineContext)

AsyncSignal

class AsyncSignal<T>(onRegister: () -> Unit = {}) : BaseSignal<T, suspend (T) -> Unit>

AsyncThread

class AsyncThread : AsyncInvokable

BaseSignal

abstract class BaseSignal<T, THandler>(val onRegister: () -> Unit = {})

BaseSignal2

abstract class BaseSignal2<T1, T2>(val onRegister: () -> Unit = {})

EventLoopExecutorService

class EventLoopExecutorService(val context: ERROR CLASS: Symbol not found for CoroutineContext) : ExecutorService

PreferSyncIo

data class PreferSyncIo(val preferSyncIo: Boolean) : CoroutineContext.Element

Signal

class Signal<T>(onRegister: () -> Unit = {}) : BaseSignal<T, (T) -> Unit>

Signal2

class Signal2<T1, T2>(onRegister: () -> Unit = {}) : BaseSignal2<T1, T2>

Properties

CIO

expect val Dispatchers.CIO: CoroutineDispatcher

actual val Dispatchers.CIO: CoroutineDispatcher

ConcurrencyLevel

expect val Dispatchers.ConcurrencyLevel: Int

actual val Dispatchers.ConcurrencyLevel: Int

actual val ERROR CLASS: Symbol not found for Dispatchers.ConcurrencyLevel: Int

actual val Dispatchers.ConcurrencyLevel: Int

preferSyncIo

val CoroutineContext.preferSyncIo: Boolean

ResourceDecoder

val Dispatchers.ResourceDecoder: CoroutineDispatcher

Functions

_createFixedThreadDispatcher

actual fun Dispatchers._createFixedThreadDispatcher(name: String, threadCount: Int): CoroutineDispatcher

addCallInit

fun Signal<Unit>.addCallInit(handler: (Unit) -> Unit): AutoCloseable

fun <T> Signal<T>.addCallInit(initial: T, handler: (T) -> Unit): AutoCloseable

addSuspend

suspend fun <T> Signal<T>.addSuspend(handler: suspend (T) -> Unit): AutoCloseable

fun <T> Signal<T>.addSuspend(context: CoroutineContext, handler: suspend (T) -> Unit): AutoCloseable

asyncEntryPoint

actual fun asyncEntryPoint(callback: suspend () -> Unit): AsyncEntryPointResult

expect fun asyncEntryPoint(callback: suspend () -> Unit): AsyncEntryPointResult

actual fun asyncEntryPoint(callback: suspend () -> Unit): AsyncEntryPointResult

asyncTestEntryPoint

actual fun asyncTestEntryPoint(callback: suspend () -> Unit): AsyncEntryPointResult

expect fun asyncTestEntryPoint(callback: suspend () -> Unit): AsyncEntryPointResult

actual fun asyncTestEntryPoint(callback: suspend () -> Unit): AsyncEntryPointResult

executeAndWaitAnySignal

inline suspend fun <T> Iterable<Signal<T>>.executeAndWaitAnySignal(callback: () -> Unit): Pair<Signal<T>, T>

inline suspend fun <T> Map<Signal<Unit>, T>.executeAndWaitAnySignal(callback: () -> Unit): T

executeAndWaitSignal

inline suspend fun <T> Signal<T>.executeAndWaitSignal(callback: () -> Unit): T

invoke

suspend operator fun AsyncSignal<Unit>.invoke()

operator fun Signal<Unit>.invoke()

operator fun ExecutorService.invoke(callback: () -> Unit)

invokeSuspend

suspend fun Method.invokeSuspend(obj: Any?, args: List<Any?>): Any?

jvmSyncAwait

fun <T> ERROR CLASS: Symbol not found for Deferred<T>.jvmSyncAwait(): T

mapSignal

fun <TI, TO> AsyncSignal<TI>.mapSignal(transform: (TI) -> TO): AsyncSignal<TO>

fun <TI, TO> Signal<TI>.mapSignal(transform: (TI) -> TO): Signal<TO>

noSuspend

fun <T : Any, R : Any> T.noSuspend(callback: suspend T.() -> R): R

Allows to execute a suspendable block as long as you can ensure no suspending will happen at all..

onCancel

fun CoroutineContext.onCancel(check: () -> Boolean = { true }, block: (cancelled: Boolean) -> Unit): AutoCloseable

runBlockingNoJs

actual fun <T> runBlockingNoJs(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T

expect fun <T> runBlockingNoJs(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T

actual fun <T> runBlockingNoJs(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T

runBlockingNoSuspensions

fun <T : Any> runBlockingNoSuspensions(callback: suspend () -> T): T

Allows to execute a suspendable block as long as you can ensure no suspending will happen at all..

runBlockingNoSuspensionsNullable

fun <T> runBlockingNoSuspensionsNullable(callback: suspend () -> T): T

waitOne

suspend fun <T> AsyncSignal<T>.waitOne(): T

suspend fun <T1, T2> Signal2<T1, T2>.waitOne(): Pair<T1, T2>

suspend fun <T> Signal<T>.waitOne(): T

suspend fun Iterable<Signal<*>>.waitOne(): Any?

suspend fun <T> Signal<T>.waitOne(timeout: Duration): T?

waitOneAsync

fun <T> Signal<T>.waitOneAsync(): Deferred<T>

waitOneOpt

suspend fun <T> Signal<T>.waitOneOpt(timeout: Duration?): T?

withContext

suspend fun AsyncQueue.withContext(): AsyncQueueWithContext

fun AsyncQueue.withContext(ctx: CoroutineContext): AsyncQueueWithContext

withContextNullable

suspend fun <T> withContextNullable(coroutineContext: CoroutineContext?, block: suspend () -> T): T