Kotlin: Check if lazy val has been initialised

Question

Is there a way to tell if a lazy val has been initialised in Kotlin without initialising it in the process?

eg if I have a lazy val, querying if it is null would instantiate it

val messageBroker: MessageBroker by lazy { MessageBroker() }
if (messageBroker == null) {
    // oops
}

I could potentially use a second variable, but that seems messy.

private var isMessageBrokerInstantiated: Boolean = false
val messageBroker: MessageBroker by lazy {
    isMessageBrokerInstantiated = true
    MessageBroker()
}

...

if (!isMessageBrokerInstantiated) {
    // use case
}

Is there some sexy way of determining this, like if (Lazy(messageBroker).isInstantiated())?

Related (but not the same): How to check if a "lateinit" variable has been initialized?

score 97 · Accepted Answer · answered Mar 01 '17 at 06:12

97

There is a way, but you have to access the delegate object which is returned by lazy {}:

val messageBrokerDelegate = lazy { MessageBroker() }
val messageBroker by messageBrokerDelegate

if(messageBrokerDelegate.isInitialized())
    ...

isInitialized is a public method on interface Lazy<T>, here are the docs.

answered Mar 01 '17 at 06:12

voddan

31,956
8
77
87

6

Note that you can also use a `Lazy` directly instead of as a delegate and access the lazily evaluated value with [`Lazy.value`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-lazy/value.html). See also http://stackoverflow.com/q/38794502/3255152. – mfulton26 Mar 01 '17 at 13:40

score 36 · Answer 2 · edited Jan 30 '19 at 14:51

36

Since Kotlin 1.1, you can access a property delegate directly using .getDelegate().

You can write an extension property for a property reference that checks that it has a Lazy delegate that has already been initialized:

/**
 * Returns true if a lazy property reference has been initialized, or if the property is not lazy.
 */
val KProperty0<*>.isLazyInitialized: Boolean
    get() {
        if (this !is Lazy<*>) return true

        // Prevent IllegalAccessException from JVM access check on private properties.
        val originalAccessLevel = isAccessible
        isAccessible = true
        val isLazyInitialized = (getDelegate() as Lazy<*>).isInitialized()
        // Reset access level.
        isAccessible = originalAccessLevel
        return isLazyInitialized
    }

Then at the use site:

val messageBroker: MessageBroker by lazy { MessageBroker() }

if (this::messageBroker.isLazyInitialized) {
    // ... do stuff here
}

^{This solution requires kotlin-reflect to be on the classpath. With Gradle, use
compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"}

^{The isAccessible = true part is required for the .getDelegate(), because otherwise it cannot access the private field storing the delegate reference.}

edited Jan 30 '19 at 14:51

Neikius

173
2
9

answered Mar 01 '17 at 15:49

hotkey

140,743
39
371
326

Wow, I did't see it in the release notes! – voddan Mar 01 '17 at 16:38
Make sure you import isAccessible: import kotlin.reflect.jvm.isAccessible – Stephen Talley May 23 '18 at 19:52
3

I had to remove "if (this !is Lazy<*>) return true", without that it works. Changes in 1.3? – Neikius Feb 07 '19 at 12:45
2

If you're using R8 (perhaps ProGuard too, not tested), two things need to be excluded from minification: the class that contains the field must be accessible, along with its parent class and implemented interfaces. And the field itself must be marked `@delegate:Keep`. – Pierre-Luc Paour Jun 03 '19 at 12:47
@Neikius Same here. – Vincent Sit Apr 20 '20 at 13:17
1

This answer didn't fit me, because for some reason the value gets initialized, when I use 'isLazyInitialized' – Arutyun Enfendzhyan Jun 14 '20 at 15:42

Stephen Talley · Answer 3 · 2020-05-08T02:21:11.777

Testing if the lazy property is easy enough:

import kotlin.reflect.KProperty0
import kotlin.reflect.jvm.isAccessible

val KProperty0<*>.isLazyInitialized: Boolean
    get() {
        // Prevent IllegalAccessException from JVM access check
        isAccessible = true
        return (getDelegate() as Lazy<*>).isInitialized()
    }

…but you can make it even easier to reference a property without initializing it:

/**
 * Returns the value of the given lazy property if initialized, null
 * otherwise.
 */
val <T> KProperty0<T>.orNull: T?
    get() = if (isLazyInitialized) get() else null

Now you can do things like:

private val myList by lazy {
    mutableSetOf<String>()
}

fun add(str: String) {
    // Create the list if necessary
    myList += str
}

fun remove(str: String) {
    // Don't create the list
    ::myList.orNull?.remove(str)
}

fun clear() {
    // Don't create the list
    ::myList.orNull?.clear()
}

Needed Gradle depencency `implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"` for `kotlin.reflect.jvm.isAccessible`. — rjr-apps, Apr 13 '23 at 17:41

Kotlin: Check if lazy val has been initialised

3 Answers3

Linked