Creates a queue of processes that will be executed one after another by effectively preventing from executing them at the same time. This class is thread-safe.

BaseSignal

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

BaseSignal2

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

EmptyContinuation

open class EmptyContinuation(val context: CoroutineContext) : Continuation<Unit>

EventLoopExecutorService

class EventLoopExecutorService(val context: CoroutineContext) : ExecutorService

IAsyncByteArrayDeque

interface IAsyncByteArrayDeque : AsyncOutputStream, AsyncInputStream

NamedAsyncThreads

class NamedAsyncThreads(val threadFactory: () -> AsyncInvokable = { AsyncThread2() })

Prevents a named invoke to happen at the same time (by effectively enqueuing by name). This class is thread-safe.

ObservableProperty

class ObservableProperty<T>(initial: T)

PreferSyncIo

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

Promise

interface ~~Promise~~<T>

A simple interface compatible with JS Promise used for interop. In other cases just use CompletableDeferred instead.

Signal

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

Signal2

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

Properties

CIO

actual val Dispatchers.CIO: CoroutineDispatcher

expect val Dispatchers.CIO: CoroutineDispatcher

actual val Dispatchers.CIO: CoroutineDispatcher

DEBUG_ASYNC_LAUNCH_ERRORS

val DEBUG_ASYNC_LAUNCH_ERRORS: Boolean

DEFAULT_SUSPEND_TEST_TIMEOUT

val DEFAULT_SUSPEND_TEST_TIMEOUT: Duration

DEFAULT_TEST_SYNC_IO

val DEFAULT_TEST_SYNC_IO: Boolean? = false

preferSyncIo

val CoroutineContext.preferSyncIo: Boolean

ResourceDecoder

actual val Dispatchers.ResourceDecoder: CoroutineDispatcher

expect val Dispatchers.ResourceDecoder: CoroutineDispatcher

actual val Dispatchers.ResourceDecoder: CoroutineDispatcher

Functions

addCallInit

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

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

addSuspend

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

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

async

fun <T> async(context: CoroutineContext, callback: suspend () -> T): Deferred<T>

async

fun <T> CoroutineScope.async(callback: suspend () -> T): Deferred<T>

asyncAsap

fun <T> asyncAsap(context: CoroutineContext, callback: suspend () -> T): Deferred<T>

asyncAsap

fun <T> CoroutineScope.asyncAsap(callback: suspend () -> T): Deferred<T>

asyncEntryPoint

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

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

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

asyncImmediately

fun <T> asyncImmediately(context: CoroutineContext, callback: suspend () -> T): Deferred<T>

asyncImmediately

fun <T> CoroutineScope.asyncImmediately(callback: suspend () -> T): Deferred<T>

asyncTestEntryPoint

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

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

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

await

suspend fun <T> Promise<T>.~~await~~(): T

suspend fun <T> Future<T>.await(): T

chunks

suspend fun <T> ReceiveChannel<T>.chunks(count: Int): ReceiveChannel<List<T>>

delay

suspend fun CoroutineContext.delay(time: TimeSpan)

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> Deferred<T>.jvmSyncAwait(): T

launch

fun launch(context: CoroutineContext, callback: suspend () -> Unit): Job

launch

fun CoroutineScope.launch(callback: suspend () -> Unit): Job

launchAsap

fun launchAsap(context: CoroutineContext, callback: suspend () -> Unit): Job

launchAsap

fun CoroutineScope.launchAsap(callback: suspend () -> Unit): Job

launchImmediately

fun launchImmediately(context: CoroutineContext, callback: suspend () -> Unit): Job

launchImmediately

fun CoroutineScope.launchImmediately(callback: suspend () -> Unit): Job

launchUnscoped

fun CoroutineContext.launchUnscoped(block: suspend () -> Unit)

fun CoroutineScope.launchUnscoped(block: suspend () -> Unit)

launchUnscopedAndWait

suspend fun <T> CoroutineContext.launchUnscopedAndWait(block: suspend () -> T): 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..

ObservableProperty

fun <T> ObservableProperty(prop: KMutableProperty0<T>): ObservableProperty<T>

onCancel

fun CoroutineContext.onCancel(block: () -> Unit): Cancellable

produce

suspend fun <E> produce(capacity: Int = 0, block: suspend ProducerScope<E>.() -> Unit): ReceiveChannel<E>

Promise

expect fun <T> ~~Promise~~(coroutineContext: CoroutineContext = EmptyCoroutineContext, executor: (resolve: (T) -> Unit, reject: (Throwable) -> Unit) -> Unit): Promise<T>

A simple interface compatible with JS Promise used for interop. In other cases just use CompletableDeferred instead.

actual fun <T> Promise(coroutineContext: CoroutineContext, executor: (resolve: (T) -> Unit, reject: (Throwable) -> Unit) -> Unit): Promise<T>

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

SPromise

suspend fun <T> ~~SPromise~~(executor: (resolve: (T) -> Unit, reject: (Throwable) -> Unit) -> Unit): Promise<T>

suspendTest

fun suspendTest(timeout: TimeSpan? = DEFAULT_SUSPEND_TEST_TIMEOUT, preferSyncIo: Boolean? = null, callback: suspend CoroutineScope.() -> Unit): AsyncEntryPointResult

fun suspendTest(cond: () -> Boolean, timeout: TimeSpan? = DEFAULT_SUSPEND_TEST_TIMEOUT, preferSyncIo: Boolean? = DEFAULT_TEST_SYNC_IO, callback: suspend CoroutineScope.() -> Unit): AsyncEntryPointResult

suspendTestNoBrowser