Package-level declarations

This Flow will have behaviour very similar to SharedFlow, but there are several differences:

ExceptionHandler wrapper which was created to make possible to use handler across all coroutines calls

This key can (and will) be used to get ContextSafelyExceptionHandler from coroutineContext of suspend functions and in ContextSafelyExceptionHandler for defining of its CoroutineContext.Element.key

Represents a deferred action that combines a Deferred value with a callback to be executed on that value.

A builder for creating multiple deferred computations that can be executed, with only the first completing one being used. This is useful for race conditions where you want the result of whichever computation finishes first.

Works like StateFlow, but guarantee that latest value update will always be delivered to each active subscriber

Combining globalRWLocker and internal map of SmartRWLocker associated by T to provide next logic:

It is interface which will work like classic Mutex, but in difference have lockStateFlow for listening of the SmartMutex state.

Composite mutex which works with next rules:

It is interface which will work like classic Semaphore, but in difference have permitsStateFlow for listening of the SmartSemaphore state.

Wraps this value in a completed Deferred. The resulting Deferred is immediately completed with this value. Useful for converting synchronous values to Deferred in contexts that expect deferred values.

Convenience property to access Dispatchers.Default for CPU-intensive operations.

This instance will be used in all calls of safely where exception handler has not been passed

This instance will be used in all calls of safelyWithoutExceptions as an exception handler for safely call

Use this handler in cases you wish to include handling of exceptions by defaultSafelyWithoutExceptionHandler and returning null at one time

Convenience property to access Dispatchers.Main for UI operations.

Creates AccumulatorFlow using this with receiveAsFlow to get

Creates AccumulatorFlow using this as base Flow

Creates an actor using coroutines that processes incoming messages of type T. An actor is a computational entity that processes messages sequentially in response to messages it receives.

Creates an actor-style channel that processes messages asynchronously based on markers. Messages with the same marker will be processed sequentially, while messages with different markers can be processed concurrently.

Executes the given block and unlocks all provided lockers for writing if the block succeeds. If the block throws an exception, the lockers will remain locked.

Asynchronously executes the given block and unlocks all provided lockers for writing if the block succeeds. This function launches a new coroutine in the given scope and automatically logs and drops any exceptions.

Creates a new async coroutine with automatic exception logging. If an exception occurs, it will be logged using the provided logger and then rethrown when the Deferred is awaited.

Creates a new async coroutine with automatic exception logging and dropping. If an exception occurs, it will be logged using the provided logger and wrapped in a Result, which can be checked when the Deferred is awaited.

this will be used as base for WeakScope. Other parameters (context, start, block) will be used to create async

Trying to Deferred.await on all deferreds. The first Deferred completed its work will interrupt all others awaits and, if cancelOthers passed as true (by default), will also cancel all the others deferreds

Trying to Deferred.await on all deferreds. The first Deferred completed its work will interrupt all others awaits and, if cancelOnResult passed as true (by default), will also cancel all the others deferreds

Trying to Deferred.await on all thiss. The first Deferred completed its work will interrupt all others awaits and, if cancelOthers passed as true (by default), will also cancel all the others Deferreds

Trying to Deferred.await on all thiss. The first Deferred completed its work will interrupt all others awaits and, if cancelOnResult passed as true (by default), will also cancel all the others Deferreds

Trying to Deferred.await on all thiss. The first Deferred completed its work will interrupt all others awaits and, if cancelOnResult passed as true (by default), will also cancel all the others Deferreds

Creates a DeferredAction from this Deferred and a callback function.

Planned to use with doWithSuspending. Will execute incoming lambdas sequentially

Planned to use with doWithSuspending. Will execute incoming lambdas sequentially

Debounces a Flow with per-marker timeout control. Values with the same marker will be debounced independently. For each marker, only the last value within the timeout period will be emitted.

Debounces a Flow with a fixed timeout in milliseconds and per-marker control. Values with the same marker will be debounced independently.

Debounces a Flow with a fixed timeout as Duration and per-marker control. Values with the same marker will be debounced independently.

Executes the given block in the specified coroutine context and returns its result. This is a convenience wrapper around withContext.

Executes the given block on the Default dispatcher and returns its result. This is a convenience function for executing CPU-intensive operations.

Executes the given block on the UI/Main dispatcher and returns its result. This is a convenience function for executing UI operations.

Call this method in case you need to do something in common thread (like reading of file in JVM)

Must be use with actor created by createActionsActor or createSafeActionsActor. Will send lambda which will execute action and return result.

Alias for takeNotNull. Filters out null values from this Flow, returning only non-null elements.

Returns the value of the first Deferred from this list to complete, using the given scope. Other deferred values are cancelled if cancelOnResult is true.

Returns the first non-null element emitted by this Flow. Suspends until a non-null element is found.

Builds multiple deferred computations using DoWithFirstBuilder and returns the value of the first one to complete. Other deferred computations are cancelled if cancelOnResult is true.

Returns the value of the first Deferred from the given variants to complete. Other deferred values are cancelled if cancelOnResult is true.

Transforms each element from inner Iterables using the given mapper function and flattens the result into a single Flow.

Transforms each inner Flow element using the given mapper function and flattens the result into a single Flow.

Transforms each element from inner Iterables using the given mapper function, flattens the result, and filters out null values.

Transforms each inner Flow element using the given mapper function, flattens the result, and filters out null values.

Flattens a Flow of Iterables into a single Flow by emitting all elements from each iterable.

Flattens a Flow of Flows into a single Flow by collecting all inner flows sequentially.

Operator function that allows a FlowCollector to be invoked like a function to emit a value. This is a convenient syntax sugar for FlowCollector.emit.

Invokes the first DeferredAction from the given variants whose deferred value completes, executing its callback and returning the result. Other deferred actions are cancelled if cancelOnResult is true.

Invokes the first DeferredAction whose deferred value completes, executing its callback and returning the result. Other deferred actions are cancelled if cancelOnResult is true.

Awaits the first Deferred from the given variants to complete and invokes the callback on its value. Other deferred values are cancelled if cancelOnResult is true.

Awaits the first Deferred to complete and invokes the callback on its value. Other deferred values are cancelled if cancelOnResult is true.

Builds multiple deferred computations using DoWithFirstBuilder and invokes callback on the first one to complete. Other deferred computations are cancelled if cancelOnResult is true.

Trying to Job.join on all jobs. The first Job completed its work will interrupt all others joins and, if cancelOthers passed as true (by default), will also cancel all the others Jobs

Trying to Job.join on all thiss. The first Job completed its work will interrupt all others joins and, if cancelOthers passed as true (by default), will also cancel all the others Jobs

Launches a new coroutine with automatic exception logging. If an exception occurs, it will be logged using the provided logger and then rethrown.

Launches a new coroutine with automatic exception logging and dropping. If an exception occurs, it will be logged using the provided logger and then dropped (not rethrown), allowing the coroutine to complete normally.

this will be used as base for WeakScope. Other parameters (context, start, block) will be used to launch

Creates a SupervisorJob linked to this CoroutineContext's job. The new supervisor job will be a child of the current job, and optionally combined with additionalContext.

Creates a SupervisorJob linked to this CoroutineScope's job. The new supervisor job will be a child of the current scope's job, and optionally combined with additionalContext.

Creates a new CoroutineScope with a SupervisorJob linked to this CoroutineContext's job. The new scope's supervisor job will be a child of the current job, and optionally combined with additionalContext.

Creates a new CoroutineScope with a SupervisorJob linked to this CoroutineScope's job. The new scope's supervisor job will be a child of the current scope's job, and optionally combined with additionalContext.

Merges two flows into a single flow. Values from both flows will be emitted as they become available. This is a convenient operator syntax for merge.

Replaces a failed Result with a new value computed from the exception. If this Result is successful, it is returned as-is. If it represents a failure, the onException handler is called with the exception to compute a replacement value, which is then wrapped in a new Result.

Executes the given block within a runCatching context and logs any exceptions that occur, excluding CancellationException which is rethrown. This method simplifies error handling by automatically logging the errors using the provided logger.

Creates a safe actor that catches and handles exceptions during message processing. This variant wraps the processing logic in a safety mechanism to prevent actor failure due to exceptions.

Shortcut for chain if Flow.onEach and Flow.launchIn

Subscribes to a Flow with asynchronous processing based on markers. Each value from the flow will be processed by the block function. Values with the same marker will be processed sequentially in the same coroutine scope, while values with different markers can be processed concurrently in separate coroutine scopes.

Use subscribe, but all blocks will be called inside of safely function. Use onException to set up your reaction for Throwables

Use subscribeSafelyWithoutExceptions, but all exceptions will be passed to defaultSafelyExceptionHandler

Subscribes to a Flow with asynchronous processing based on markers, automatically logging and dropping exceptions. Each value from the flow will be processed by the block function. Values with the same marker will be processed sequentially, while values with different markers can be processed concurrently. Any exceptions thrown during processing will be logged and dropped without affecting other messages.

Ensures that the current coroutine context is still active and throws a kotlinx.coroutines.CancellationException if the coroutine has been canceled.

Filters out null values from this Flow, returning only non-null elements.

Will wait until the SmartSemaphore.permitsStateFlow of this instance will have permits count free permits.

Will wait until the SmartSemaphore.permitsStateFlow of this instance will have permits count free permits.

Will wait until the SmartMutex.lockStateFlow of this instance will be false.

Will wait until the SmartMutex.lockStateFlow of this instance will be false.

Created CoroutineScope which will launch listening of context job completing and drop itself. Current weak scope will not be attached to context directly. So, this CoroutineScope will not prevent parent one from cancelling if it is launched with supervisorScope or coroutineScope, but still will follow closing status of parent Job

Created CoroutineScope which will launch listening of scope job completing and drop itself. Current weak scope will not be attached to scope directly. So, this CoroutineScope will not prevent parent one from cancelling if it is launched with supervisorScope or coroutineScope, but still will follow closing status of parent Job

Will call SmartSemaphore.Mutable.lock, then execute action and return the result after SmartSemaphore.Mutable.unlock

Will call SmartMutex.Mutable.lock, then execute action and return the result after SmartMutex.Mutable.unlock

Will call SmartSemaphore.Mutable.lock, then execute action and return the result after SmartSemaphore.Mutable.unlock

Will call SmartMutex.Mutable.lock, then execute action and return the result after SmartMutex.Mutable.unlock