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.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, parent, 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 ActorJob. The resulting object can be used to SendChannel.send messages to this coroutine.
ActorKt - Class in kotlinx.coroutines.experimental.channels
ActorScope<E> - Interface in kotlinx.coroutines.experimental.channels: Scope for ActorKt.actor coroutine builder.
afterClose(cause) - Method in class kotlinx.coroutines.experimental.channels.AbstractSendChannel: Invoked after successful AbstractSendChannel.close.
any($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns true if channel has at least one element.
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.
asReceiveChannel($receiver, context) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel to read all element of the Iterable.
asReceiveChannel($receiver, context) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel to read all element of the Sequence.
async(context, start, parent, 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 class kotlinx.coroutines.experimental.NonCancellable: Always returns class NonDisposableHandle and does not do anything.
await(p) - 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.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.experimental.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 interface kotlinx.coroutines.experimental.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.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, p) - Static method in class kotlinx.coroutines.experimental.JobKt: Cancels the job and suspends invoking coroutine until the cancelled job is complete.
cancelChildren($receiver, cause) - Static method in class kotlinx.coroutines.experimental.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.
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.
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 CancellableContinuation.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
cleanupSendQueueOnCancel() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel
cleanupSendQueueOnCancel() - Method in class kotlinx.coroutines.experimental.channels.ArrayChannel
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.
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.
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.
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.
close() - Method in interface kotlinx.coroutines.experimental.channels.SubscriptionReceiveChannel: Closes this subscription. This is a synonym for ReceiveChannel.cancel.
close($this) - Static method in class kotlinx.coroutines.experimental.channels.SubscriptionReceiveChannel.DefaultImpls: Closes this subscription. This is a synonym for ReceiveChannel.cancel.
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 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.experimental.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.experimental.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.experimental.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.
CommonCompletionHandlerKt - Class in kotlinx.coroutines.experimental
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: Deprecated.
CompletableDeferred<T> - Interface in kotlinx.coroutines.experimental: A interface Deferred that can be completed via public functions CompletableDeferred.complete, CompletableDeferred.completeExceptionally, and cancel.
CompletableDeferred(parent) - Static method in class kotlinx.coroutines.experimental.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.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 ConflatedBroadcastChannel.getValue) to all ConflatedBroadcastChannel.openSubscription subscribers.
ConflatedBroadcastChannel() - Constructor for class kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel: Broadcasts the most recently sent element (aka ConflatedBroadcastChannel.getValue) 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.
consume($receiver, block) - Static method in class kotlinx.coroutines.experimental.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.experimental.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.
copy(name) - Method in class kotlinx.coroutines.experimental.CoroutineName: User-specified name of coroutine. This name is used in debugging mode. See CoroutineContextKt.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 CoroutineContextKt.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 CoroutineContextKt.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 CoroutineScope.getCoroutineContext and its cancellation status via CoroutineScope.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 CoroutineScope.getCoroutineContext and its cancellation status via CoroutineScope.isActive.
CoroutineStart - Enum in kotlinx.coroutines.experimental: Defines start option for coroutines builders. It is used in start parameter of launch, async, and ActorKt.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 ActorKt.actor coroutine builder functions.
count($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns the number of elements in this channel.

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, p) - 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, p) - 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, p) - 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(time, unit, p) - 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.
DispatchedKt - Class in kotlinx.coroutines.experimental
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 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.
distinct($receiver) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel containing only distinct elements from the given channel.
distinctBy($receiver, context, selector) - Static method in class kotlinx.coroutines.experimental.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.experimental.channels.ChannelsKt: Returns a channel containing all elements except first n elements.
dropWhile($receiver, context, predicate) - Static method in class kotlinx.coroutines.experimental.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.experimental.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.experimental.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.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
ExceptionsKt - 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().
filter($receiver, context, predicate) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel containing only elements matching the given predicate.
filterIndexed($receiver, context, predicate) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel containing only elements matching the given predicate.
filterNot($receiver, predicate) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel containing all elements not matching the given predicate.
filterNotNull($receiver) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel containing all elements that are not null.
filterNotNullTo($receiver, destination, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Appends all elements that are not null to the given destination.
filterNotNullTo($receiver, destination, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Appends all elements that are not null to the given destination.
first($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns first element.
firstOrNull($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns the first element, or null if the channel is empty.
flatMap($receiver, context, transform) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a single channel of all elements from results of transform function being invoked on each element of original 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. 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.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.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.experimental.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.experimental.Job: Returns a sequence of this job's children.
getChildren() - Method in class kotlinx.coroutines.experimental.NonCancellable: Always returns emptySequence.
getCompleted() - Method in interface kotlinx.coroutines.experimental.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.experimental.Deferred.DefaultImpls: Deprecated.
getCompletionExceptionOrNull() - Method in interface kotlinx.coroutines.experimental.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.
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 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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.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 ConflatedBroadcastChannel.close.

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(p) - Method in interface kotlinx.coroutines.experimental.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.experimental.sync.Mutex: Checks mutex locked by owner

I

indexOf($receiver, element, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns first index of element, or -1 if the channel does not contain element.
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 NonCancellable.isActive. It is designed for withContext function to prevent cancellation of code blocks that need to be executed 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(handler) - Method in interface kotlinx.coroutines.experimental.CancellableContinuation: Registers handler that is synchronously invoked once on completion of this continuation. When continuation is already complete, then the handler is immediately invoked with continuation's exception or null. Otherwise, handler will be invoked once when this continuation is complete.
invokeOnCompletion(handler) - Method in interface kotlinx.coroutines.experimental.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.experimental.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.experimental.NonCancellable: Always returns class NonDisposableHandle.
invokeOnCompletion(onCancelling_, handler) - Method in class kotlinx.coroutines.experimental.NonCancellable: Always returns class NonDisposableHandle.
invokeOnCompletion(onCancelling, invokeImmediately, 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.CancellableContinuation: Returns true when this continuation is active -- it has not completed or cancelled yet.
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.getChildren 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 ArrayChannel.isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.experimental.channels.ConflatedChannel: Returns true if ConflatedChannel.isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.experimental.channels.LinkedListChannel: Returns true if LinkedListChannel.isBufferEmpty is always true.
isBufferAlwaysEmpty() - Method in class kotlinx.coroutines.experimental.channels.RendezvousChannel: Returns true if RendezvousChannel.isBufferEmpty is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.ArrayBroadcastChannel: Returns true if ArrayBroadcastChannel.isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.ArrayChannel: Returns true if ArrayChannel.isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.ConflatedChannel: Returns true if ConflatedChannel.isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.LinkedListChannel: Returns true if LinkedListChannel.isBufferFull is always true.
isBufferAlwaysFull() - Method in class kotlinx.coroutines.experimental.channels.RendezvousChannel: Returns true if RendezvousChannel.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 CancellableContinuation.cancel.
isCancelled() - Method in interface kotlinx.coroutines.experimental.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.experimental.NonCancellable: Always returns false.
isClosedForReceive() - Method in class kotlinx.coroutines.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.experimental.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.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.getChildren 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 Job.cancel.
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 AbstractChannel.receive attempt will suspend. This function returns false for AbstractChannel.isClosedForReceive channel.
isEmpty() - Method in interface kotlinx.coroutines.experimental.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.experimental.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.experimental.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.experimental.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.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 AbstractChannel.isClosedForReceive without cause and throws the original SendChannel.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 ReceiveChannel.isClosedForReceive without cause and throws the original SendChannel.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 Job.getChildren.
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 Job.getChildren.
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(p) - 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 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.experimental.NonCancellable: Always throws UnsupportedOperationException.
joinChildren($receiver, p) - Static method in class kotlinx.coroutines.experimental.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.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

last($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns the last element.
lastIndexOf($receiver, element, p) - Static method in class kotlinx.coroutines.experimental.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.experimental.channels.ChannelsKt: Returns the last element, or null if the channel is empty.
launch(context, start, parent, 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 Job.cancel.
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, p) - Method in interface kotlinx.coroutines.experimental.sync.Mutex: Locks this mutex, suspending caller while the mutex is locked.

M

map($receiver, context, transform) - Static method in class kotlinx.coroutines.experimental.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.experimental.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.experimental.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.experimental.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.experimental.channels.ChannelsKt: Returns the first element having the largest value according to the provided comparator or null if there are no elements.
minusKey($this, key) - Static method in class kotlinx.coroutines.experimental.Deferred.DefaultImpls
minusKey($this, key) - Static method in class kotlinx.coroutines.experimental.Job.DefaultImpls
minWith($receiver, comparator, p) - Static method in class kotlinx.coroutines.experimental.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.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, parent) - 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).
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(p) - Method in interface kotlinx.coroutines.experimental.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.experimental: A non-cancelable job that is always NonCancellable.isActive. It is designed for withContext function to prevent cancellation of code blocks that need to be executed without cancellation.
NonDisposableHandle - Class in kotlinx.coroutines.experimental: No-op implementation of interface DisposableHandle.
none($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns true if the channel has no elements.

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 AbstractSendChannel.isClosedForSend (see AbstractSendChannel.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 ConflatedBroadcastChannel.isClosedForSend (see ConflatedBroadcastChannel.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 SendChannel.isClosedForSend (see SendChannel.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.
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 AbstractChannel.isClosedForReceive without cause. It throws the original SendChannel.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 ReceiveChannel.isClosedForReceive without cause. It throws the original SendChannel.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, parent, 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 ReceiveChannel. This resulting object can be used to ReceiveChannel.receive elements produced by this coroutine.
ProduceKt - Class in kotlinx.coroutines.experimental.channels
ProducerScope<E> - Interface in kotlinx.coroutines.experimental.channels: Scope for ProduceKt.produce coroutine builder.

R

receive(p) - 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 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.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 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.experimental.channels: Receiver's interface to interface Channel.
receiveOrNull(p) - 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 AbstractChannel.isClosedForReceive without cause or throws the original SendChannel.close cause exception if the channel has failed.
receiveOrNull(p) - 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 ReceiveChannel.isClosedForReceive without cause or throws the original SendChannel.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 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.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 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.experimental.channels.ChannelsKt: Returns an original collection containing all the non-null elements, throwing an IllegalArgumentException if there are any null elements.
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 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.experimental.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.
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.
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
SelectUnbiasedKt - Class in kotlinx.coroutines.experimental.selects
send(element, p) - Method in class kotlinx.coroutines.experimental.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.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 ConflatedBroadcastChannel.isClosedForSend (see ConflatedBroadcastChannel.close for details).
send(element, p) - Method in interface kotlinx.coroutines.experimental.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.experimental.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.experimental.channels: Sender's interface to interface Channel.
single($receiver, p) - Static method in class kotlinx.coroutines.experimental.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.experimental.channels.ChannelsKt: Returns single element, or null if the channel is empty or has more than one element.
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 ReceiveChannel.receive elements from the open subscription and to SubscriptionReceiveChannel.close it to unsubscribe.
SubscriptionReceiveChannel.DefaultImpls - Class in kotlinx.coroutines.experimental.channels: 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.experimental.channels.ChannelsKt: Returns a channel containing first n elements.
takeFirstReceiveOrPeekClosed() - Method in class kotlinx.coroutines.experimental.channels.AbstractChannel: Retrieves first receiving waiter from the queue or returns closed token.
takeWhile($receiver, context, predicate) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel containing first elements satisfying the given predicate.
ThreadPoolDispatcher - Class in kotlinx.coroutines.experimental: 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.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
toChannel($receiver, destination, p) - Static method in class kotlinx.coroutines.experimental.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.experimental.channels.ChannelsKt: Appends all elements to the given destination collection.
toList($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a List containing all elements.
toMap($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a Map filled with all elements of this channel.
toMap($receiver, destination, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a MutableMap filled with all elements of this channel.
toMutableList($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a MutableList filled with all elements of this channel.
toMutableSet($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a mutable set containing all distinct elements from the given channel.
toSet($receiver, p) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a Set of all elements.
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 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, p) - Static method in class kotlinx.coroutines.experimental.selects.WhileSelectKt: Loops while select expression returns true.
WhileSelectKt - Class in kotlinx.coroutines.experimental.selects
withContext(context, start, block, p) - 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.
withIndex($receiver, context) - Static method in class kotlinx.coroutines.experimental.channels.ChannelsKt: Returns a channel of IndexedValue for each element of the original channel.
withTimeout(time, block, p) - 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.
withTimeout(time, unit, block, p) - 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, block, p) - 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.
withTimeoutOrNull(time, unit, block, p) - 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(p) - 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

Z

zip($receiver, other) - Static method in class kotlinx.coroutines.experimental.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.experimental.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