2025.2.2-beta1

rd-core/com.jetbrains.rd.util.lifetime/LifetimeDefinition

LifetimeDefinition

class LifetimeDefinition : Lifetime

Constructors

LifetimeDefinition

constructor(parent: Lifetime)

constructor()

Types

object Companion

Properties

allowTerminationUnderExecution

open override var allowTerminationUnderExecution: Boolean

open override val coroutineScope: CoroutineScope

var id: Any?

You can optionally set this identification information to see logs with lifetime's id other than anonymousLifetimeId"/>

val Lifetime.isAlive: Boolean

val Lifetime.isEternal: Boolean

val Lifetime.isNotAlive: Boolean

val ~~isTerminated~~: Boolean

val lifetime: Lifetime

open override val status: LifetimeStatus

Only possible Alive ->Canceling ->Terminating ->Terminated

terminationTimeoutKind

open override var terminationTimeoutKind: LifetimeTerminationTimeoutKind

Gets or sets termination timeout kind for the definition.

Functions

fun ~~add~~(action: () -> Unit)

fun Lifetime.assertAlive()

fun <T> Lifetime.async(scheduler: IScheduler, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T): Deferred<T>

fun <T> Lifetime.async(context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T): Deferred<T>

open override fun attach(child: LifetimeDefinition, inheritTimeoutKind: Boolean)

fun <T : Any> ~~bracket~~(opening: () -> T, terminationAction: () -> Unit): T?

open override fun <T : Any> bracketIfAlive(opening: () -> T, terminationAction: () -> Unit): T?

bracketIfAliveEx

open override fun <T : Any> bracketIfAliveEx(opening: () -> T, terminationAction: (T) -> Unit): T?

open override fun <T : Any> bracketOrThrow(opening: () -> T, terminationAction: () -> Unit): T

bracketOrThrowEx

open override fun <T : Any> bracketOrThrowEx(opening: () -> T, terminationAction: (T) -> Unit): T

fun createNested(): LifetimeDefinition

fun createNested(atomicAction: (LifetimeDefinition) -> Unit): LifetimeDefinition

createNestedDef

fun ~~createNestedDef~~(): LifetimeDefinition

createTerminatedAfter

fun Lifetime.createTerminatedAfter(duration: Duration, terminationContext: CoroutineContext): Lifetime

defineIntersection

fun Lifetime.defineIntersection(lifetime: Lifetime): LifetimeDefinition

open override fun <T : Any> executeIfAlive(action: () -> T): T?

open override fun <T : Any> executeOrThrow(action: () -> T): T

fun <T : Any> ~~ifAlive~~(action: () -> T): T?

fun Lifetime.intersect(lifetime: Lifetime): Lifetime

Creates an intersection of some lifetimes: new lifetime that terminate when either one terminates. Created lifetime inherits the smallest terminationTimeoutKind

fun Lifetime.launch(scheduler: IScheduler, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit): Job

fun Lifetime.launch(context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit): Job

open override fun onTermination(closeable: Closeable)

open override fun onTermination(action: () -> Unit)

fun Lifetime.~~onTermination~~(closeable: Closeable)

fun Lifetime.~~onTermination~~(action: () -> Unit)

onTerminationIfAlive

open override fun onTerminationIfAlive(closeable: Closeable): Boolean

open override fun onTerminationIfAlive(action: () -> Unit): Boolean

operator fun Lifetime.plusAssign(action: () -> Unit)

synchronizeWith

fun LifetimeDefinition.synchronizeWith(scope: CoroutineScope, supportsTerminationUnderExecution: Boolean = false)

fun LifetimeDefinition.synchronizeWith(job: Job, supportsTerminationUnderExecution: Boolean = false)

fun terminate(supportsTerminationUnderExecuting: Boolean = false): Boolean

throwIfNotAlive

fun Lifetime.throwIfNotAlive()

open override fun toString(): String

inline fun <T> usingNested(action: (Lifetime) -> T): T

inline fun <T> Lifetime.view(viewable: IViewable<T>, crossinline handler: Lifetime.(T) -> Unit)

inline fun <T : Any> Lifetime.viewNotNull(viewable: IViewable<T?>, crossinline handler: Lifetime.(T) -> Unit)

waitTermination

fun Lifetime.waitTermination()