Better destroyable listeners

Author: emyfops

common/src/main/kotlin/com/lambda/event/listener/SafeListener.kt

@@ -104,12 +104,10 @@ class SafeListener(
          *
          * Usage:
          * ```kotlin
-         * listenerOnce<MyEvent> { event ->
-         *     player.sendMessage("Event received: $event")
-         * }
-         *
-         * listenerOnce<MyEvent>(priority = 1) { event ->
-         *     player.sendMessage("Event received before the previous listener: $event")
+         * private val event by listenOnce<MyEvent> { event ->
+         *     player.sendMessage("Event received only once: $event")
+         *     // event is stored in the value
+         *     // event is unsubscribed after execution
          * }
          * ```
          *
@@ -122,18 +120,23 @@ class SafeListener(
         inline fun <reified T : Event> Any.listenOnce(
             priority: Int = 0,
             alwaysListen: Boolean = false,
-            noinline function: SafeContext.(T) -> Unit,
-        ): SafeListener {
+            noinline function: SafeContext.(T) -> Unit = {},
+        ): Lazy<T?> {
+            // This doesn't leak memory because the owner still has a reference to the listener
+            var value: T? = null
+
             val destroyable by selfReference<SafeListener> {
                 SafeListener(priority, this@listenOnce, alwaysListen) { event ->
                     function(event as T)
+                    value = event
+
                     EventFlow.syncListeners.unsubscribe(self)
                 }
             }
 
             EventFlow.syncListeners.subscribe<T>(destroyable)
 
-            return destroyable
+            return lazy { value }
         }
 
         /**

common/src/main/kotlin/com/lambda/event/listener/UnsafeListener.kt

@@ -91,12 +91,11 @@ class UnsafeListener(
          *
          * Usage:
          * ```kotlin
-         * unsafeListenOnce<MyEvent> { event ->
+         * private val event by unsafeListenOnce<MyEvent> { event ->
          *     println("Unsafe event received only once: $event")
-         * }
-         *
-         * unsafeListenOnce<MyEvent>(priority = 1) { event ->
-         *     println("Unsafe event received only once before the previous listener: $event")
+         *     // no safe access to player or world
+         *     // event is stored in the value
+         *     // event is unsubscribed after execution
          * }
          * ```
          *
@@ -112,17 +111,22 @@ class UnsafeListener(
             priority: Int = 0,
             alwaysListen: Boolean = false,
             noinline function: (T) -> Unit,
-        ): UnsafeListener {
+        ): Lazy<T?> {
+            // This doesn't leak memory because the owner still has a reference to the listener
+            var value: T? = null
+
             val destroyable by selfReference<UnsafeListener> {
                 UnsafeListener(priority, this@unsafeListenOnce, alwaysListen) { event ->
                     function(event as T)
+                    value = event
+
                     EventFlow.syncListeners.unsubscribe(self)
                 }
             }
 
             EventFlow.syncListeners.subscribe<T>(destroyable)
 
-            return destroyable
+            return lazy { value }
         }
 
         /**

common/src/main/kotlin/com/lambda/util/SelfReference.kt

@@ -1,7 +1,7 @@
 package com.lambda.util
 
 class SelfReference<T>(initializer: SelfReference<T>.() -> T)  {
-    val self: T by lazy { inner ?: throw IllegalStateException("Do not use `self` until initialized.") }
+    val self: T by lazy { inner }
 
     private val inner = initializer()
     operator fun getValue(thisRef: Any?, property: Any?) = self