Updated reflections

Author: emyfops

common/src/main/kotlin/com/lambda/Lambda.kt

@@ -26,18 +26,10 @@ import com.lambda.config.serializer.GameProfileSerializer
 import com.lambda.config.serializer.ItemStackSerializer
 import com.lambda.config.serializer.KeyCodeSerializer
 import com.lambda.config.serializer.OptionalSerializer
-import com.lambda.core.Loadable
 import com.lambda.core.Loader
-import com.lambda.threading.awaitMainThread
 import com.lambda.threading.recordRenderCall
-import com.lambda.threading.runGameScheduled
 import com.lambda.util.KeyCode
-import com.lambda.util.reflections.createInstance
 import com.mojang.authlib.GameProfile
-import io.github.classgraph.ClassGraph
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withContext
 import net.minecraft.block.Block
 import net.minecraft.client.MinecraftClient
 import net.minecraft.item.ItemStack
@@ -77,29 +69,3 @@ object Lambda {
 
     fun initialize(block: (Long) -> Unit) = recordRenderCall { Loader.initialize().apply(block) }
 }
-
-    /**
-     * Execute a block of code on the main thread
-     */
-    suspend fun <T> executeOnMainThread(block: () -> T): T {
-        return withContext(Dispatchers.Main) {
-            println("Executing on ${Thread.currentThread().name}")
-            block()
-        }
-    }
-
-suspend fun main() {
-    val classes = ClassGraph()
-        .enableAllInfo()
-        .scan()
-        .use { result ->
-            result.getClassesImplementing(Loadable::class.java)
-                .map { Class.forName(it.name) }
-        }
-
-    val loadables = classes.mapNotNull {
-        executeOnMainThread { createInstance<Loadable>(it) }
-    }
-
-    loadables.forEach { println(it.load()) }
-}

common/src/main/kotlin/com/lambda/util/reflections/Reflections.kt

@@ -20,46 +20,34 @@ package com.lambda.util.reflections
 import com.lambda.util.extension.isObject
 import com.lambda.util.extension.objectInstance
 import io.github.classgraph.ClassGraph
+import io.github.classgraph.ClassInfo
+import io.github.classgraph.Resource
 import io.github.classgraph.ResourceList
+import io.github.classgraph.ScanResult
 import java.lang.reflect.Modifier
 import kotlin.jvm.java
 
-/**
- * Retrieves all instances of the specified type `T`.
- *
- * @param T The type of instances to retrieve.
- * @param block A configuration lambda to customize the [ClassGraph] configuration.
- *
- * @return A list of instances of type `T`
- */
-inline fun <reified T : Any> getInstances(block: ClassGraph.() -> Unit = { enableClassInfo(); acceptPackages("com.lambda") }): List<T> =
-    ClassGraph().apply(block)
-        .scan()
-        .use { result ->
-            val clazz = T::class.java
+val scanResult: ScanResult by lazy { ClassGraph().enableAllInfo().scan() }
 
-            return when {
-                clazz.isInterface -> result.getClassesImplementing(T::class.java)
+inline fun <reified T : Any> getInstances(crossinline block: (ClassInfo) -> Boolean = { true }): List<T> {
+    if (scanResult.isClosed) return emptyList()
 
-                clazz.isObject || Modifier.isAbstract(clazz.modifiers) ->
-                    result.getSubclasses(T::class.java)
+    val clazz = T::class.java
 
-                else -> throw IllegalAccessException("class ${clazz.name} is neither an interface or abstract class")
-            }.mapNotNull { createInstance<T>(Class.forName(it.name)) }
-        }
+    return when {
+        clazz.isInterface -> scanResult.getClassesImplementing(clazz)
+            .filter { block(it) }
 
-/**
- * Retrieves all resource paths that match the given pattern wildcard.
- *
- * @param pattern The resource pattern to search for.
- * @param block A configuration lambda to customize the [ClassGraph] configuration.
- *
- * @return A [ResourceList]
- */
-inline fun getResources(pattern: String, block: ClassGraph.() -> Unit = { enableAllInfo(); acceptPackages("com.lambda") }): ResourceList =
-    ClassGraph().apply(block)
-        .scan()
-        .use { it.getResourcesMatchingWildcard(pattern) }
+        clazz.isObject || Modifier.isAbstract(clazz.modifiers) -> scanResult.getSubclasses(clazz)
+             .filter { block(it) }
+
+        else -> throw IllegalAccessException("class ${clazz.name} is neither an interface or open class")
+    }.mapNotNull { createInstance<T>(Class.forName(it.name)) }
+}
+
+inline fun getResources(pattern: String, crossinline block: (Resource) -> Boolean): ResourceList =
+    scanResult.getResourcesMatchingWildcard(pattern)
+        .filter { block(it) }
 
 inline fun <reified T : Any> createInstance(clazz: Class<*>): T? {
     return when {