Index

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

A

AbstractChannel<E> - Class in kotlinx.coroutines.experimental.channels: Abstract send/receive channel. It is a base class for all channel implementations.
AbstractChannel() - Constructor for class kotlinx.coroutines.experimental.channels.AbstractChannel: Abstract send/receive channel. It is a base class for all channel implementations.
AbstractChannelKt - Class in kotlinx.coroutines.experimental.channels
AbstractContinuationKt - Class in kotlinx.coroutines.experimental
AbstractSendChannel<E> - Class in kotlinx.coroutines.experimental.channels: Abstract send channel. It is a base class for all send channel implementations.
AbstractSendChannel() - Constructor for class kotlinx.coroutines.experimental.channels.AbstractSendChannel: Abstract send channel. It is a base class for all send channel implementations.
actor(context, capacity, start, block) - Static method in class kotlinx.coroutines.experimental.channels.ActorKt: Launches new coroutine that is receiving messages from its mailbox channel and returns a reference to the coroutine as an interface ActorJob. The resulting object can be used to send messages to this coroutine.
ActorJob<E> - Interface in kotlinx.coroutines.experimental.channels: Return type for actor coroutine builder.
ActorKt - Class in kotlinx.coroutines.experimental.channels
ActorScope<E> - Interface in kotlinx.coroutines.experimental.channels: Scope for actor coroutine builder.
afterClose(cause) - Method in class kotlinx.coroutines.experimental.channels.AbstractSendChannel: Invoked after successful close.
ArrayBroadcastChannel<E> - Class in kotlinx.coroutines.experimental.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.experimental.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.experimental.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.experimental.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.
asCoroutineDispatcher($receiver) - Static method in class kotlinx.coroutines.experimental.ExecutorsKt: Converts an instance of Executor to an implementation of class CoroutineDispatcher.
async(context, start, block) - Static method in class kotlinx.coroutines.experimental.DeferredKt: Creates new coroutine and returns its future result as an implementation of interface Deferred.
attachChild(child) - Method in interface kotlinx.coroutines.experimental.Job: Attaches child job so that this job becomes its parent and returns a handle that should be used to detach it.
attachChild(child) - Method in class kotlinx.coroutines.experimental.NonCancellable: Always returns class NonDisposableHandle and does not do anything.
await($continuation) - Method in interface kotlinx.coroutines.experimental.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.

B

BroadcastChannel<E> - Interface in kotlinx.coroutines.experimental.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 SubscriptionReceiveChannel.close function.
BroadcastChannel(capacity) - Static method in class kotlinx.coroutines.experimental.channels.BroadcastChannelKt: Creates a broadcast channel with the specified buffer capacity.
BroadcastChannel.DefaultImpls - Class in kotlinx.coroutines.experimental.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 SubscriptionReceiveChannel.close function.
BroadcastChannelKt - Class in kotlinx.coroutines.experimental.channels
BuildersKt - Class in kotlinx.coroutines.experimental

C

cancel(cause) - Method in interface kotlinx.coroutines.experimental.Job: Cancels this job with an optional cancellation cause. The result is true if this job was cancelled as a result of this invocation and false otherwise (if it was already completed or if it is class NonCancellable). Repeated invocations of this function have no effect and always produce false.
cancel($receiver, cause) - Static method in class kotlinx.coroutines.experimental.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.experimental.NonCancellable: Always returns false.
cancelAndJoin($receiver, $continuation) - Static method in class kotlinx.coroutines.experimental.JobKt: Cancels the job and suspends invoking coroutine until the cancelled job is complete.
cancelChildren(cause) - Method in interface kotlinx.coroutines.experimental.Job: Cancels all Job.attachChild jobs of this coroutine with the given cause. Unlike cancel, the state of this job itself is not affected.
cancelChildren($receiver, cause) - Static method in class kotlinx.coroutines.experimental.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(cause) - Method in class kotlinx.coroutines.experimental.NonCancellable: Does not do anything.
cancelFutureOnCompletion($receiver, future) - Static method in class kotlinx.coroutines.experimental.JobKt: Cancels a specified future when this job is complete.
CancellableContinuation<T> - Interface in kotlinx.coroutines.experimental: Cancellable continuation. Its job is completed when it is resumed or cancelled. When cancel function is explicitly invoked, this continuation immediately resumes with CancellationException or with the specified cancel cause.
CancellableContinuationKt - Class in kotlinx.coroutines.experimental
CancellableKt - Class in kotlinx.coroutines.experimental
Channel<E> - Interface in kotlinx.coroutines.experimental.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.experimental.channels.ChannelKt: Creates a channel without a buffer -- class RendezvousChannel.
Channel(capacity) - Static method in class kotlinx.coroutines.experimental.channels.ChannelKt: Creates a channel with the specified buffer capacity (or without a buffer by default).
Channel.Factory - Class in kotlinx.coroutines.experimental.channels: Constants for channel factory function Channel().
ChannelIterator<E> - Interface in kotlinx.coroutines.experimental.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.experimental.channels
ChannelsKt - Class in kotlinx.coroutines.experimental.channels
close(cause) - Method in class kotlinx.coroutines.experimental.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. Immediately after invocation of this function isClosedForSend starts returning true. However, isClosedForReceive on the side of interface ReceiveChannel starts returning true only after all previously sent elements are received.
close(cause) - Method in class kotlinx.coroutines.experimental.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. Immediately after invocation of this function isClosedForSend starts returning true. However, isClosedForReceive on the side of interface ReceiveChannel starts returning true only after all previously sent elements are received.
close(cause) - Method in class kotlinx.coroutines.experimental.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. Immediately after invocation of this function isClosedForSend starts returning true. However, isClosedForReceive on the side of interface ReceiveChannel starts returning true only after all previously sent elements are received.
close(cause) - Method in interface kotlinx.coroutines.experimental.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. Immediately after invocation of this function isClosedForSend starts returning true. However, isClosedForReceive on the side of interface ReceiveChannel starts returning true only after all previously sent elements are received.
close() - Method in interface kotlinx.coroutines.experimental.channels.SubscriptionReceiveChannel: Closes this subscription.
close() - Method in class kotlinx.coroutines.experimental.ThreadPoolDispatcher: Closes this dispatcher -- shuts down all threads in this pool and releases resources.
CLOSED - Static variable in class kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel
ClosedReceiveChannelException - Exception in kotlinx.coroutines.experimental.channels: Indicates attempt to receive on isClosedForReceive channel that was closed without a cause. A failed channel rethrows the original close cause exception on receive attempts.
ClosedReceiveChannelException(message) - Constructor for exception kotlinx.coroutines.experimental.channels.ClosedReceiveChannelException: Indicates attempt to receive on isClosedForReceive channel that was closed without a cause. A failed channel rethrows the original close cause exception on receive attempts.
ClosedSendChannelException - Exception in kotlinx.coroutines.experimental.channels: Indicates attempt to send on isClosedForSend channel that was closed without a cause. A failed channel rethrows the original close cause exception on send attempts.
ClosedSendChannelException(message) - Constructor for exception kotlinx.coroutines.experimental.channels.ClosedSendChannelException: Indicates attempt to send on isClosedForSend channel that was closed without a cause. A failed channel rethrows the original close cause exception on send attempts.
CommonPool - Class in kotlinx.coroutines.experimental: Represents common pool of shared threads as coroutine dispatcher for compute-intensive tasks. It uses java.util.concurrent.ForkJoinPool when available, which implements efficient work-stealing algorithm for its queues, so every coroutine resumption is dispatched as a separate task even when it already executes inside the pool. When available, it wraps ForkJoinPool.commonPool and provides a similar shared pool where not.
Companion - Static variable in class kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel
CompletableDeferred<T> - Interface in kotlinx.coroutines.experimental: A interface Deferred that can be completed via public functions complete, completeExceptionally, and cancel.
CompletableDeferred() - Static method in class kotlinx.coroutines.experimental.CompletableDeferredKt: Creates a interface CompletableDeferred in an active state.
CompletableDeferred(value) - Static method in class kotlinx.coroutines.experimental.CompletableDeferredKt: Creates an already completed interface CompletableDeferred with a given value.
CompletableDeferredKt - Class in kotlinx.coroutines.experimental
complete(value) - Method in interface kotlinx.coroutines.experimental.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).
completeExceptionally(exception) - Method in interface kotlinx.coroutines.experimental.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).
CompletionHandlerException - Exception in kotlinx.coroutines.experimental: This exception gets thrown if an exception is caught while processing CompletionHandler invocation for interface Job.
CompletionHandlerException(message, cause) - Constructor for exception kotlinx.coroutines.experimental.CompletionHandlerException: This exception gets thrown if an exception is caught while processing CompletionHandler invocation for interface Job.
component1() - Method in class kotlinx.coroutines.experimental.CoroutineName: User-defined coroutine name.
CONFLATED - Static variable in interface kotlinx.coroutines.experimental.channels.Channel: Requests conflated channel in Channel(...) factory function -- the class ConflatedChannel gets created.
CONFLATED - Static variable in class kotlinx.coroutines.experimental.channels.Channel.Factory: Requests conflated channel in Channel(...) factory function -- the class ConflatedChannel gets created.
ConflatedBroadcastChannel<E> - Class in kotlinx.coroutines.experimental.channels: Broadcasts the most recently sent element (aka value) to all ConflatedBroadcastChannel.openSubscription subscribers.
ConflatedBroadcastChannel() - Constructor for class kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel: Broadcasts the most recently sent element (aka value) to all ConflatedBroadcastChannel.openSubscription subscribers.
ConflatedBroadcastChannel(value) - Constructor for class kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel: Creates an instance of this class that already holds a value.
ConflatedChannel<E> - Class in kotlinx.coroutines.experimental.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.experimental.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.
consumeEach($receiver, action, $continuation) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Performs the given action for each received element.
consumeEach($receiver, action, $continuation) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Subscribes to this interface BroadcastChannel and performs the specified action for each received element.
copy(name) - Method in class kotlinx.coroutines.experimental.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.experimental
CoroutineDispatcher - Class in kotlinx.coroutines.experimental: Base class that shall be extended by all coroutine dispatcher implementations.
CoroutineDispatcher() - Constructor for class kotlinx.coroutines.experimental.CoroutineDispatcher: Base class that shall be extended by all coroutine dispatcher implementations.
CoroutineDispatcherKt - Class in kotlinx.coroutines.experimental
CoroutineExceptionHandler - Interface in kotlinx.coroutines.experimental: An optional element on the coroutine context to handle uncaught exceptions.
CoroutineExceptionHandler(handler) - Static method in class kotlinx.coroutines.experimental.CoroutineExceptionHandlerKt: Creates new interface CoroutineExceptionHandler instance.
CoroutineExceptionHandler.Key - Class in kotlinx.coroutines.experimental: Key for interface CoroutineExceptionHandler instance in the coroutine context.
CoroutineExceptionHandlerKt - Class in kotlinx.coroutines.experimental
CoroutineName - Class in kotlinx.coroutines.experimental: 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.experimental.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.experimental: Key for class CoroutineName instance in the coroutine context.
CoroutineScope - Interface in kotlinx.coroutines.experimental: Receiver interface for generic coroutine builders, so that the code inside coroutine has a convenient access to its coroutineContext and its cancellation status via isActive.
CoroutineScope.DefaultImpls - Class in kotlinx.coroutines.experimental: Receiver interface for generic coroutine builders, so that the code inside coroutine has a convenient access to its coroutineContext and its cancellation status via isActive.
CoroutineStart - Enum in kotlinx.coroutines.experimental: Defines start option for coroutines builders. It is used in start parameter of launch, async, and actor coroutine builder functions.
CoroutineStart() - Constructor for enum kotlinx.coroutines.experimental.CoroutineStart: Defines start option for coroutines builders. It is used in start parameter of launch, async, and actor coroutine builder functions.

D

DebugKt - Class in kotlinx.coroutines.experimental
Deferred<T> - Interface in kotlinx.coroutines.experimental: Deferred value is a non-blocking cancellable future.
Deferred.DefaultImpls - Class in kotlinx.coroutines.experimental: Deferred value is a non-blocking cancellable future.
DeferredKt - Class in kotlinx.coroutines.experimental
Delay - Interface in kotlinx.coroutines.experimental: This dispatcher feature is implemented by class CoroutineDispatcher implementations that natively support scheduled execution of tasks.
delay($this, time, unit, $continuation) - Static method in class kotlinx.coroutines.experimental.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, $continuation) - Method in interface kotlinx.coroutines.experimental.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, unit, $continuation) - Static method in class kotlinx.coroutines.experimental.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.experimental: This dispatcher feature is implemented by class CoroutineDispatcher implementations that natively support scheduled execution of tasks.
DelayKt - Class in kotlinx.coroutines.experimental
dispatch(context, block) - Method in class kotlinx.coroutines.experimental.CommonPool: Dispatches execution of a runnable block onto another thread in the given context.
dispatch(context, block) - Method in class kotlinx.coroutines.experimental.CoroutineDispatcher: Dispatches execution of a runnable block onto another thread in the given context.
dispatch(context, block) - Method in class kotlinx.coroutines.experimental.Unconfined: Dispatches execution of a runnable block onto another thread in the given context.
DisposableFutureHandle - Class in kotlinx.coroutines.experimental: An implementation of interface DisposableHandle that cancels the specified future on dispose.
DisposableFutureHandle(future) - Constructor for class kotlinx.coroutines.experimental.DisposableFutureHandle: An implementation of interface DisposableHandle that cancels the specified future on dispose.
DisposableHandle - Interface in kotlinx.coroutines.experimental: A handle to an allocated object that can be disposed to make it eligible for garbage collection.
DisposableHandle.DefaultImpls - Class in kotlinx.coroutines.experimental: A handle to an allocated object that can be disposed to make it eligible for garbage collection.
dispose() - Method in class kotlinx.coroutines.experimental.DisposableFutureHandle: Disposes the corresponding object, making it eligible for garbage collection. Repeated invocation of this function has no effect.
dispose() - Method in interface kotlinx.coroutines.experimental.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.experimental.NonDisposableHandle: Does not do anything.
disposeOnCompletion($receiver, handle) - Static method in class kotlinx.coroutines.experimental.JobKt: Disposes a specified handle when this job is complete.

E

equals(p) - Method in class kotlinx.coroutines.experimental.CoroutineName
equals(other) - Method in exception kotlinx.coroutines.experimental.JobCancellationException
EventLoop - Interface in kotlinx.coroutines.experimental: 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.experimental.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.experimental
ExecutorsKt - Class in kotlinx.coroutines.experimental

F

Factory - Static variable in interface kotlinx.coroutines.experimental.channels.Channel: Constants for channel factory function Channel().
fold($this, initial, operation) - Static method in class kotlinx.coroutines.experimental.Deferred.DefaultImpls
fold($this, initial, operation) - Static method in class kotlinx.coroutines.experimental.Job.DefaultImpls

G

get($this, key) - Static method in class kotlinx.coroutines.experimental.Deferred.DefaultImpls
get($this, key) - Static method in class kotlinx.coroutines.experimental.Job.DefaultImpls
getCancellationException() - Method in interface kotlinx.coroutines.experimental.Job: Returns CancellationException that signals the completion of this job.
getCancellationException() - Method in class kotlinx.coroutines.experimental.NonCancellable: Always throws IllegalStateException.
getCapacity() - Method in class kotlinx.coroutines.experimental.channels.ArrayBroadcastChannel: Buffer capacity.
getCapacity() - Method in class kotlinx.coroutines.experimental.channels.ArrayChannel: Buffer capacity.
getChannel() - Method in interface kotlinx.coroutines.experimental.channels.ActorJob: A reference to the mailbox channel that this coroutine is receiving messages from. All the interface SendChannel functions on this interface delegate to the channel instance returned by this function.
getChannel() - Method in interface kotlinx.coroutines.experimental.channels.ActorScope: A reference to the mailbox channel that this coroutine receives 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.experimental.channels.ProducerJob: A reference to the channel that this coroutine is producing. All the interface ReceiveChannel functions on this interface delegate to the channel instance returned by this function.
getChannel() - Method in interface kotlinx.coroutines.experimental.channels.ProducerScope: A reference to the channel that this coroutine sends 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.
getCompleted() - Method in interface kotlinx.coroutines.experimental.Deferred: Returns completed result or throws IllegalStateException if this deferred value has not completed yet. It throws the corresponding exception if this deferred has completed exceptionally.
getCompletionException($this) - Static method in class kotlinx.coroutines.experimental.Deferred.DefaultImpls: Deprecated.
getCompletionExceptionOrNull() - Method in interface kotlinx.coroutines.experimental.Deferred: Returns completion exception result if this deferred completed exceptionally, null if it is completed normally, or throws IllegalStateException if this deferred value has not completed yet.
getCoroutineContext($this) - Static method in class kotlinx.coroutines.experimental.CoroutineScope.DefaultImpls: Returns the context of this coroutine.
getCoroutineContext() - Method in interface kotlinx.coroutines.experimental.CoroutineScope: Returns the context of this coroutine.
getDefaultDispatcher() - Static method in class kotlinx.coroutines.experimental.CoroutineContextKt: This is the default class CoroutineDispatcher that is used by all standard builders like launch, async, etc if no dispatcher nor any other ContinuationInterceptor is specified in their context.
getJob() - Method in exception kotlinx.coroutines.experimental.JobCancellationException: The job that was cancelled.
getName() - Method in class kotlinx.coroutines.experimental.CoroutineName: User-defined coroutine name.
getOnAwait() - Method in interface kotlinx.coroutines.experimental.Deferred: Clause for select expression of 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.experimental.Job: Clause for select expression of 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.experimental.NonCancellable: Clause for select expression of 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.experimental.sync.Mutex: Clause for select expression of lock suspending function that selects when the mutex is locked. Additional parameter for the clause in the owner (see lock) and when the clause is selected the reference to this mutex is passed into the corresponding block.
getOnReceive() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Clause for select expression of receive suspending function that selects with the element that is received from the channel. The select invocation fails with exception if the channel isClosedForReceive (see close for details).
getOnReceive() - Method in interface kotlinx.coroutines.experimental.channels.ReceiveChannel: Clause for select expression of receive suspending function that selects with the element that is received from the channel. The select invocation fails with exception if the channel isClosedForReceive (see close for details).
getOnReceiveOrNull() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Clause for select expression of receiveOrNull suspending function that selects with the element that is received from the channel or selects with null if if the channel isClosedForReceive without cause. The select invocation fails with the original close cause exception if the channel has failed.
getOnReceiveOrNull() - Method in interface kotlinx.coroutines.experimental.channels.ReceiveChannel: Clause for select expression of receiveOrNull suspending function that selects with the element that is received from the channel or selects with null if if the channel isClosedForReceive without cause. The select invocation fails with the original close cause exception if the channel has failed.
getOnSend() - Method in class kotlinx.coroutines.experimental.channels.AbstractSendChannel: Clause for select expression of 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.experimental.channels.ConflatedBroadcastChannel: Clause for select expression of 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.experimental.channels.SendChannel: Clause for select expression of 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.experimental.channels.ConflatedBroadcastChannel: The most recently sent element to this channel.
getValueOrNull() - Method in class kotlinx.coroutines.experimental.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 closed.

H

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

I

initCancellability() - Method in interface kotlinx.coroutines.experimental.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.experimental.channels.ConflatedBroadcastChannel
INSTANCE - Static variable in class kotlinx.coroutines.experimental.CommonPool: Represents common pool of shared threads as coroutine dispatcher for compute-intensive tasks. It uses java.util.concurrent.ForkJoinPool when available, which implements efficient work-stealing algorithm for its queues, so every coroutine resumption is dispatched as a separate task even when it already executes inside the pool. When available, it wraps ForkJoinPool.commonPool and provides a similar shared pool where not.
INSTANCE - Static variable in class kotlinx.coroutines.experimental.NonCancellable: A non-cancelable job that is always active. It is designed to be used with run builder to prevent cancellation of code blocks that need to run without cancellation.
INSTANCE - Static variable in class kotlinx.coroutines.experimental.NonDisposableHandle: No-op implementation of interface DisposableHandle.
INSTANCE - Static variable in class kotlinx.coroutines.experimental.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.experimental.CoroutineDispatcher: Returns continuation that wraps the original continuation, thus intercepting all resumptions.
invoke(block, completion) - Method in enum kotlinx.coroutines.experimental.CoroutineStart: Starts the corresponding block as a coroutine with this coroutine start strategy.
invoke(block, receiver, completion) - Method in enum kotlinx.coroutines.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.
invokeOnCompletion(onCancelling, handler) - Method in interface kotlinx.coroutines.experimental.Job: Registers handler that is synchronously invoked once on cancellation or completion of this job. When job is already complete, then the handler is immediately invoked with a job's cancellation cause or null. Otherwise, handler will be invoked once when this job is cancelled or complete.
invokeOnCompletion(onCancelling, handler) - Method in class kotlinx.coroutines.experimental.NonCancellable: Always returns class NonDisposableHandle.
invokeOnTimeout($this, time, unit, block) - Static method in class kotlinx.coroutines.experimental.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.experimental.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.
isActive() - Method in interface kotlinx.coroutines.experimental.CoroutineScope: Returns true when this coroutine is still active (has not completed and was not cancelled yet).
isActive() - Method in interface kotlinx.coroutines.experimental.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.attachChild to complete is still considered to be active if it was not cancelled.
isActive() - Method in class kotlinx.coroutines.experimental.NonCancellable: Always returns true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.experimental.channels.ArrayChannel: Returns true if isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.experimental.channels.ConflatedChannel: Returns true if isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.experimental.channels.LinkedListChannel: Returns true if isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.experimental.channels.RendezvousChannel: Returns true if isBufferEmpty is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.ArrayBroadcastChannel: Returns true if isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.ArrayChannel: Returns true if isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.ConflatedChannel: Returns true if isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.LinkedListChannel: Returns true if isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.RendezvousChannel: Returns true if isBufferFull is always true.
isBufferEmpty() - Method in class kotlinx.coroutines.experimental.channels.ArrayChannel: Returns true if this channel's buffer is empty.
isBufferEmpty() - Method in class kotlinx.coroutines.experimental.channels.ConflatedChannel: Returns true if this channel's buffer is empty.
isBufferEmpty() - Method in class kotlinx.coroutines.experimental.channels.LinkedListChannel: Returns true if this channel's buffer is empty.
isBufferEmpty() - Method in class kotlinx.coroutines.experimental.channels.RendezvousChannel: Returns true if this channel's buffer is empty.
isBufferFull() - Method in class kotlinx.coroutines.experimental.channels.ArrayBroadcastChannel: Returns true if this channel's buffer is full.
isBufferFull() - Method in class kotlinx.coroutines.experimental.channels.ArrayChannel: Returns true if this channel's buffer is full.
isBufferFull() - Method in class kotlinx.coroutines.experimental.channels.ConflatedChannel: Returns true if this channel's buffer is full.
isBufferFull() - Method in class kotlinx.coroutines.experimental.channels.LinkedListChannel: Returns true if this channel's buffer is full.
isBufferFull() - Method in class kotlinx.coroutines.experimental.channels.RendezvousChannel: Returns true if this channel's buffer is full.
isCancelled() - Method in interface kotlinx.coroutines.experimental.CancellableContinuation: Returns true if this continuation was cancelled.
isCancelled() - Method in interface kotlinx.coroutines.experimental.Job: Returns true if this job was cancelled. In the general case, it does not imply that the job has already completed (it may still be cancelling whatever it was doing).
isCancelled() - Method in class kotlinx.coroutines.experimental.NonCancellable: Always returns false.
isClosedForReceive() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Returns true if this channel was closed by invocation of close on the interface SendChannel side and all previously sent items were already received, so that the 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 close cause exception.
isClosedForReceive() - Method in interface kotlinx.coroutines.experimental.channels.ReceiveChannel: Returns true if this channel was closed by invocation of close on the interface SendChannel side and all previously sent items were already received, so that the 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 close cause exception.
isClosedForSend() - Method in class kotlinx.coroutines.experimental.channels.AbstractSendChannel: Returns true if this channel was closed by invocation of close and thus the send and offer attempts throws exception.
isClosedForSend() - Method in class kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel: Returns true if this channel was closed by invocation of close and thus the send and offer attempts throws exception.
isClosedForSend() - Method in interface kotlinx.coroutines.experimental.channels.SendChannel: Returns true if this channel was closed by invocation of close and thus the send and offer attempts throws exception.
isCompleted() - Method in interface kotlinx.coroutines.experimental.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.attachChild complete.
isCompleted() - Method in class kotlinx.coroutines.experimental.NonCancellable: Always returns false.
isCompletedExceptionally() - Method in interface kotlinx.coroutines.experimental.Deferred: Returns true if computation of this deferred value has completed exceptionally -- it had either failed with exception during computation or was cancelled.
isDispatchNeeded(context) - Method in class kotlinx.coroutines.experimental.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.experimental.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.experimental.channels.AbstractChannel: Returns true if the channel is empty (contains no elements) and the receive attempt will suspend. This function returns false for isClosedForReceive channel.
isEmpty() - Method in interface kotlinx.coroutines.experimental.channels.ReceiveChannel: Returns true if the channel is empty (contains no elements) and the receive attempt will suspend. This function returns false for isClosedForReceive channel.
isFull() - Method in class kotlinx.coroutines.experimental.channels.AbstractSendChannel: Returns true if the channel is full (out of capacity) and the send attempt will suspend. This function returns false for isClosedForSend channel.
isFull() - Method in class kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel: Returns true if the channel is full (out of capacity) and the send attempt will suspend. This function returns false for isClosedForSend channel.
isFull() - Method in interface kotlinx.coroutines.experimental.channels.SendChannel: Returns true if the channel is full (out of capacity) and the send attempt will suspend. This function returns false for isClosedForSend channel.
isLazy() - Method in enum kotlinx.coroutines.experimental.CoroutineStart: Returns true when LAZY.
isLocked() - Method in interface kotlinx.coroutines.experimental.sync.Mutex: Returns true when this mutex is locked.
iterator() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Returns new iterator to receive elements from this channels using for loop. Iteration completes normally when the channel is isClosedForReceive without cause and throws the original close cause exception if the channel has failed.
iterator() - Method in interface kotlinx.coroutines.experimental.channels.ReceiveChannel: Returns new iterator to receive elements from this channels using for loop. Iteration completes normally when the channel is isClosedForReceive without cause and throws the original close cause exception if the channel has failed.

J

Job - Interface in kotlinx.coroutines.experimental: 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 children.
Job(parent) - Static method in class kotlinx.coroutines.experimental.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.experimental: 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 children.
Job.Key - Class in kotlinx.coroutines.experimental: Key for interface Job instance in the coroutine context.
JobCancellationException - Exception in kotlinx.coroutines.experimental: 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, job) - Constructor for exception kotlinx.coroutines.experimental.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.experimental
join($continuation) - Method in interface kotlinx.coroutines.experimental.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 active. This function also Job.start the corresponding coroutine if the interface Job was still in new state.
join($continuation) - Method in class kotlinx.coroutines.experimental.NonCancellable: Always throws UnsupportedOperationException.

K

Key - Static variable in interface kotlinx.coroutines.experimental.CoroutineExceptionHandler: Key for interface CoroutineExceptionHandler instance in the coroutine context.
Key - Static variable in class kotlinx.coroutines.experimental.CoroutineName: Key for class CoroutineName instance in the coroutine context.
Key - Static variable in interface kotlinx.coroutines.experimental.Job: Key for interface Job instance in the coroutine context.
kotlinx.coroutines.experimental - package kotlinx.coroutines.experimental: General-purpose coroutine builders, contexts, and helper functions.
kotlinx.coroutines.experimental.channels - package kotlinx.coroutines.experimental.channels: Channels -- non-blocking primitives for communicating a stream of elements between coroutines.
kotlinx.coroutines.experimental.selects - package kotlinx.coroutines.experimental.selects: Select expression to perform multiple suspending operations simultaneously until one of them succeeds.
kotlinx.coroutines.experimental.sync - package kotlinx.coroutines.experimental.sync: Synchronization primitives (mutex).

L

launch(context, start, block) - Static method in class kotlinx.coroutines.experimental.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 cancelled.
LazyDeferredKt - Class in kotlinx.coroutines.experimental
LinkedListChannel<E> - Class in kotlinx.coroutines.experimental.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.experimental.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, $continuation) - Method in interface kotlinx.coroutines.experimental.sync.Mutex: Locks this mutex, suspending caller while the mutex is locked.

M

minusKey($this, key) - Static method in class kotlinx.coroutines.experimental.Deferred.DefaultImpls
minusKey($this, key) - Static method in class kotlinx.coroutines.experimental.Job.DefaultImpls
Mutex - Interface in kotlinx.coroutines.experimental.sync: Mutual exclusion for coroutines.
Mutex(locked) - Static method in class kotlinx.coroutines.experimental.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.experimental.sync

N

newCoroutineContext(context) - Static method in class kotlinx.coroutines.experimental.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.experimental.ThreadPoolDispatcherKt: Creates new coroutine execution context with the fixed-size thread-pool and built-in yield and 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.experimental.ThreadPoolDispatcherKt: Creates new coroutine execution context with the a single thread and built-in yield and delay support. NOTE: The resulting class ThreadPoolDispatcher owns native resources (its thread).Resources are reclaimed by ThreadPoolDispatcher.close.
next($continuation) - Method in interface kotlinx.coroutines.experimental.channels.ChannelIterator: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or throws exception ClosedReceiveChannelException if the channel isClosedForReceive without cause. It throws the original close cause exception if the channel has failed.
NonCancellable - Class in kotlinx.coroutines.experimental: A non-cancelable job that is always active. It is designed to be used with run builder to prevent cancellation of code blocks that need to run without cancellation.
NonDisposableHandle - Class in kotlinx.coroutines.experimental: No-op implementation of interface DisposableHandle.

O

offer(element) - Method in class kotlinx.coroutines.experimental.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 isClosedForSend (see close for details).
offer(element) - Method in class kotlinx.coroutines.experimental.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 isClosedForSend (see close for details).
offer(element) - Method in interface kotlinx.coroutines.experimental.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 isClosedForSend (see close for details).
offerInternal(element) - Method in class kotlinx.coroutines.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.
onCancelledReceive() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Invoked when enqueued receiver was successfully cancelled.
onEnqueuedReceive() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Invoked when receiver is successfully enqueued to the queue of waiting receivers.
onTimeout(time, unit, block) - Method in interface kotlinx.coroutines.experimental.selects.SelectBuilder: Clause that selects the given block after a specified timeout passes.
openSubscription() - Method in class kotlinx.coroutines.experimental.channels.ArrayBroadcastChannel: Subscribes to this interface BroadcastChannel and returns a channel to receive elements from it. The resulting channel shall be SubscriptionReceiveChannel.close to unsubscribe from this broadcast channel.
openSubscription() - Method in interface kotlinx.coroutines.experimental.channels.BroadcastChannel: Subscribes to this interface BroadcastChannel and returns a channel to receive elements from it. The resulting channel shall be SubscriptionReceiveChannel.close to unsubscribe from this broadcast channel.
openSubscription() - Method in class kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel: Subscribes to this interface BroadcastChannel and returns a channel to receive elements from it. The resulting channel shall be SubscriptionReceiveChannel.close to unsubscribe from this broadcast channel.

P

plus($this, other) - Static method in class kotlinx.coroutines.experimental.Deferred.DefaultImpls: Deprecated.
plus($this, context) - Static method in class kotlinx.coroutines.experimental.Deferred.DefaultImpls
plus($this, context) - Static method in class kotlinx.coroutines.experimental.Job.DefaultImpls
poll() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Retrieves and removes the element from this channel, or returns null if this channel isEmpty or is isClosedForReceive without cause. It throws the original close cause exception if the channel has failed.
poll() - Method in interface kotlinx.coroutines.experimental.channels.ReceiveChannel: Retrieves and removes the element from this channel, or returns null if this channel isEmpty or is isClosedForReceive without cause. It throws the original close cause exception if the channel has failed.
pollInternal() - Method in class kotlinx.coroutines.experimental.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.experimental.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.experimental.EventLoop: Processes next event in this event loop.
produce(context, capacity, block) - Static method in class kotlinx.coroutines.experimental.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 ProducerJob. This resulting object can be used to receive elements produced by this coroutine.
ProduceKt - Class in kotlinx.coroutines.experimental.channels
ProducerJob<E> - Interface in kotlinx.coroutines.experimental.channels: Return type for produce coroutine builder.
ProducerScope<E> - Interface in kotlinx.coroutines.experimental.channels: Scope for produce coroutine builder.

R

receive($continuation) - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or throws exception ClosedReceiveChannelException if the channel isClosedForReceive. If the channel was closed because of the exception, it is called a failed channel and this function throws the original close cause exception.
receive($continuation) - Method in interface kotlinx.coroutines.experimental.channels.ReceiveChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or throws exception ClosedReceiveChannelException if the channel isClosedForReceive. If the channel was closed because of the exception, it is called a failed channel and this function throws the original close cause exception.
ReceiveChannel<E> - Interface in kotlinx.coroutines.experimental.channels: Receiver's interface to interface Channel.
receiveOrNull($continuation) - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or returns null if the channel is closed without cause or throws the original close cause exception if the channel has failed.
receiveOrNull($continuation) - Method in interface kotlinx.coroutines.experimental.channels.ReceiveChannel: Retrieves and removes the element from this channel suspending the caller while this channel isEmpty or returns null if the channel is closed without cause or throws the original close cause exception if the channel has failed.
RendezvousChannel<E> - Class in kotlinx.coroutines.experimental.channels: Rendezvous channel. This channel does not have any buffer at all. An element is transferred from sender to receiver only when send and receive invocations meet in time (rendezvous), so send suspends until another coroutine invokes receive and receive suspends until another coroutine invokes send.
RendezvousChannel() - Constructor for class kotlinx.coroutines.experimental.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 receive invocations meet in time (rendezvous), so send suspends until another coroutine invokes receive and receive suspends until another coroutine invokes send.
resumeMode($receiver, value, mode) - Static method in class kotlinx.coroutines.experimental.ResumeModeKt
ResumeModeKt - Class in kotlinx.coroutines.experimental
resumeUndispatched($receiver, value) - Method in interface kotlinx.coroutines.experimental.CancellableContinuation: Resumes this continuation with a given value in the invoker thread without going though 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.experimental.CancellableContinuation: Resumes this continuation with a given exception in the invoker thread without going though 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.
resumeWithExceptionMode($receiver, exception, mode) - Static method in class kotlinx.coroutines.experimental.ResumeModeKt
run(context, start, block, $continuation) - Static method in class kotlinx.coroutines.experimental.BuildersKt: Calls the specified suspending block with a given coroutine context, suspends until it completes, and returns the result.
runBlocking(context, block) - Static method in class kotlinx.coroutines.experimental.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.

S

ScheduledKt - Class in kotlinx.coroutines.experimental
scheduleResumeAfterDelay(time, unit, continuation) - Method in interface kotlinx.coroutines.experimental.Delay: Schedules resume of a specified continuation after a specified delay time.
select(builder, $continuation) - Static method in class kotlinx.coroutines.experimental.selects.SelectKt: Waits for the result of multiple suspending functions simultaneously, which are specified using clauses in the builder scope of this select invocation. The caller is suspended until one of the clauses is either selected or fails.
SelectBuilder<R> - Interface in kotlinx.coroutines.experimental.selects: Scope for select invocation.
SelectBuilder.DefaultImpls - Class in kotlinx.coroutines.experimental.selects: Scope for select invocation.
SelectClause0 - Interface in kotlinx.coroutines.experimental.selects: Clause for select expression without additional parameters that does not select any value.
SelectClause1<Q> - Interface in kotlinx.coroutines.experimental.selects: Clause for select expression without additional parameters that selects value of type Q.
SelectClause2<P,Q> - Interface in kotlinx.coroutines.experimental.selects: Clause for select expression with additional parameter of type P that selects value of type Q.
SelectKt - Class in kotlinx.coroutines.experimental.selects
selectUnbiased(builder, $continuation) - Static method in class kotlinx.coroutines.experimental.selects.SelectUnbiasedKt: Waits for the result of multiple suspending functions simultaneously like select, but in an unbiased way when multiple clauses are selectable at the same time.
SelectUnbiasedKt - Class in kotlinx.coroutines.experimental.selects
send(element, $continuation) - Method in class kotlinx.coroutines.experimental.channels.AbstractSendChannel: Adds element into to this channel, suspending the caller while this channel isFull, or throws exception if the channel isClosedForSend (see close for details).
send(element, $continuation) - Method in class kotlinx.coroutines.experimental.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 isClosedForSend (see close for details).
send(element, $continuation) - Method in interface kotlinx.coroutines.experimental.channels.SendChannel: Adds element into to this channel, suspending the caller while this channel isFull, or throws exception if the channel isClosedForSend (see close for details).
SendChannel<E> - Interface in kotlinx.coroutines.experimental.channels: Sender's interface to interface Channel.
start() - Method in interface kotlinx.coroutines.experimental.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.experimental.NonCancellable: Always returns false.
SubscriptionReceiveChannel<T> - Interface in kotlinx.coroutines.experimental.channels: Return type for BroadcastChannel.openSubscription that can be used to receive elements from the open subscription and to SubscriptionReceiveChannel.close it to unsubscribe.
suspendAtomicCancellableCoroutine(holdCancellability, block, $continuation) - Static method in class kotlinx.coroutines.experimental.CancellableContinuationKt: Suspends coroutine similar to suspendCancellableCoroutine, but with atomic cancellation.
suspendCancellableCoroutine(holdCancellability, block, $continuation) - Static method in class kotlinx.coroutines.experimental.CancellableContinuationKt: Suspends coroutine similar to suspendCoroutine, but provide an implementation of interface CancellableContinuation to the block. This function throws CancellationException if the coroutine is cancelled or completed while suspended.

T

ThreadPoolDispatcher - Class in kotlinx.coroutines.experimental: Dispatches coroutine execution to a thread pool of a fixed size. Instances of this dispatcher are created with newSingleThreadContext and newFixedThreadPoolContext.
ThreadPoolDispatcherKt - Class in kotlinx.coroutines.experimental
TimeoutCancellationException - Exception in kotlinx.coroutines.experimental: This exception is thrown by withTimeout to indicate timeout.
TimeoutCancellationException(message) - Constructor for exception kotlinx.coroutines.experimental.TimeoutCancellationException: Creates timeout exception with a given message.
TimeSourceKt - Class in kotlinx.coroutines.experimental
toString() - Method in class kotlinx.coroutines.experimental.CommonPool
toString() - Method in class kotlinx.coroutines.experimental.CoroutineDispatcher
toString() - Method in class kotlinx.coroutines.experimental.CoroutineName: Returns a string representation of the object.
toString() - Method in class kotlinx.coroutines.experimental.DisposableFutureHandle
toString() - Method in exception kotlinx.coroutines.experimental.JobCancellationException
toString() - Method in class kotlinx.coroutines.experimental.NonDisposableHandle: Returns "NonDisposableHandle" string.
toString() - Method in class kotlinx.coroutines.experimental.ThreadPoolDispatcher
toString() - Method in class kotlinx.coroutines.experimental.Unconfined
tryLock(owner) - Method in interface kotlinx.coroutines.experimental.sync.Mutex: Tries to lock this mutex, returning false if this mutex is already locked.

U

Unconfined - Class in kotlinx.coroutines.experimental: 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.experimental.channels.ConflatedBroadcastChannel
UNLIMITED - Static variable in class kotlinx.coroutines.experimental.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.experimental.channels.Channel: Requests channel with unlimited capacity buffer in Channel(...) factory function -- the class LinkedListChannel gets created.
unlock(owner) - Method in interface kotlinx.coroutines.experimental.sync.Mutex: Unlocks this mutex. Throws IllegalStateException if invoked on a mutex that is not locked.

W

whileSelect(builder, $continuation) - Static method in class kotlinx.coroutines.experimental.selects.WhileSelectKt: Loops while select expression returns true.
WhileSelectKt - Class in kotlinx.coroutines.experimental.selects
withLock($receiver, owner, action, $continuation) - Static method in class kotlinx.coroutines.experimental.sync.MutexKt: Executes the given action under this mutex's lock.
withTimeout(time, unit, block, $continuation) - Static method in class kotlinx.coroutines.experimental.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, unit, block, $continuation) - Static method in class kotlinx.coroutines.experimental.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($continuation) - Static method in class kotlinx.coroutines.experimental.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.experimental

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