Index

A B C D E F G H I J K L M N O P R S T U W Y Z

A

AbstractChannel<E> - Class in kotlinx.coroutines.channels: Abstract send/receive channel. It is a base class for all channel implementations.
AbstractChannel() - Constructor for class kotlinx.coroutines.channels.AbstractChannel: Abstract send/receive channel. It is a base class for all channel implementations.
AbstractChannelKt - Class in kotlinx.coroutines.channels
AbstractContinuationKt - Class in kotlinx.coroutines
AbstractCoroutine<T> - Class in kotlinx.coroutines: Abstract base class for implementation of coroutines in coroutine builders.
AbstractCoroutine(parentContext, active) - Constructor for class kotlinx.coroutines.AbstractCoroutine: Abstract base class for implementation of coroutines in coroutine builders.
AbstractSendChannel<E> - Class in kotlinx.coroutines.channels: Abstract send channel. It is a base class for all send channel implementations.
AbstractSendChannel() - Constructor for class kotlinx.coroutines.channels.AbstractSendChannel: Abstract send channel. It is a base class for all send channel implementations.
actor(context, capacity, start, parent, onCompletion, block) - Static method in class kotlinx.coroutines.channels.ActorKt: Launches new coroutine that is receiving messages from its mailbox channel and returns a reference to its mailbox channel as a interface SendChannel. The resulting object can be used to SendChannel.send messages to this coroutine.
ActorKt - Class in kotlinx.coroutines.channels
ActorScope<E> - Interface in kotlinx.coroutines.channels: Scope for ActorKt.actor coroutine builder.
advanceTimeBy(delayTime, unit) - Method in class kotlinx.coroutines.test.TestCoroutineContext: Moves the CoroutineContext's virtual clock forward by a specified amount of time.
advanceTimeTo(targetTime, unit) - Method in class kotlinx.coroutines.test.TestCoroutineContext: Moves the CoroutineContext's clock-time to a particular moment in time.
afterClose(cause) - Method in class kotlinx.coroutines.channels.AbstractSendChannel: Invoked after successful AbstractSendChannel.close.
any($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns true if channel has at least one element.
ArrayBroadcastChannel<E> - Class in kotlinx.coroutines.channels: Broadcast channel with array buffer of a fixed capacity. Sender suspends only when buffer is full due to one of the receives being slow to consume and receiver suspends only when buffer is empty.
ArrayBroadcastChannel(capacity) - Constructor for class kotlinx.coroutines.channels.ArrayBroadcastChannel: Broadcast channel with array buffer of a fixed capacity. Sender suspends only when buffer is full due to one of the receives being slow to consume and receiver suspends only when buffer is empty.
ArrayChannel<E> - Class in kotlinx.coroutines.channels: Channel with array buffer of a fixed capacity. Sender suspends only when buffer is fully and receiver suspends only when buffer is empty.
ArrayChannel(capacity) - Constructor for class kotlinx.coroutines.channels.ArrayChannel: Channel with array buffer of a fixed capacity. Sender suspends only when buffer is fully and receiver suspends only when buffer is empty.
asContextElement($receiver, value) - Static method in class kotlinx.coroutines.ThreadContextElementKt: Wraps ThreadLocal into interface ThreadContextElement. The resulting interface ThreadContextElement maintains the given value of the given ThreadLocal for coroutine regardless of the actual thread its is resumed on. By default ThreadLocal.get is used as a value for the thread-local variable, but it can be overridden with value parameter.
asCoroutineDispatcher($receiver) - Static method in class kotlinx.coroutines.ExecutorsKt: Converts an instance of ExecutorService to an implementation of class ExecutorCoroutineDispatcher.
asCoroutineDispatcher($receiver) - Static method in class kotlinx.coroutines.ExecutorsKt: Converts an instance of Executor to an implementation of class CoroutineDispatcher.
asReceiveChannel($receiver, context) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel to read all element of the Iterable.
asReceiveChannel($receiver, context) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel to read all element of the Sequence.
assertAllUnhandledExceptions(message, predicate) - Method in class kotlinx.coroutines.test.TestCoroutineContext: This method does nothing if there are no unhandled exceptions or all of them satisfy the given predicate. Otherwise it throws an AssertionError with the given message.
assertAnyUnhandledException(message, predicate) - Method in class kotlinx.coroutines.test.TestCoroutineContext: This method does nothing if one or more unhandled exceptions satisfy the given predicate. Otherwise it throws an AssertionError with the given message.
assertExceptions(message, predicate) - Method in class kotlinx.coroutines.test.TestCoroutineContext: This method does nothing if the list of unhandled exceptions satisfy the given predicate. Otherwise it throws an AssertionError with the given message.
assertUnhandledException(message, predicate) - Method in class kotlinx.coroutines.test.TestCoroutineContext: This method does nothing if there is one unhandled exception that satisfies the given predicate. Otherwise it throws an AssertionError with the given message.
async(context, start, parent, onCompletion, block) - Static method in class kotlinx.coroutines.DeferredKt: Creates new coroutine and returns its future result as an implementation of interface Deferred.
attachChild(child) - Method in class kotlinx.coroutines.NonCancellable: Always returns class NonDisposableHandle and does not do anything.
await(p) - Method in interface kotlinx.coroutines.Deferred: Awaits for completion of this value without blocking a thread and resumes when deferred computation is complete, returning the resulting value or throwing the corresponding exception if the deferred had completed exceptionally or was cancelled.
awaitAll(deferreds, p) - Static method in class kotlinx.coroutines.AwaitKt: Awaits for completion of given deferred values without blocking a thread and resumes normally with the list of values when all deferred computations are complete or resumes with the first thrown exception if any of computations complete exceptionally including cancellation.
awaitAll($receiver, p) - Static method in class kotlinx.coroutines.AwaitKt: Awaits for completion of given deferred values without blocking a thread and resumes normally with the list of values when all deferred computations are complete or resumes with the first thrown exception if any of computations complete exceptionally including cancellation.
AwaitKt - Class in kotlinx.coroutines

B

broadcast($receiver, capacity, start) - Static method in class kotlinx.coroutines.channels.BroadcastKt: Broadcasts all elements of the channel.
broadcast(context, capacity, start, parent, onCompletion, block) - Static method in class kotlinx.coroutines.channels.BroadcastKt: Launches new coroutine to produce a stream of values by sending them to a broadcast channel and returns a reference to the coroutine as a interface BroadcastChannel. The resulting object can be used to BroadcastChannel.openSubscription to elements produced by this coroutine.
BroadcastChannel<E> - Interface in kotlinx.coroutines.channels: Broadcast channel is a non-blocking primitive for communication between the sender and multiple receivers that subscribe for the elements using BroadcastChannel.openSubscription function and unsubscribe using ReceiveChannel.cancel function.
BroadcastChannel(capacity) - Static method in class kotlinx.coroutines.channels.BroadcastChannelKt: Creates a broadcast channel with the specified buffer capacity.
BroadcastChannel.DefaultImpls - Class in kotlinx.coroutines.channels: Broadcast channel is a non-blocking primitive for communication between the sender and multiple receivers that subscribe for the elements using BroadcastChannel.openSubscription function and unsubscribe using ReceiveChannel.cancel function.
BroadcastChannelKt - Class in kotlinx.coroutines.channels
BroadcastKt - Class in kotlinx.coroutines.channels
BuildersKt - Class in kotlinx.coroutines

C

cancel(cause) - Method in interface kotlinx.coroutines.CancellableContinuation: Cancels this continuation with an optional cancellation cause. The result is true if this continuation was cancelled as a result of this invocation and false otherwise.
cancel(cause) - Method in class kotlinx.coroutines.channels.AbstractChannel: Cancels reception of remaining elements from this channel. This function closes the channel with the specified cause (unless it was already closed) and removes all buffered sent elements from it. This function returns true if the channel was not closed previously, or false otherwise.
cancel(cause) - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel: Cancels reception of remaining elements from this channel. This function closes the channel with the specified cause (unless it was already closed), removes all buffered sent elements from it, and ReceiveChannel.cancel all open subscriptions. This function returns true if the channel was not closed previously, or false otherwise.
cancel(cause) - Method in interface kotlinx.coroutines.channels.BroadcastChannel: Cancels reception of remaining elements from this channel. This function closes the channel with the specified cause (unless it was already closed), removes all buffered sent elements from it, and ReceiveChannel.cancel all open subscriptions. This function returns true if the channel was not closed previously, or false otherwise.
cancel(cause) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Closes this broadcast channel. Same as ConflatedBroadcastChannel.close.
cancel(cause) - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Cancels reception of remaining elements from this channel. This function closes the channel with the specified cause (unless it was already closed) and removes all buffered sent elements from it. This function returns true if the channel was not closed previously, or false otherwise.
cancel(cause) - Method in interface kotlinx.coroutines.Job: Cancels this job with an optional cancellation cause. The result is true if this job was either cancelled as a result of this invocation or it's being cancelled and given cause was successfully received by the job and will be properly handled, false otherwise.
cancel($receiver, cause) - Static method in class kotlinx.coroutines.JobKt: Cancels interface Job of this context with an optional cancellation cause. The result is true if the job was cancelled as a result of this invocation and false if there is no job in the context or if it was already cancelled or completed. See Job.cancel for details.
cancel(cause) - Method in class kotlinx.coroutines.NonCancellable: Always returns false.
cancelAllActions() - Method in class kotlinx.coroutines.test.TestCoroutineContext: Cancels all not yet triggered actions. Be careful calling this, since it can seriously mess with your coroutines work. This method should usually be called on tear-down of a unit test.
cancelAndJoin($receiver, p) - Static method in class kotlinx.coroutines.JobKt: Cancels the job and suspends invoking coroutine until the cancelled job is complete.
cancelChildren($receiver, cause) - Static method in class kotlinx.coroutines.JobKt: Cancels all children of the interface Job in this context with an optional cancellation cause. It does not do anything if there is no job in the context or it has no children. See Job.cancelChildren for details.
cancelChildren($receiver, cause) - Static method in class kotlinx.coroutines.JobKt: Cancels all Job.getChildren jobs of this coroutine with the given cause using Job.cancel for all of them. Unlike Job.cancel on this job as a whole, the state of this job itself is not affected.
cancelFutureOnCancellation($receiver, future) - Static method in class kotlinx.coroutines.JobKt: Cancels a specified future when this job is cancelled. This is a shortcut for the following code with slightly more efficient implementation (one fewer object created).
cancelFutureOnCompletion($receiver, future) - Static method in class kotlinx.coroutines.JobKt: Deprecated.
cancelFutureOnCompletion($receiver, future) - Static method in class kotlinx.coroutines.JobKt: Cancels a specified future when this job is cancelled. This is a shortcut for the following code with slightly more efficient implementation (one fewer object created).
CancellableContinuation<T> - Interface in kotlinx.coroutines: Cancellable continuation. It is completed when it is resumed or cancelled. When CancellableContinuation.cancel function is explicitly invoked, this continuation immediately resumes with CancellationException or with the specified cancel cause.
CancellableContinuationKt - Class in kotlinx.coroutines
CancellableKt - Class in kotlinx.coroutines.intrinsics
Channel<E> - Interface in kotlinx.coroutines.channels: Channel is a non-blocking primitive for communication between sender using interface SendChannel and receiver using interface ReceiveChannel. Conceptually, a channel is similar to BlockingQueue, but it has suspending operations instead of blocking ones and it can be closed.
Channel() - Static method in class kotlinx.coroutines.channels.ChannelKt: Creates a channel without a buffer -- class RendezvousChannel.
Channel(capacity) - Static method in class kotlinx.coroutines.channels.ChannelKt: Creates a channel with the specified buffer capacity (or without a buffer by default).
Channel.Factory - Class in kotlinx.coroutines.channels: Constants for channel factory function Channel().
ChannelIterator<E> - Interface in kotlinx.coroutines.channels: Iterator for interface ReceiveChannel. Instances of this interface are not thread-safe and shall not be used from concurrent coroutines.
ChannelKt - Class in kotlinx.coroutines.channels
ChannelsKt - Class in kotlinx.coroutines.channels
cleanupSendQueueOnCancel() - Method in class kotlinx.coroutines.channels.AbstractChannel
cleanupSendQueueOnCancel() - Method in class kotlinx.coroutines.channels.ArrayChannel
close(cause) - Method in class kotlinx.coroutines.channels.AbstractSendChannel: Closes this channel with an optional exceptional cause. This is an idempotent operation -- repeated invocations of this function have no effect and return false. Conceptually, its sends a special "close token" over this channel.
close(cause) - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel: Closes this channel with an optional exceptional cause. This is an idempotent operation -- repeated invocations of this function have no effect and return false. Conceptually, its sends a special "close token" over this channel.
close(cause) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Closes this channel with an optional exceptional cause. This is an idempotent operation -- repeated invocations of this function have no effect and return false. Conceptually, its sends a special "close token" over this channel.
close(cause) - Method in interface kotlinx.coroutines.channels.SendChannel: Closes this channel with an optional exceptional cause. This is an idempotent operation -- repeated invocations of this function have no effect and return false. Conceptually, its sends a special "close token" over this channel.
close() - Method in interface kotlinx.coroutines.channels.SubscriptionReceiveChannel: Deprecated.
close($this) - Static method in class kotlinx.coroutines.channels.SubscriptionReceiveChannel.DefaultImpls: Deprecated.
close() - Method in class kotlinx.coroutines.CommonPool
close() - Method in class kotlinx.coroutines.ThreadPoolDispatcher: Closes this dispatcher -- shuts down all threads in this pool and releases resources.
CLOSED - Static variable in class kotlinx.coroutines.channels.ConflatedBroadcastChannel
ClosedReceiveChannelException - Exception in kotlinx.coroutines.channels: Indicates attempt to ReceiveChannel.receive on ReceiveChannel.isClosedForReceive channel that was closed without a cause. A failed channel rethrows the original SendChannel.close cause exception on receive attempts.
ClosedReceiveChannelException(message) - Constructor for exception kotlinx.coroutines.channels.ClosedReceiveChannelException: Indicates attempt to ReceiveChannel.receive on ReceiveChannel.isClosedForReceive channel that was closed without a cause. A failed channel rethrows the original SendChannel.close cause exception on receive attempts.
ClosedSendChannelException - Exception in kotlinx.coroutines.channels: Indicates attempt to SendChannel.send on SendChannel.isClosedForSend channel that was closed without a cause. A failed channel rethrows the original SendChannel.close cause exception on send attempts.
ClosedSendChannelException(message) - Constructor for exception kotlinx.coroutines.channels.ClosedSendChannelException: Indicates attempt to SendChannel.send on SendChannel.isClosedForSend channel that was closed without a cause. A failed channel rethrows the original SendChannel.close cause exception on send attempts.
CommonPool - Class in kotlinx.coroutines: Represents common pool of shared threads as coroutine dispatcher for compute-intensive tasks.
Companion - Static variable in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Deprecated.
CompletableDeferred<T> - Interface in kotlinx.coroutines: A interface Deferred that can be completed via public functions CompletableDeferred.complete, CompletableDeferred.completeExceptionally, and cancel.
CompletableDeferred(parent) - Static method in class kotlinx.coroutines.CompletableDeferredKt: Creates a interface CompletableDeferred in an active state. It is optionally a child of a parent job.
CompletableDeferred(value) - Static method in class kotlinx.coroutines.CompletableDeferredKt: Creates an already completed interface CompletableDeferred with a given value.
CompletableDeferredKt - Class in kotlinx.coroutines
complete(value) - Method in interface kotlinx.coroutines.CompletableDeferred: Completes this deferred value with a given value. The result is true if this deferred was completed as a result of this invocation and false otherwise (if it was already completed).
CompletedExceptionallyKt - Class in kotlinx.coroutines
completeExceptionally(exception) - Method in interface kotlinx.coroutines.CompletableDeferred: Completes this deferred value exceptionally with a given exception. The result is true if this deferred was completed as a result of this invocation and false otherwise (if it was already completed).
CompletionHandler_commonKt - Class in kotlinx.coroutines
CompletionHandlerException - Exception in kotlinx.coroutines: This exception gets thrown if an exception is caught while processing CompletionHandler invocation for interface Job.
CompletionHandlerException(message, cause) - Constructor for exception kotlinx.coroutines.CompletionHandlerException: This exception gets thrown if an exception is caught while processing CompletionHandler invocation for interface Job.
CompletionHandlerKt - Class in kotlinx.coroutines
component1() - Method in class kotlinx.coroutines.CoroutineName: User-defined coroutine name.
CONFLATED - Static variable in interface kotlinx.coroutines.channels.Channel: Requests conflated channel in Channel(...) factory function -- the class ConflatedChannel gets created.
CONFLATED - Static variable in class kotlinx.coroutines.channels.Channel.Factory: Requests conflated channel in Channel(...) factory function -- the class ConflatedChannel gets created.
ConflatedBroadcastChannel<E> - Class in kotlinx.coroutines.channels: Broadcasts the most recently sent element (aka ConflatedBroadcastChannel.getValue) to all ConflatedBroadcastChannel.openSubscription subscribers.
ConflatedBroadcastChannel() - Constructor for class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Broadcasts the most recently sent element (aka ConflatedBroadcastChannel.getValue) to all ConflatedBroadcastChannel.openSubscription subscribers.
ConflatedBroadcastChannel(value) - Constructor for class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Creates an instance of this class that already holds a value.
ConflatedChannel<E> - Class in kotlinx.coroutines.channels: Channel that buffers at most one element and conflates all subsequent send and offer invocations, so that the receiver always gets the most recently sent element. Back-to-send sent elements are conflated -- only the the most recently sent element is received, while previously sent elements are lost. Sender to this channel never suspends and offer always returns true.
ConflatedChannel() - Constructor for class kotlinx.coroutines.channels.ConflatedChannel: Channel that buffers at most one element and conflates all subsequent send and offer invocations, so that the receiver always gets the most recently sent element. Back-to-send sent elements are conflated -- only the the most recently sent element is received, while previously sent elements are lost. Sender to this channel never suspends and offer always returns true.
consume($receiver, block) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Opens subscription to this interface BroadcastChannel and makes sure that the given block consumes all elements from it by always invoking ReceiveChannel.cancel after the execution of the block.
consume($receiver, block) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Makes sure that the given block consumes all elements from the given channel by always invoking ReceiveChannel.cancel after the execution of the block.
consumes($receiver) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a CompletionHandler that invokes ReceiveChannel.cancel on the interface ReceiveChannel with the corresponding cause. See also ChannelsKt.consume.
consumesAll(channels) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a CompletionHandler that invokes ReceiveChannel.cancel on all the specified interface ReceiveChannel instances with the corresponding cause. See also ChannelsKt.consumes for a version on one channel.
copy(name) - Method in class kotlinx.coroutines.CoroutineName: User-specified name of coroutine. This name is used in debugging mode. See newCoroutineContext for the description of coroutine debugging facilities.
CoroutineContextKt - Class in kotlinx.coroutines
CoroutineDispatcher - Class in kotlinx.coroutines: Base class that shall be extended by all coroutine dispatcher implementations.
CoroutineDispatcher() - Constructor for class kotlinx.coroutines.CoroutineDispatcher: Base class that shall be extended by all coroutine dispatcher implementations.
CoroutineExceptionHandler - Interface in kotlinx.coroutines: An optional element on the coroutine context to handle uncaught exceptions.
CoroutineExceptionHandler(handler) - Static method in class kotlinx.coroutines.CoroutineExceptionHandlerKt: Creates new interface CoroutineExceptionHandler instance.
CoroutineExceptionHandler.Key - Class in kotlinx.coroutines: Key for interface CoroutineExceptionHandler instance in the coroutine context.
CoroutineExceptionHandlerImplKt - Class in kotlinx.coroutines
CoroutineExceptionHandlerKt - Class in kotlinx.coroutines
CoroutineName - Class in kotlinx.coroutines: User-specified name of coroutine. This name is used in debugging mode. See newCoroutineContext for the description of coroutine debugging facilities.
CoroutineName(name) - Constructor for class kotlinx.coroutines.CoroutineName: User-specified name of coroutine. This name is used in debugging mode. See newCoroutineContext for the description of coroutine debugging facilities.
CoroutineName.Key - Class in kotlinx.coroutines: Key for class CoroutineName instance in the coroutine context.
CoroutineScope - Interface in kotlinx.coroutines: Receiver interface for generic coroutine builders, so that the code inside coroutine has a convenient and fast access to its own cancellation status via CoroutineScope.isActive.
CoroutineStart - Enum in kotlinx.coroutines: Defines start options for coroutines builders. It is used in start parameter of BuildersKt.launch, DeferredKt.async, and other coroutine builder functions.
CoroutineStart() - Constructor for enum kotlinx.coroutines.CoroutineStart: Defines start options for coroutines builders. It is used in start parameter of BuildersKt.launch, DeferredKt.async, and other coroutine builder functions.
count($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the number of elements in this channel.

D

DEBUG_PROPERTY_NAME - Static variable in class kotlinx.coroutines.CoroutineContextKt: Name of the property that controls coroutine debugging. See newCoroutineContext.
DEBUG_PROPERTY_VALUE_AUTO - Static variable in class kotlinx.coroutines.CoroutineContextKt: Automatic debug configuration value for DEBUG_PROPERTY_NAME. See newCoroutineContext.
DEBUG_PROPERTY_VALUE_OFF - Static variable in class kotlinx.coroutines.CoroutineContextKt: Debug turned on value for DEBUG_PROPERTY_NAME. See newCoroutineContext.
DEBUG_PROPERTY_VALUE_ON - Static variable in class kotlinx.coroutines.CoroutineContextKt: Debug turned on value for DEBUG_PROPERTY_NAME. See newCoroutineContext.
DebugKt - Class in kotlinx.coroutines
DEFAULT_PARALLELISM_PROPERTY_NAME - Static variable in class kotlinx.coroutines.CommonPool: Name of the property that controls default parallelism level of class CommonPool. If the property is not specified, Runtime.getRuntime().availableProcessors() - 1 will be used instead (or 1 for single-core JVM). Note that until Java 10, if an application is run within a container, Runtime.getRuntime().availableProcessors() is not aware of container constraints and will return the real number of cores.
DefaultExecutorKt - Class in kotlinx.coroutines
Deferred<T> - Interface in kotlinx.coroutines: Deferred value is a non-blocking cancellable future.
Deferred.DefaultImpls - Class in kotlinx.coroutines: Deferred value is a non-blocking cancellable future.
DeferredKt - Class in kotlinx.coroutines
Delay - Interface in kotlinx.coroutines: This dispatcher feature is implemented by class CoroutineDispatcher implementations that natively support scheduled execution of tasks.
delay($this, time, unit, p) - Static method in class kotlinx.coroutines.Delay.DefaultImpls: Delays coroutine for a given time without blocking a thread and resumes it after a specified time. This suspending function is cancellable. If the interface Job of the current coroutine is cancelled or completed while this suspending function is waiting, this function immediately resumes with CancellationException.
delay(time, unit, p) - Method in interface kotlinx.coroutines.Delay: Delays coroutine for a given time without blocking a thread and resumes it after a specified time. This suspending function is cancellable. If the interface Job of the current coroutine is cancelled or completed while this suspending function is waiting, this function immediately resumes with CancellationException.
delay(time, p) - Static method in class kotlinx.coroutines.DelayKt: Delays coroutine for a given time without blocking a thread and resumes it after a specified time. This suspending function is cancellable. If the interface Job of the current coroutine is cancelled or completed while this suspending function is waiting, this function immediately resumes with CancellationException.
delay(time, unit, p) - Static method in class kotlinx.coroutines.DelayKt: Delays coroutine for a given time without blocking a thread and resumes it after a specified time. This suspending function is cancellable. If the interface Job of the current coroutine is cancelled or completed while this suspending function is waiting, this function immediately resumes with CancellationException.
Delay.DefaultImpls - Class in kotlinx.coroutines: This dispatcher feature is implemented by class CoroutineDispatcher implementations that natively support scheduled execution of tasks.
DelayKt - Class in kotlinx.coroutines
dispatch(context, block) - Method in class kotlinx.coroutines.CommonPool: Dispatches execution of a runnable block onto another thread in the given context.
dispatch(context, block) - Method in class kotlinx.coroutines.CoroutineDispatcher: Dispatches execution of a runnable block onto another thread in the given context.
dispatch(context, block) - Method in class kotlinx.coroutines.Unconfined: Dispatches execution of a runnable block onto another thread in the given context.
DispatchedKt - Class in kotlinx.coroutines
dispatchYield(context, block) - Method in class kotlinx.coroutines.CoroutineDispatcher: Dispatches execution of a runnable block onto another thread in the given context with a hint for dispatcher that current dispatch is triggered by YieldKt.yield call, so execution of this continuation may be delayed in favor of already dispatched coroutines.
DisposableHandle - Interface in kotlinx.coroutines: A handle to an allocated object that can be disposed to make it eligible for garbage collection.
dispose() - Method in interface kotlinx.coroutines.DisposableHandle: Disposes the corresponding object, making it eligible for garbage collection. Repeated invocation of this function has no effect.
dispose() - Method in class kotlinx.coroutines.NonDisposableHandle: Does not do anything.
disposeOnCancellation($receiver, handle) - Static method in class kotlinx.coroutines.CancellableContinuationKt: Disposes a specified handle when this continuation is cancelled.
disposeOnCompletion($receiver, handle) - Static method in class kotlinx.coroutines.CancellableContinuationKt: Deprecated.
disposeOnCompletion($receiver, handle) - Static method in class kotlinx.coroutines.JobKt: Disposes a specified handle when this job is complete.
distinct($receiver) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only distinct elements from the given channel.
distinctBy($receiver, context, selector) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only elements from the given channel having distinct keys returned by the given selector function.
drop($receiver, n, context) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing all elements except first n elements.
dropWhile($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing all elements except first elements that satisfy the given predicate.

E

elementAt($receiver, index, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this channel.
elementAtOrNull($receiver, index, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns an element at the given index or null if the index is out of bounds of this channel.
equals(p) - Method in class kotlinx.coroutines.CoroutineName
equals(other) - Method in exception kotlinx.coroutines.JobCancellationException
EventLoop - Interface in kotlinx.coroutines: Implemented by class CoroutineDispatcher implementations that have event loop inside and can be asked to process next event from their event queue.
EventLoop(thread, parentJob) - Static method in class kotlinx.coroutines.EventLoopKt: Creates a new event loop that is bound the specified thread (current thread by default) and stops accepting new events when parentJob completes. Every continuation that is scheduled onto this event loop unparks the specified thread via LockSupport.unpark.
EventLoopKt - Class in kotlinx.coroutines
ExceptionsKt - Class in kotlinx.coroutines
ExecutorCoroutineDispatcher - Class in kotlinx.coroutines: class CoroutineDispatcher that has underlying Executor for dispatching tasks. Instances of class ExecutorCoroutineDispatcher should be closed by the owner of the dispatcher.
ExecutorCoroutineDispatcher() - Constructor for class kotlinx.coroutines.ExecutorCoroutineDispatcher: class CoroutineDispatcher that has underlying Executor for dispatching tasks. Instances of class ExecutorCoroutineDispatcher should be closed by the owner of the dispatcher.
ExecutorsKt - Class in kotlinx.coroutines

F

Factory - Static variable in interface kotlinx.coroutines.channels.Channel: Constants for channel factory function Channel().
fillInStackTrace() - Method in exception kotlinx.coroutines.JobCancellationException
filter($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only elements matching the given predicate.
filterIndexed($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only elements matching the given predicate.
filterNot($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing all elements not matching the given predicate.
filterNotNull($receiver) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing all elements that are not null.
filterNotNullTo($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Appends all elements that are not null to the given destination.
filterNotNullTo($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Appends all elements that are not null to the given destination.
first($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns first element.
firstOrNull($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the first element, or null if the channel is empty.
flatMap($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a single channel of all elements from results of transform function being invoked on each element of original channel.
fold(initial, operation) - Method in class kotlinx.coroutines.test.TestCoroutineContext

G

get(key) - Method in class kotlinx.coroutines.test.TestCoroutineContext
getBufferDebugString() - Method in class kotlinx.coroutines.channels.AbstractSendChannel
getBufferDebugString() - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel
getBufferDebugString() - Method in class kotlinx.coroutines.channels.ArrayChannel
getCancellationException() - Method in interface kotlinx.coroutines.Job: Returns CancellationException that signals the completion of this job. This function is used by cancellable suspending functions. They throw exception returned by this function when they suspend in the context of this job and this job becomes complete.
getCancellationException() - Method in class kotlinx.coroutines.NonCancellable: Always throws IllegalStateException.
getCapacity() - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel: Buffer capacity.
getCapacity() - Method in class kotlinx.coroutines.channels.ArrayChannel: Buffer capacity.
getChannel() - Method in interface kotlinx.coroutines.channels.ActorScope: A reference to the mailbox channel that this coroutine ReceiveChannel.receive messages from. It is provided for convenience, so that the code in the coroutine can refer to the channel as channel as apposed to this. All the interface ReceiveChannel functions on this interface delegate to the channel instance returned by this function.
getChannel() - Method in interface kotlinx.coroutines.channels.ProducerScope: A reference to the channel that this coroutine SendChannel.send elements to. It is provided for convenience, so that the code in the coroutine can refer to the channel as channel as apposed to this. All the interface SendChannel functions on this interface delegate to the channel instance returned by this function.
getChildren() - Method in interface kotlinx.coroutines.Job: Returns a sequence of this job's children.
getChildren() - Method in class kotlinx.coroutines.NonCancellable: Always returns emptySequence.
getCompleted() - Method in interface kotlinx.coroutines.Deferred: Returns completed result or throws IllegalStateException if this deferred value has not Job.isCompleted yet. It throws the corresponding exception if this deferred has Deferred.isCompletedExceptionally.
getCompletionException($this) - Static method in class kotlinx.coroutines.Deferred.DefaultImpls: Deprecated.
getCompletionExceptionOrNull() - Method in interface kotlinx.coroutines.Deferred: Returns completion exception result if this deferred Deferred.isCompletedExceptionally, null if it is completed normally, or throws IllegalStateException if this deferred value has not Job.isCompleted yet.
getContext() - Method in class kotlinx.coroutines.AbstractCoroutine
getCoroutineContext() - Method in class kotlinx.coroutines.AbstractCoroutine: Deprecated.
getDefaultDispatcher() - Static method in class kotlinx.coroutines.CoroutineContextKt: The default class CoroutineDispatcher that is used by all standard builders like BuildersKt.launch, DeferredKt.async, etc if no dispatcher nor any other ContinuationInterceptor is specified in their context.
getExceptions() - Method in class kotlinx.coroutines.test.TestCoroutineContext: Exceptions that were caught during a BuildersKt.launch or a DeferredKt.async + Deferred.await.
getExecutor() - Method in class kotlinx.coroutines.CommonPool: Underlying executor of current class CoroutineDispatcher.
getExecutor() - Method in class kotlinx.coroutines.ExecutorCoroutineDispatcher: Underlying executor of current class CoroutineDispatcher.
getExecutor() - Method in class kotlinx.coroutines.ThreadPoolDispatcher: Underlying executor of current class CoroutineDispatcher.
getIO() - Static method in class kotlinx.coroutines.CoroutineContextKt: The class CoroutineDispatcher that is designed for offloading blocking IO tasks to a shared pool of threads.
getName() - Method in class kotlinx.coroutines.CoroutineName: User-defined coroutine name.
getOnAwait() - Method in interface kotlinx.coroutines.Deferred: Clause for select expression of Deferred.await suspending function that selects with the deferred value when it is resolved. The select invocation fails if the deferred value completes exceptionally (either fails or it cancelled).
getOnJoin() - Method in interface kotlinx.coroutines.Job: Clause for select expression of Job.join suspending function that selects when the job is complete. This clause never fails, even if the job completes exceptionally.
getOnJoin() - Method in class kotlinx.coroutines.NonCancellable: Clause for select expression of NonCancellable.join suspending function that selects when the job is complete. This clause never fails, even if the job completes exceptionally.
getOnLock() - Method in interface kotlinx.coroutines.sync.Mutex: Clause for select expression of Mutex.lock suspending function that selects when the mutex is locked. Additional parameter for the clause in the owner (see Mutex.lock) and when the clause is selected the reference to this mutex is passed into the corresponding block.
getOnReceive() - Method in class kotlinx.coroutines.channels.AbstractChannel: Clause for select expression of AbstractChannel.receive suspending function that selects with the element that is received from the channel. The select invocation fails with exception if the channel AbstractChannel.isClosedForReceive (see SendChannel.close for details).
getOnReceive() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Clause for select expression of ReceiveChannel.receive suspending function that selects with the element that is received from the channel. The select invocation fails with exception if the channel ReceiveChannel.isClosedForReceive (see SendChannel.close for details).
getOnReceiveOrNull() - Method in class kotlinx.coroutines.channels.AbstractChannel: Clause for select expression of AbstractChannel.receiveOrNull suspending function that selects with the element that is received from the channel or selects with null if if the channel AbstractChannel.isClosedForReceive without cause. The select invocation fails with the original SendChannel.close cause exception if the channel has failed.
getOnReceiveOrNull() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Clause for select expression of ReceiveChannel.receiveOrNull suspending function that selects with the element that is received from the channel or selects with null if if the channel ReceiveChannel.isClosedForReceive without cause. The select invocation fails with the original SendChannel.close cause exception if the channel has failed.
getOnSend() - Method in class kotlinx.coroutines.channels.AbstractSendChannel: Clause for select expression of AbstractSendChannel.send suspending function that selects when the element that is specified as parameter is sent to the channel. When the clause is selected the reference to this channel is passed into the corresponding block.
getOnSend() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Clause for select expression of ConflatedBroadcastChannel.send suspending function that selects when the element that is specified as parameter is sent to the channel. When the clause is selected the reference to this channel is passed into the corresponding block.
getOnSend() - Method in interface kotlinx.coroutines.channels.SendChannel: Clause for select expression of SendChannel.send suspending function that selects when the element that is specified as parameter is sent to the channel. When the clause is selected the reference to this channel is passed into the corresponding block.
getValue() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: The most recently sent element to this channel.
getValueOrNull() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: The most recently sent element to this channel or null when this class is constructed without initial value and no value was sent yet or if it was ConflatedBroadcastChannel.close.

H

handleCoroutineException(context, exception, caller) - Static method in class kotlinx.coroutines.CoroutineExceptionHandlerKt: Helper function for coroutine builder implementations to handle uncaught exception in coroutines.
handleCoroutineException(context, exception) - Static method in class kotlinx.coroutines.CoroutineExceptionHandlerKt: Helper function for coroutine builder implementations to handle uncaught exception in coroutines.
handleException(context, exception) - Method in interface kotlinx.coroutines.CoroutineExceptionHandler: Handles uncaught exception in the given context. It is invoked if coroutine has an uncaught exception. See CoroutineExceptionHandlerKt.handleCoroutineException.
hashCode() - Method in class kotlinx.coroutines.CoroutineName
hashCode() - Method in exception kotlinx.coroutines.JobCancellationException
hasNext(p) - Method in interface kotlinx.coroutines.channels.ChannelIterator: Returns true if the channel has more elements suspending the caller while this channel ReceiveChannel.isEmpty or returns false if the channel ReceiveChannel.isClosedForReceive without cause. It throws the original SendChannel.close cause exception if the channel has failed.
holdsLock(owner) - Method in interface kotlinx.coroutines.sync.Mutex: Checks mutex locked by owner

I

indexOf($receiver, element, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns first index of element, or -1 if the channel does not contain element.
initCancellability() - Method in interface kotlinx.coroutines.CancellableContinuation: Makes this continuation cancellable. Use it with holdCancellability optional parameter to suspendCancellableCoroutine function. It throws IllegalStateException if invoked more than once.
INITIAL_STATE - Static variable in class kotlinx.coroutines.channels.ConflatedBroadcastChannel
INSTANCE - Static variable in class kotlinx.coroutines.CommonPool: Represents common pool of shared threads as coroutine dispatcher for compute-intensive tasks.
INSTANCE - Static variable in class kotlinx.coroutines.NonCancellable: A non-cancelable job that is always NonCancellable.isActive. It is designed for BuildersKt.withContext function to prevent cancellation of code blocks that need to be executed without cancellation.
INSTANCE - Static variable in class kotlinx.coroutines.NonDisposableHandle: No-op implementation of interface DisposableHandle.
INSTANCE - Static variable in class kotlinx.coroutines.Unconfined: A coroutine dispatcher that is not confined to any specific thread. It executes initial continuation of the coroutine right here in the current call-frame and let the coroutine resume in whatever thread that is used by the corresponding suspending function, without mandating any specific threading policy.
interceptContinuation(continuation) - Method in class kotlinx.coroutines.CoroutineDispatcher: Returns continuation that wraps the original continuation, thus intercepting all resumptions.
invoke(block, completion) - Method in enum kotlinx.coroutines.CoroutineStart: Starts the corresponding block as a coroutine with this coroutine start strategy.
invoke(block, receiver, completion) - Method in enum kotlinx.coroutines.CoroutineStart: Starts the corresponding block with receiver as a coroutine with this coroutine start strategy.
invoke($this, $receiver, block) - Static method in class kotlinx.coroutines.selects.SelectBuilder.DefaultImpls: Registers clause in this select expression with additional parameter nullable parameter of type P with the null value for this parameter that selects value of type Q.
invoke($receiver, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Registers clause in this select expression without additional parameters that does not select any value.
invoke($receiver, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Registers clause in this select expression without additional parameters that selects value of type Q.
invoke($receiver, param, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Registers clause in this select expression with additional parameter of type P that selects value of type Q.
invoke($receiver, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Registers clause in this select expression with additional parameter nullable parameter of type P with the null value for this parameter that selects value of type Q.
invokeOnCancellation(handler) - Method in interface kotlinx.coroutines.CancellableContinuation: Registers handler that is synchronously invoked once on cancellation (both regular and exceptional) of this continuation. When the continuation is already cancelled, then the handler is immediately invoked with cancellation exception. Otherwise, the handler will be invoked once on cancellation if this continuation is cancelled.
invokeOnClose(handler) - Method in class kotlinx.coroutines.channels.AbstractSendChannel: Registers handler which is synchronously invoked once the channel is AbstractSendChannel.close or receiving side of this channel is ReceiveChannel.cancel. Only one handler can be attached to the channel during channel's lifetime. Handler is invoked when AbstractSendChannel.isClosedForSend starts to return true. If channel is already closed, handler is invoked immediately.
invokeOnClose(handler) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Registers handler which is synchronously invoked once the channel is ConflatedBroadcastChannel.close or receiving side of this channel is ReceiveChannel.cancel. Only one handler can be attached to the channel during channel's lifetime. Handler is invoked when ConflatedBroadcastChannel.isClosedForSend starts to return true. If channel is already closed, handler is invoked immediately.
invokeOnClose(handler) - Method in interface kotlinx.coroutines.channels.SendChannel: Registers handler which is synchronously invoked once the channel is SendChannel.close or receiving side of this channel is ReceiveChannel.cancel. Only one handler can be attached to the channel during channel's lifetime. Handler is invoked when SendChannel.isClosedForSend starts to return true. If channel is already closed, handler is invoked immediately.
invokeOnCompletion(onCancelling, invokeImmediately, handler) - Method in interface kotlinx.coroutines.CancellableContinuation: Deprecated.
invokeOnCompletion(handler) - Method in interface kotlinx.coroutines.Job: Registers handler that is synchronously invoked once on completion of this job. When job is already complete, then the handler is immediately invoked with a job's exception or cancellation cause or null. Otherwise, handler will be invoked once when this job is complete.
invokeOnCompletion(onCancelling, invokeImmediately, handler) - Method in interface kotlinx.coroutines.Job: Registers handler that is synchronously invoked once on cancellation or completion of this job. When job is already cancelling or complete, then the handler is immediately invoked with a job's cancellation cause or null unless invokeImmediately is set to false. Otherwise, handler will be invoked once when this job is cancelled or complete.
invokeOnCompletion(handler) - Method in class kotlinx.coroutines.NonCancellable: Always returns class NonDisposableHandle.
invokeOnCompletion(onCancelling_, handler) - Method in class kotlinx.coroutines.NonCancellable: Always returns class NonDisposableHandle.
invokeOnCompletion(onCancelling, invokeImmediately, handler) - Method in class kotlinx.coroutines.NonCancellable: Always returns class NonDisposableHandle.
invokeOnTimeout($this, time, unit, block) - Static method in class kotlinx.coroutines.Delay.DefaultImpls: Schedules invocation of a specified block after a specified delay time. The resulting interface DisposableHandle can be used to DisposableHandle.dispose of this invocation request if it is not needed anymore.
invokeOnTimeout(time, unit, block) - Method in interface kotlinx.coroutines.Delay: Schedules invocation of a specified block after a specified delay time. The resulting interface DisposableHandle can be used to DisposableHandle.dispose of this invocation request if it is not needed anymore.
IO_PARALLELISM_PROPERTY_NAME - Static variable in class kotlinx.coroutines.CoroutineContextKt: Name of the property that defines the maximal number of threads that are used by CoroutineContextKt.getIO coroutines dispatcher.
isActive() - Method in interface kotlinx.coroutines.CancellableContinuation: Returns true when this continuation is active -- it has not completed or cancelled yet.
isActive() - Method in interface kotlinx.coroutines.CoroutineScope: Returns true when this coroutine is still active (has not completed and was not cancelled yet).
isActive() - Method in interface kotlinx.coroutines.Job: Returns true when this job is active -- it was already started and has not completed or cancelled yet. The job that is waiting for its Job.getChildren to complete is still considered to be active if it was not cancelled.
isActive($receiver) - Static method in class kotlinx.coroutines.JobKt: Returns true when the interface Job of the coroutine in this context is still active (has not completed and was not cancelled yet).
isActive() - Method in class kotlinx.coroutines.NonCancellable: Always returns true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.channels.ArrayChannel: Returns true if ArrayChannel.isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.channels.ConflatedChannel: Returns true if ConflatedChannel.isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.channels.LinkedListChannel: Returns true if LinkedListChannel.isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.channels.RendezvousChannel: Returns true if RendezvousChannel.isBufferEmpty is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel: Returns true if ArrayBroadcastChannel.isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.channels.ArrayChannel: Returns true if ArrayChannel.isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.channels.ConflatedChannel: Returns true if ConflatedChannel.isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.channels.LinkedListChannel: Returns true if LinkedListChannel.isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.channels.RendezvousChannel: Returns true if RendezvousChannel.isBufferFull is always true.
isBufferEmpty() - Method in class kotlinx.coroutines.channels.ArrayChannel: Returns true if this channel's buffer is empty.
isBufferEmpty() - Method in class kotlinx.coroutines.channels.ConflatedChannel: Returns true if this channel's buffer is empty.
isBufferEmpty() - Method in class kotlinx.coroutines.channels.LinkedListChannel: Returns true if this channel's buffer is empty.
isBufferEmpty() - Method in class kotlinx.coroutines.channels.RendezvousChannel: Returns true if this channel's buffer is empty.
isBufferFull() - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel: Returns true if this channel's buffer is full.
isBufferFull() - Method in class kotlinx.coroutines.channels.ArrayChannel: Returns true if this channel's buffer is full.
isBufferFull() - Method in class kotlinx.coroutines.channels.ConflatedChannel: Returns true if this channel's buffer is full.
isBufferFull() - Method in class kotlinx.coroutines.channels.LinkedListChannel: Returns true if this channel's buffer is full.
isBufferFull() - Method in class kotlinx.coroutines.channels.RendezvousChannel: Returns true if this channel's buffer is full.
isCancelled() - Method in interface kotlinx.coroutines.CancellableContinuation: Returns true if this continuation was CancellableContinuation.cancel.
isCancelled() - Method in interface kotlinx.coroutines.Job: Returns true if this job was Job.cancel. In the general case, it does not imply that the job has already Job.isCompleted (it may still be cancelling whatever it was doing).
isCancelled() - Method in class kotlinx.coroutines.NonCancellable: Always returns false.
isClosedForReceive() - Method in class kotlinx.coroutines.channels.AbstractChannel: Returns true if this channel was closed by invocation of SendChannel.close on the interface SendChannel side and all previously sent items were already received, so that the AbstractChannel.receive attempt throws exception ClosedReceiveChannelException. If the channel was closed because of the exception, it is considered closed, too, but it is called a failed channel. All suspending attempts to receive an element from a failed channel throw the original SendChannel.close cause exception.
isClosedForReceive() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Returns true if this channel was closed by invocation of SendChannel.close on the interface SendChannel side and all previously sent items were already received, so that the ReceiveChannel.receive attempt throws exception ClosedReceiveChannelException. If the channel was closed because of the exception, it is considered closed, too, but it is called a failed channel. All suspending attempts to receive an element from a failed channel throw the original SendChannel.close cause exception.
isClosedForSend() - Method in class kotlinx.coroutines.channels.AbstractSendChannel: Returns true if this channel was closed by invocation of AbstractSendChannel.close and thus the AbstractSendChannel.send and AbstractSendChannel.offer attempts throws exception.
isClosedForSend() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Returns true if this channel was closed by invocation of ConflatedBroadcastChannel.close and thus the ConflatedBroadcastChannel.send and ConflatedBroadcastChannel.offer attempts throws exception.
isClosedForSend() - Method in interface kotlinx.coroutines.channels.SendChannel: Returns true if this channel was closed by invocation of SendChannel.close and thus the SendChannel.send and SendChannel.offer attempts throws exception.
isCompleted() - Method in interface kotlinx.coroutines.CancellableContinuation: Returns true when this continuation has completed for any reason. A continuation that was cancelled is also considered complete.
isCompleted() - Method in interface kotlinx.coroutines.Job: Returns true when this job has completed for any reason. A job that was cancelled and has finished its execution is also considered complete. Job becomes complete only after all its Job.getChildren complete.
isCompleted() - Method in class kotlinx.coroutines.NonCancellable: Always returns false.
isCompletedExceptionally() - Method in interface kotlinx.coroutines.Deferred: Returns true if computation of this deferred value has completed exceptionally -- it had either failed with exception during computation or was Job.cancel.
isDispatchNeeded(context) - Method in class kotlinx.coroutines.CoroutineDispatcher: Returns true if execution shall be dispatched onto another thread. The default behaviour for most dispatchers is to return true.
isDispatchNeeded(context) - Method in class kotlinx.coroutines.Unconfined: Returns true if execution shall be dispatched onto another thread. The default behaviour for most dispatchers is to return true.
isEmpty() - Method in class kotlinx.coroutines.channels.AbstractChannel: Returns true if the channel is empty (contains no elements) and the AbstractChannel.receive attempt will suspend. This function returns false for AbstractChannel.isClosedForReceive channel.
isEmpty() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Returns true if the channel is empty (contains no elements) and the ReceiveChannel.receive attempt will suspend. This function returns false for ReceiveChannel.isClosedForReceive channel.
isFull() - Method in class kotlinx.coroutines.channels.AbstractSendChannel: Returns true if the channel is full (out of capacity) and the AbstractSendChannel.send attempt will suspend. This function returns false for AbstractSendChannel.isClosedForSend channel.
isFull() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Returns true if the channel is full (out of capacity) and the ConflatedBroadcastChannel.send attempt will suspend. This function returns false for ConflatedBroadcastChannel.isClosedForSend channel.
isFull() - Method in interface kotlinx.coroutines.channels.SendChannel: Returns true if the channel is full (out of capacity) and the SendChannel.send attempt will suspend. This function returns false for SendChannel.isClosedForSend channel.
isLazy() - Method in enum kotlinx.coroutines.CoroutineStart: Returns true when LAZY.
isLocked() - Method in interface kotlinx.coroutines.sync.Mutex: Returns true when this mutex is locked.
iterator() - Method in class kotlinx.coroutines.channels.AbstractChannel: Returns new iterator to receive elements from this channels using for loop. Iteration completes normally when the channel is AbstractChannel.isClosedForReceive without cause and throws the original SendChannel.close cause exception if the channel has failed.
iterator() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Returns new iterator to receive elements from this channels using for loop. Iteration completes normally when the channel is ReceiveChannel.isClosedForReceive without cause and throws the original SendChannel.close cause exception if the channel has failed.

J

Job - Interface in kotlinx.coroutines: A background job. Conceptually, a job is a cancellable thing with a simple life-cycle that culminates in its completion. Jobs can be arranged into parent-child hierarchies where cancellation or completion of parent immediately cancels all its Job.getChildren.
Job(parent) - Static method in class kotlinx.coroutines.JobKt: Creates a new job object in an active state. It is optionally a child of a parent job.
Job.DefaultImpls - Class in kotlinx.coroutines: A background job. Conceptually, a job is a cancellable thing with a simple life-cycle that culminates in its completion. Jobs can be arranged into parent-child hierarchies where cancellation or completion of parent immediately cancels all its Job.getChildren.
Job.Key - Class in kotlinx.coroutines: Key for interface Job instance in the coroutine context.
JobCancellationException - Exception in kotlinx.coroutines: Thrown by cancellable suspending functions if the interface Job of the coroutine is cancelled or completed without cause, or with a cause or exception that is not CancellationException (see Job.getCancellationException).
JobCancellationException(message, cause) - Constructor for exception kotlinx.coroutines.JobCancellationException: Thrown by cancellable suspending functions if the interface Job of the coroutine is cancelled or completed without cause, or with a cause or exception that is not CancellationException (see Job.getCancellationException).
JobKt - Class in kotlinx.coroutines
JobSupportKt - Class in kotlinx.coroutines
join(p) - Method in interface kotlinx.coroutines.Job: Suspends coroutine until this job is complete. This invocation resumes normally (without exception) when the job is complete for any reason and the interface Job of the invoking coroutine is still Job.isActive. This function also Job.start the corresponding coroutine if the interface Job was still in new state.
join(p) - Method in class kotlinx.coroutines.NonCancellable: Always throws UnsupportedOperationException.
joinAll(jobs, p) - Static method in class kotlinx.coroutines.AwaitKt: Suspends current coroutine until all given jobs are complete. This method is semantically equivalent to joining all given jobs one by one with jobs.forEach { it.join() }.
joinAll($receiver, p) - Static method in class kotlinx.coroutines.AwaitKt: Suspends current coroutine until all given jobs are complete. This method is semantically equivalent to joining all given jobs one by one with forEach { it.join() }.
joinChildren($receiver, p) - Static method in class kotlinx.coroutines.JobKt: Suspends coroutine until all Job.getChildren of this job are complete using Job.join for all of them. Unlike Job.join on this job as a whole, it does not wait until this job is complete.

K

Key - Static variable in interface kotlinx.coroutines.CoroutineExceptionHandler: Key for interface CoroutineExceptionHandler instance in the coroutine context.
Key - Static variable in class kotlinx.coroutines.CoroutineName: Key for class CoroutineName instance in the coroutine context.
Key - Static variable in interface kotlinx.coroutines.Job: Key for interface Job instance in the coroutine context.
kotlinx.coroutines - package kotlinx.coroutines: General-purpose coroutine builders, contexts, and helper functions.
kotlinx.coroutines.channels - package kotlinx.coroutines.channels: Channels -- non-blocking primitives for communicating a stream of elements between coroutines.
kotlinx.coroutines.intrinsics - package kotlinx.coroutines.intrinsics: Low-level primitives for finer-grained control of coroutines.
kotlinx.coroutines.selects - package kotlinx.coroutines.selects: Select expression to perform multiple suspending operations simultaneously until one of them succeeds.
kotlinx.coroutines.sync - package kotlinx.coroutines.sync: Synchronization primitives (mutex).
kotlinx.coroutines.test - package kotlinx.coroutines.test: Components to ease writing unit-tests for code that contains coroutines with delays and timeouts.
kotlinx.coroutines.timeunit - package kotlinx.coroutines.timeunit: Optional time unit support for multiplatform projects.

L

last($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the last element.
lastIndexOf($receiver, element, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns last index of element, or -1 if the channel does not contain element.
lastOrNull($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the last element, or null if the channel is empty.
launch(context, start, parent, onCompletion, block) - Static method in class kotlinx.coroutines.BuildersKt: Launches new coroutine without blocking current thread and returns a reference to the coroutine as a interface Job. The coroutine is cancelled when the resulting job is Job.cancel.
LazyDeferredKt - Class in kotlinx.coroutines
LinkedListChannel<E> - Class in kotlinx.coroutines.channels: Channel with linked-list buffer of a unlimited capacity (limited only by available memory). Sender to this channel never suspends and offer always returns true.
LinkedListChannel() - Constructor for class kotlinx.coroutines.channels.LinkedListChannel: Channel with linked-list buffer of a unlimited capacity (limited only by available memory). Sender to this channel never suspends and offer always returns true.
lock(owner, p) - Method in interface kotlinx.coroutines.sync.Mutex: Locks this mutex, suspending caller while the mutex is locked.

M

map($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing the results of applying the given transform function to each element in the original channel.
mapIndexed($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing the results of applying the given transform function to each element and its index in the original channel.
mapIndexedNotNull($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only the non-null results of applying the given transform function to each element and its index in the original channel.
mapNotNull($receiver, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing only the non-null results of applying the given transform function to each element in the original channel.
maxWith($receiver, comparator, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the first element having the largest value according to the provided comparator or null if there are no elements.
minusKey(key) - Method in class kotlinx.coroutines.test.TestCoroutineContext
minWith($receiver, comparator, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the first element having the smallest value according to the provided comparator or null if there are no elements.
Mutex - Interface in kotlinx.coroutines.sync: Mutual exclusion for coroutines.
Mutex(locked) - Static method in class kotlinx.coroutines.sync.MutexKt: Creates new interface Mutex instance. The mutex created is fair: lock is granted in first come, first served order.
MutexKt - Class in kotlinx.coroutines.sync

N

newCoroutineContext(context, parent) - Static method in class kotlinx.coroutines.CoroutineContextKt: Creates context for the new coroutine. It installs DefaultDispatcher when no other dispatcher nor ContinuationInterceptor is specified, and adds optional support for debugging facilities (when turned on).
newCoroutineContext(context) - Static method in class kotlinx.coroutines.CoroutineContextKt: Creates context for the new coroutine. It installs DefaultDispatcher when no other dispatcher nor ContinuationInterceptor is specified, and adds optional support for debugging facilities (when turned on).
newFixedThreadPoolContext(nThreads, name) - Static method in class kotlinx.coroutines.ThreadPoolDispatcherKt: Creates new coroutine execution context with the fixed-size thread-pool and built-in YieldKt.yield and DelayKt.delay support. NOTE: The resulting class ThreadPoolDispatcher owns native resources (its threads).Resources are reclaimed by ThreadPoolDispatcher.close.
newSingleThreadContext(name) - Static method in class kotlinx.coroutines.ThreadPoolDispatcherKt: Creates a new coroutine execution context using a single thread with built-in YieldKt.yield and DelayKt.delay support. NOTE: The resulting class ThreadPoolDispatcher owns native resources (its thread).Resources are reclaimed by ThreadPoolDispatcher.close.
next(p) - Method in interface kotlinx.coroutines.channels.ChannelIterator: Retrieves and removes the element from this channel suspending the caller while this channel ReceiveChannel.isEmpty or throws exception ClosedReceiveChannelException if the channel ReceiveChannel.isClosedForReceive without cause. It throws the original SendChannel.close cause exception if the channel has failed.
NonCancellable - Class in kotlinx.coroutines: A non-cancelable job that is always NonCancellable.isActive. It is designed for BuildersKt.withContext function to prevent cancellation of code blocks that need to be executed without cancellation.
NonDisposableHandle - Class in kotlinx.coroutines: No-op implementation of interface DisposableHandle.
none($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns true if the channel has no elements.
now(unit) - Method in class kotlinx.coroutines.test.TestCoroutineContext: Returns the current virtual clock-time as it is known to this CoroutineContext.

O

offer(element) - Method in class kotlinx.coroutines.channels.AbstractSendChannel: Adds element into this queue if it is possible to do so immediately without violating capacity restrictions and returns true. Otherwise, it returns false immediately or throws exception if the channel AbstractSendChannel.isClosedForSend (see AbstractSendChannel.close for details).
offer(element) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Sends the value to all subscribed receives and stores this value as the most recent state for future subscribers. This implementation always returns true. It throws exception if the channel ConflatedBroadcastChannel.isClosedForSend (see ConflatedBroadcastChannel.close for details).
offer(element) - Method in interface kotlinx.coroutines.channels.SendChannel: Adds element into this queue if it is possible to do so immediately without violating capacity restrictions and returns true. Otherwise, it returns false immediately or throws exception if the channel SendChannel.isClosedForSend (see SendChannel.close for details).
offerInternal(element) - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel: Tries to add element to buffer or to queued receiver. Return type is OFFER_SUCCESS | OFFER_FAILED | Closed.
offerInternal(element) - Method in class kotlinx.coroutines.channels.ArrayChannel: Tries to add element to buffer or to queued receiver. Return type is OFFER_SUCCESS | OFFER_FAILED | Closed.
offerInternal(element) - Method in class kotlinx.coroutines.channels.ConflatedChannel: Tries to add element to buffer or to queued receiver. Return type is OFFER_SUCCESS | OFFER_FAILED | Closed.
offerInternal(element) - Method in class kotlinx.coroutines.channels.LinkedListChannel: Tries to add element to buffer or to queued receiver. Return type is OFFER_SUCCESS | OFFER_FAILED | Closed.
offerSelectInternal(element, select) - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel: Tries to add element to buffer or to queued receiver if select statement clause was not selected yet. Return type is ALREADY_SELECTED | OFFER_SUCCESS | OFFER_FAILED | Closed.
offerSelectInternal(element, select) - Method in class kotlinx.coroutines.channels.ArrayChannel: Tries to add element to buffer or to queued receiver if select statement clause was not selected yet. Return type is ALREADY_SELECTED | OFFER_SUCCESS | OFFER_FAILED | Closed.
offerSelectInternal(element, select) - Method in class kotlinx.coroutines.channels.ConflatedChannel: Tries to add element to buffer or to queued receiver if select statement clause was not selected yet. Return type is ALREADY_SELECTED | OFFER_SUCCESS | OFFER_FAILED | Closed.
offerSelectInternal(element, select) - Method in class kotlinx.coroutines.channels.LinkedListChannel: Tries to add element to buffer or to queued receiver if select statement clause was not selected yet. Return type is ALREADY_SELECTED | OFFER_SUCCESS | OFFER_FAILED | Closed.
onCancellation(cause) - Method in class kotlinx.coroutines.AbstractCoroutine: This function is invoked once when this coroutine is cancelled or is completed, similarly to invokeOnCompletion with onCancelling set to true.
onCompleted(value) - Method in class kotlinx.coroutines.AbstractCoroutine: This function is invoked once when job is completed normally with the specified value.
onCompletedExceptionally(exception) - Method in class kotlinx.coroutines.AbstractCoroutine: This function is invoked once when job is completed exceptionally with the specified exception.
onStart() - Method in class kotlinx.coroutines.AbstractCoroutine: This function is invoked once when non-active coroutine (constructed with active set to `false) is AbstractCoroutine.start.
onTimeout(time, unit, block) - Method in interface kotlinx.coroutines.selects.SelectBuilder: Clause that selects the given block after a specified timeout passes. If timeout is negative or zero, block is selected immediately.
openSubscription() - Method in class kotlinx.coroutines.channels.ArrayBroadcastChannel: Subscribes to this interface BroadcastChannel and returns a channel to receive elements from it. The resulting channel shall be ReceiveChannel.cancel to unsubscribe from this broadcast channel.
openSubscription() - Method in interface kotlinx.coroutines.channels.BroadcastChannel: Subscribes to this interface BroadcastChannel and returns a channel to receive elements from it. The resulting channel shall be ReceiveChannel.cancel to unsubscribe from this broadcast channel.
openSubscription() - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Subscribes to this interface BroadcastChannel and returns a channel to receive elements from it. The resulting channel shall be ReceiveChannel.cancel to unsubscribe from this broadcast channel.

P

plus($this, other) - Static method in class kotlinx.coroutines.Deferred.DefaultImpls: Deprecated.
poll() - Method in class kotlinx.coroutines.channels.AbstractChannel: Retrieves and removes the element from this channel, or returns null if this channel isEmpty or is AbstractChannel.isClosedForReceive without cause. It throws the original SendChannel.close cause exception if the channel has failed.
poll() - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Retrieves and removes the element from this channel, or returns null if this channel isEmpty or is ReceiveChannel.isClosedForReceive without cause. It throws the original SendChannel.close cause exception if the channel has failed.
pollInternal() - Method in class kotlinx.coroutines.channels.ArrayChannel: Tries to remove element from buffer or from queued sender. Return type is E | POLL_FAILED | Closed
pollSelectInternal(select) - Method in class kotlinx.coroutines.channels.ArrayChannel: Tries to remove element from buffer or from queued sender if select statement clause was not selected yet. Return type is ALREADY_SELECTED | E | POLL_FAILED | Closed
processNextEvent() - Method in interface kotlinx.coroutines.EventLoop: Processes next event in this event loop.
produce(context, capacity, parent, onCompletion, block) - Static method in class kotlinx.coroutines.channels.ProduceKt: Launches new coroutine to produce a stream of values by sending them to a channel and returns a reference to the coroutine as a interface ReceiveChannel. This resulting object can be used to ReceiveChannel.receive elements produced by this coroutine.
ProduceKt - Class in kotlinx.coroutines.channels
ProducerScope<E> - Interface in kotlinx.coroutines.channels: Scope for ProduceKt.produce coroutine builder.

R

receive(p) - Method in class kotlinx.coroutines.channels.AbstractChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or throws exception ClosedReceiveChannelException if the channel AbstractChannel.isClosedForReceive. If the channel was closed because of the exception, it is called a failed channel and this function throws the original SendChannel.close cause exception.
receive(p) - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or throws exception ClosedReceiveChannelException if the channel ReceiveChannel.isClosedForReceive. If the channel was closed because of the exception, it is called a failed channel and this function throws the original SendChannel.close cause exception.
ReceiveChannel<E> - Interface in kotlinx.coroutines.channels: Receiver's interface to interface Channel.
receiveOrNull(p) - Method in class kotlinx.coroutines.channels.AbstractChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or returns null if the channel is AbstractChannel.isClosedForReceive without cause or throws the original SendChannel.close cause exception if the channel has failed.
receiveOrNull(p) - Method in interface kotlinx.coroutines.channels.ReceiveChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or returns null if the channel is ReceiveChannel.isClosedForReceive without cause or throws the original SendChannel.close cause exception if the channel has failed.
RendezvousChannel<E> - Class in kotlinx.coroutines.channels: Rendezvous channel. This channel does not have any buffer at all. An element is transferred from sender to receiver only when send and AbstractChannel.receive invocations meet in time (rendezvous), so send suspends until another coroutine invokes AbstractChannel.receive and AbstractChannel.receive suspends until another coroutine invokes send.
RendezvousChannel() - Constructor for class kotlinx.coroutines.channels.RendezvousChannel: Rendezvous channel. This channel does not have any buffer at all. An element is transferred from sender to receiver only when send and AbstractChannel.receive invocations meet in time (rendezvous), so send suspends until another coroutine invokes AbstractChannel.receive and AbstractChannel.receive suspends until another coroutine invokes send.
requireNoNulls($receiver) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns an original collection containing all the non-null elements, throwing an IllegalArgumentException if there are any null elements.
restoreThreadContext(context, oldState) - Method in interface kotlinx.coroutines.ThreadContextElement: Restores context of the current thread. This function is invoked after the coroutine in the specified context is suspended in the current thread if ThreadContextElement.updateThreadContext was previously invoked on resume of this coroutine. The value of oldState is the result of the previous invocation of ThreadContextElement.updateThreadContext and it should be restored in the thread-local state by this function.
ResumeModeKt - Class in kotlinx.coroutines
resumeUndispatched($receiver, value) - Method in interface kotlinx.coroutines.CancellableContinuation: Resumes this continuation with a given value in the invoker thread without going though CoroutineDispatcher.dispatch function of the class CoroutineDispatcher in the context. This function is designed to be used only by the class CoroutineDispatcher implementations themselves. It should not be used in general code.
resumeUndispatchedWithException($receiver, exception) - Method in interface kotlinx.coroutines.CancellableContinuation: Resumes this continuation with a given exception in the invoker thread without going though CoroutineDispatcher.dispatch function of the class CoroutineDispatcher in the context. This function is designed to be used only by the class CoroutineDispatcher implementations themselves. It should not be used in general code.
resumeWith(result) - Method in class kotlinx.coroutines.AbstractCoroutine: Completes execution of this with coroutine with the specified result.
runBlocking(context, block) - Static method in class kotlinx.coroutines.BuildersKt: Runs new coroutine and blocks current thread interruptibly until its completion. This function should not be used from coroutine. It is designed to bridge regular blocking code to libraries that are written in suspending style, to be used in main functions and in tests.
Runnable(block) - Static method in class kotlinx.coroutines.RunnableKt: Creates Runnable task instance.
RunnableKt - Class in kotlinx.coroutines

S

ScheduledKt - Class in kotlinx.coroutines
scheduleResumeAfterDelay(time, unit, continuation) - Method in interface kotlinx.coroutines.Delay: Schedules resume of a specified continuation after a specified delay time.
SelectBuilder<R> - Interface in kotlinx.coroutines.selects: Scope for select invocation.
SelectBuilder.DefaultImpls - Class in kotlinx.coroutines.selects: Scope for select invocation.
SelectClause0 - Interface in kotlinx.coroutines.selects: Clause for select expression without additional parameters that does not select any value.
SelectClause1<Q> - Interface in kotlinx.coroutines.selects: Clause for select expression without additional parameters that selects value of type Q.
SelectClause2<P,Q> - Interface in kotlinx.coroutines.selects: Clause for select expression with additional parameter of type P that selects value of type Q.
SelectKt - Class in kotlinx.coroutines.selects
SelectUnbiasedKt - Class in kotlinx.coroutines.selects
send(element, p) - Method in class kotlinx.coroutines.channels.AbstractSendChannel: Adds element into to this channel, suspending the caller while this channel AbstractSendChannel.isFull, or throws exception if the channel AbstractSendChannel.isClosedForSend (see AbstractSendChannel.close for details).
send(element, p) - Method in class kotlinx.coroutines.channels.ConflatedBroadcastChannel: Sends the value to all subscribed receives and stores this value as the most recent state for future subscribers. This implementation never suspends. It throws exception if the channel ConflatedBroadcastChannel.isClosedForSend (see ConflatedBroadcastChannel.close for details).
send(element, p) - Method in interface kotlinx.coroutines.channels.SendChannel: Adds element into to this channel, suspending the caller while this channel SendChannel.isFull, or throws exception if the channel SendChannel.isClosedForSend (see SendChannel.close for details).
sendBlocking($receiver, element) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Adds element into to this channel, blocking the caller while this channel SendChannel.isFull, or throws exception if the channel SendChannel.isClosedForSend (see SendChannel.close for details).
SendChannel<E> - Interface in kotlinx.coroutines.channels: Sender's interface to interface Channel.
single($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns the single element, or throws an exception if the channel is empty or has more than one element.
singleOrNull($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns single element, or null if the channel is empty or has more than one element.
start(start, block) - Method in class kotlinx.coroutines.AbstractCoroutine: Starts this coroutine with the given code block and start strategy. This function shall be invoked at most once on this coroutine.
start(start, receiver, block) - Method in class kotlinx.coroutines.AbstractCoroutine: Starts this coroutine with the given code block and start strategy. This function shall be invoked at most once on this coroutine.
start() - Method in interface kotlinx.coroutines.Job: Starts coroutine related to this job (if any) if it was not started yet. The result true if this invocation actually started coroutine or false if it was already started or completed.
start() - Method in class kotlinx.coroutines.NonCancellable: Always returns false.
startCoroutineCancellable($receiver, completion) - Static method in class kotlinx.coroutines.intrinsics.CancellableKt: Use this function to start coroutine in a cancellable way, so that it can be cancelled while waiting to be dispatched.
startCoroutineCancellable($receiver, receiver, completion) - Static method in class kotlinx.coroutines.intrinsics.CancellableKt: Use this function to start coroutine in a cancellable way, so that it can be cancelled while waiting to be dispatched.
startCoroutineUndispatched($receiver, completion) - Static method in class kotlinx.coroutines.intrinsics.UndispatchedKt: Use this function to start new coroutine in CoroutineStart.UNDISPATCHED mode — immediately execute coroutine in the current thread until next suspension. It does not use ContinuationInterceptor, but updates the context of the current thread for the new coroutine.
startCoroutineUndispatched($receiver, receiver, completion) - Static method in class kotlinx.coroutines.intrinsics.UndispatchedKt: Use this function to start new coroutine in CoroutineStart.UNDISPATCHED mode — immediately execute coroutine in the current thread until next suspension. It does not use ContinuationInterceptor, but updates the context of the current thread for the new coroutine.
startCoroutineUnintercepted($receiver, completion) - Static method in class kotlinx.coroutines.intrinsics.UndispatchedKt: Use this function to restart coroutine directly from inside of suspendCoroutine, when the code is already in the context of this coroutine. It does not use ContinuationInterceptor and does not update context of the current thread.
startCoroutineUnintercepted($receiver, receiver, completion) - Static method in class kotlinx.coroutines.intrinsics.UndispatchedKt: Use this function to restart coroutine directly from inside of suspendCoroutine, when the code is already in the context of this coroutine. It does not use ContinuationInterceptor and does not update context of the current thread.
startUndispatchedOrReturn($receiver, block) - Static method in class kotlinx.coroutines.intrinsics.UndispatchedKt: Starts this coroutine with the given code block in the same context and returns result when it completes without suspension. This function shall be invoked at most once on this coroutine.
startUndispatchedOrReturn($receiver, receiver, block) - Static method in class kotlinx.coroutines.intrinsics.UndispatchedKt: Starts this coroutine with the given code block in the same context and returns result when it completes without suspension. This function shall be invoked at most once on this coroutine.
SubscriptionReceiveChannel<T> - Interface in kotlinx.coroutines.channels: Deprecated.
SubscriptionReceiveChannel.DefaultImpls - Class in kotlinx.coroutines.channels: Deprecated.

Return type for BroadcastChannel.openSubscription that can be used to ReceiveChannel.receive elements from the open subscription and to SubscriptionReceiveChannel.close it to unsubscribe.

T

take($receiver, n, context) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing first n elements.
takeFirstReceiveOrPeekClosed() - Method in class kotlinx.coroutines.channels.AbstractChannel: Retrieves first receiving waiter from the queue or returns closed token.
takeWhile($receiver, context, predicate) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel containing first elements satisfying the given predicate.
TestCoroutineContext - Class in kotlinx.coroutines.test: This CoroutineContext dispatcher can be used to simulate virtual time to speed up code, especially tests, that deal with delays and timeouts in Coroutines.
TestCoroutineContext(name) - Constructor for class kotlinx.coroutines.test.TestCoroutineContext: This CoroutineContext dispatcher can be used to simulate virtual time to speed up code, especially tests, that deal with delays and timeouts in Coroutines.
TestCoroutineContext() - Constructor for class kotlinx.coroutines.test.TestCoroutineContext: This CoroutineContext dispatcher can be used to simulate virtual time to speed up code, especially tests, that deal with delays and timeouts in Coroutines.
TestCoroutineContextKt - Class in kotlinx.coroutines.test
ThreadContextElement<S> - Interface in kotlinx.coroutines: Defines elements in CoroutineContext that are installed into thread context every time the coroutine with this element in the context is resumed on a thread.
ThreadContextElementKt - Class in kotlinx.coroutines
ThreadPoolDispatcher - Class in kotlinx.coroutines: Dispatches coroutine execution to a thread pool of a fixed size. Instances of this dispatcher are created with ThreadPoolDispatcherKt.newSingleThreadContext and ThreadPoolDispatcherKt.newFixedThreadPoolContext.
ThreadPoolDispatcherKt - Class in kotlinx.coroutines
ticker(delay, unit, initialDelay, context, mode) - Static method in class kotlinx.coroutines.channels.TickerChannelsKt: Creates a channel that produces the first item after the given initial delay and subsequent items with the given delay between them.
TickerChannelsKt - Class in kotlinx.coroutines.channels
TickerMode - Enum in kotlinx.coroutines.channels: Mode for TickerChannelsKt.ticker function.
TickerMode() - Constructor for enum kotlinx.coroutines.channels.TickerMode: Mode for TickerChannelsKt.ticker function.
TimeoutCancellationException - Exception in kotlinx.coroutines: This exception is thrown by ScheduledKt.withTimeout to indicate timeout.
TimeoutCancellationException(message) - Constructor for exception kotlinx.coroutines.TimeoutCancellationException: Creates timeout exception with a given message.
TimeSourceKt - Class in kotlinx.coroutines
TimeUnitKt - Class in kotlinx.coroutines.timeunit
toChannel($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Send each element of the original channel and appends the results to the given destination.
toCollection($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Appends all elements to the given destination collection.
toList($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a List containing all elements.
toMap($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a Map filled with all elements of this channel.
toMap($receiver, destination, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a MutableMap filled with all elements of this channel.
toMutableList($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a MutableList filled with all elements of this channel.
toMutableSet($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a mutable set containing all distinct elements from the given channel.
toSet($receiver, p) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a Set of all elements.
toString() - Method in class kotlinx.coroutines.channels.AbstractSendChannel
toString() - Method in class kotlinx.coroutines.CommonPool
toString() - Method in class kotlinx.coroutines.CoroutineDispatcher
toString() - Method in class kotlinx.coroutines.CoroutineName: Returns a string representation of the object.
toString() - Method in exception kotlinx.coroutines.JobCancellationException
toString() - Method in class kotlinx.coroutines.NonDisposableHandle: Returns "NonDisposableHandle" string.
toString() - Method in class kotlinx.coroutines.test.TestCoroutineContext
toString() - Method in class kotlinx.coroutines.ThreadPoolDispatcher
toString() - Method in class kotlinx.coroutines.Unconfined
triggerActions() - Method in class kotlinx.coroutines.test.TestCoroutineContext: Triggers any actions that have not yet been triggered and that are scheduled to be triggered at or before this CoroutineContext's present virtual clock-time.
tryLock(owner) - Method in interface kotlinx.coroutines.sync.Mutex: Tries to lock this mutex, returning false if this mutex is already locked.

U

Unconfined - Class in kotlinx.coroutines: A coroutine dispatcher that is not confined to any specific thread. It executes initial continuation of the coroutine right here in the current call-frame and let the coroutine resume in whatever thread that is used by the corresponding suspending function, without mandating any specific threading policy.
UNDEFINED - Static variable in class kotlinx.coroutines.channels.ConflatedBroadcastChannel
UndispatchedKt - Class in kotlinx.coroutines.intrinsics
UNLIMITED - Static variable in class kotlinx.coroutines.channels.Channel.Factory: Requests channel with unlimited capacity buffer in Channel(...) factory function -- the class LinkedListChannel gets created.
UNLIMITED - Static variable in interface kotlinx.coroutines.channels.Channel: Requests channel with unlimited capacity buffer in Channel(...) factory function -- the class LinkedListChannel gets created.
unlock(owner) - Method in interface kotlinx.coroutines.sync.Mutex: Unlocks this mutex. Throws IllegalStateException if invoked on a mutex that is not locked.
updateThreadContext(context) - Method in interface kotlinx.coroutines.ThreadContextElement: Updates context of the current thread. This function is invoked before the coroutine in the specified context is resumed in the current thread when the context of the coroutine this element. The result of this function is the old value of the thread-local state that will be passed to ThreadContextElement.restoreThreadContext.

W

whileSelect(builder, p) - Static method in class kotlinx.coroutines.selects.WhileSelectKt: Loops while select expression returns true.
WhileSelectKt - Class in kotlinx.coroutines.selects
withContext(context, start, block, p) - Static method in class kotlinx.coroutines.BuildersKt: Calls the specified suspending block with a given coroutine context, suspends until it completes, and returns the result.
withIndex($receiver, context) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel of IndexedValue for each element of the original channel.
withTestContext(testContext, testBody) - Static method in class kotlinx.coroutines.test.TestCoroutineContextKt: Executes a block of code in which a unit-test can be written using the provided class TestCoroutineContext. The provided class TestCoroutineContext is available in the testBody as the this receiver.
withTimeout(time, block, p) - Static method in class kotlinx.coroutines.ScheduledKt: Runs a given suspending block of code inside a coroutine with a specified timeout and throws exception TimeoutCancellationException if timeout was exceeded.
withTimeout(time, unit, block, p) - Static method in class kotlinx.coroutines.ScheduledKt: Runs a given suspending block of code inside a coroutine with a specified timeout and throws exception TimeoutCancellationException if timeout was exceeded.
withTimeoutOrNull(time, block, p) - Static method in class kotlinx.coroutines.ScheduledKt: Runs a given suspending block of code inside a coroutine with a specified timeout and returns null if this timeout was exceeded.
withTimeoutOrNull(time, unit, block, p) - Static method in class kotlinx.coroutines.ScheduledKt: Runs a given suspending block of code inside a coroutine with a specified timeout and returns null if this timeout was exceeded.

Y

yield(p) - Static method in class kotlinx.coroutines.YieldKt: Yields a thread (or thread pool) of the current coroutine dispatcher to other coroutines to run. If the coroutine dispatcher does not have its own thread pool (like class Unconfined dispatcher) then this function does nothing, but checks if the coroutine interface Job was completed. This suspending function is cancellable. If the interface Job of the current coroutine is cancelled or completed when this suspending function is invoked or while this function is waiting for dispatching, it resumes with CancellationException.
YieldKt - Class in kotlinx.coroutines

Z

zip($receiver, other) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel of pairs built from elements of both channels with same indexes. Resulting channel has length of shortest input channel.
zip($receiver, other, context, transform) - Static method in class kotlinx.coroutines.channels.ChannelsKt: Returns a channel of values built from elements of both collections with same indexes using provided transform. Resulting channel has length of shortest input channels.

A B C D E F G H I J K L M N O P R S T U W Y Z