Optimized reflections utils

Author: emyfops

common/src/main/kotlin/com/lambda/command/CommandRegistry.kt

@@ -32,7 +32,7 @@ object CommandRegistry : Configurable(LambdaConfig), Loadable {
     override val name = "command"
     val prefix by setting("prefix", ';')
 
-    val commands = getInstances<LambdaCommand> { forPackages("com.lambda.command.commands") }.toMutableList()
+    val commands = getInstances<LambdaCommand>().toMutableList()
 
     override fun load() = "Loaded ${commands.size} commands with ${dispatcher.root.children()} possible command paths."
 

common/src/main/kotlin/com/lambda/core/Loader.kt

@@ -30,7 +30,7 @@ object Loader {
     val runtime: String
         get() = "${(System.currentTimeMillis() - started).milliseconds}"
 
-    private val loadables = getInstances<Loadable> { forPackages("com.lambda") }
+    private val loadables = getInstances<Loadable>()
 
     fun initialize(): Long {
         ascii.split("\n").forEach { LOG.info(it) }

common/src/main/kotlin/com/lambda/interaction/construction/processing/ProcessorRegistry.kt

@@ -24,8 +24,7 @@ import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 
 object ProcessorRegistry : Loadable {
-    private const val PROCESSOR_PACKAGE = "com.lambda.interaction.construction.processing.processors"
-    private val processors = getInstances<PlacementProcessor> { forPackages(PROCESSOR_PACKAGE) }
+    private val processors = getInstances<PlacementProcessor>()
     private val processorCache = mutableMapOf<BlockState, PreprocessingStep>()
 
     override fun load() = "Loaded ${processors.size} pre processors"
@@ -41,4 +40,4 @@ object ProcessorRegistry : Loadable {
         override fun acceptState(state: BlockState) = true
         override fun preProcess(state: BlockState) = PreprocessingStep()
     }
-}
+}

common/src/main/kotlin/com/lambda/interaction/material/container/ContainerManager.kt

@@ -47,8 +47,7 @@ object ContainerManager : Loadable {
         // ToDo: Filter containers based on a filter setting TaskFlowModule.inventory.accessEnderChest etc
         get() = compileContainers.filter { it !is EnderChestContainer } + runtimeContainers
 
-    private val compileContainers =
-        getInstances<MaterialContainer> { forPackages("com.lambda.interaction.material.container") }
+    private val compileContainers = getInstances<MaterialContainer>()
     private val runtimeContainers = mutableSetOf<MaterialContainer>()
 
     private var lastInteractedBlockEntity: BlockEntity? = null

common/src/main/kotlin/com/lambda/module/ModuleRegistry.kt

@@ -25,7 +25,7 @@ import com.lambda.util.reflections.getInstances
  */
 object ModuleRegistry : Loadable {
     override val priority = 1
-    val modules = getInstances<Module> { forPackages("com.lambda.module.modules") }.toMutableList()
+    val modules = getInstances<Module>().toMutableList()
 
     val moduleNames: Set<String>
         get() = modules.map { it.name }.toSet()

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

@@ -17,77 +17,69 @@
 
 package com.lambda.util.reflections
 
-import com.lambda.Lambda.LOG
 import com.lambda.util.extension.isObject
 import com.lambda.util.extension.objectInstance
 import org.reflections.Reflections
 import org.reflections.util.ConfigurationBuilder
 import java.lang.reflect.Modifier
-import java.util.regex.Pattern
+import java.util.Objects
 
-/**
- * Retrieves instances of objects of the specified type using a DSL configuration.
- *
- * @param T The type of objects to retrieve instances for.
- * @param block A DSL block used to configure the [ReflectionConfigDsl].
- * @return A [List] of object instances of type [T], or null if no instances can be found.
- */
-inline fun <reified T : Any> getInstances(block: ReflectionConfigDsl.() -> Unit): List<T> =
-    getInstances<T>(getConfiguration(block))
+val cache = mutableMapOf<Int, Reflections>()
 
 /**
- * Retrieves instances of objects of the specified type using a provided configuration.
+ * Retrieves all instances of the specified type `T`.
  *
- * @param T The type of objects to retrieve instances for.
- * @param config A pre-configured [ConfigurationBuilder].
- * @return A [List] of object instances of type [T], or null if no instances can be found.
- */
-inline fun <reified T : Any> getInstances(config: ConfigurationBuilder): List<T> =
-    getSubTypesOf<T>(config).mapNotNull { clazz: Class<*> ->
-        if (!clazz.isInterface
-            && !clazz.isEnum
-            && !clazz.isAnnotation
-            && !clazz.isObject
-        ) clazz.constructors.filter { !Modifier.isAbstract(clazz.modifiers) }.firstOrNull { it.parameterCount == 0 }
-            ?.newInstance() as? T
-            ?: null.also { LOG.debug("Could not find a proper no-arg constructor for the class ${clazz.simpleName}.") }
-        else clazz.objectInstance as? T
-        // We're doomed at this point, now I am become death, the destroyer of worlds
-            ?: null.also {
-                LOG.debug(
-                    "No instance of type ${T::class.java.simpleName} could be found on the class ${clazz.simpleName}." +
-                            " Ensure that the class has an INSTANCE field or a no-arg constructor."
-                )
-            }
-    }
-
-/**
- * Finds all subtypes of a specified class
+ * The function caches the results based on the configuration provided via the [block] lambda to avoid redundant
+ * reflection calls.
  *
- * @param T The type for which to find subtypes.
- * @param config A pre-configured [ConfigurationBuilder].
- * @return A [Set] of [Class] objects representing all subtypes of the specified type.
+ * @param T The type of instances to retrieve.
+ * @param block A configuration lambda to customize the [ConfigurationBuilder] used to configure Reflections.
+ *
+ * @return A list of instances of type `T`
  */
-inline fun <reified T : Any> getSubTypesOf(config: ConfigurationBuilder): Set<Class<*>> =
-    Reflections(config).getSubTypesOf(T::class.java)
+inline fun <reified T : Any> getInstances(block: ConfigurationBuilder.() -> Unit = { forPackage("com.lambda") }): List<T> {
+    val config = ConfigurationBuilder().apply(block)
+    val cacheKey = Objects.hash(config.classLoaders, config.urls, config.scanners, config.inputsFilter)
 
+    // Use previously scanned classes or create a new reflections
+    val reflections = cache.getOrPut(cacheKey) { Reflections(config) }
 
-/**
- * Retrieves resources matching a specified pattern
- *
- * @param pattern The pattern to match resources against.
- * @param config A pre-configured [ConfigurationBuilder].
- * @return A [Set] of [String] representing resources matching the specified pattern.
- */
-fun getResources(pattern: String, config: ConfigurationBuilder): Set<String> =
-    Reflections(config).getResources(pattern)
+    return reflections.getSubTypesOf(T::class.java)
+        .mapNotNull { clazz -> createInstance<T>(clazz) }
+}
 
 /**
- * Retrieves resources matching a specified [Pattern]
+ * Retrieves all resource paths that match the given pattern.
+ *
+ * The function caches the results based on the configuration provided via the [block] lambda to avoid redundant
+ * reflection calls.
+ *
+ * @param pattern The resource pattern to search for.
+ * @param block A configuration lambda to customize the [ConfigurationBuilder] used to configure Reflections.
  *
- * @param pattern The [Pattern] to match resources against.
- * @param block A DSL block used to configure the [ReflectionConfigDsl].
- * @return A [Set] of [String] representing resources matching the specified pattern.
+ * @return A set of resource paths that match the specified pattern.
  */
-inline fun getResources(pattern: Pattern, block: ReflectionConfigDsl.() -> Unit): Set<String> =
-    getResources(pattern.pattern(), config = getConfiguration(block))
+inline fun getResources(pattern: String, block: ConfigurationBuilder.() -> Unit = { forPackage("com.lambda") }): Set<String> {
+    val config = ConfigurationBuilder().apply(block)
+    val cacheKey = Objects.hash(config.classLoaders, config.urls, config.scanners, config.inputsFilter)
+
+    // Use previously scanned classes or create a new reflections
+    val reflections = cache.getOrPut(cacheKey) { Reflections(config) }
+
+    return reflections.getResources(pattern)
+}
+
+inline fun <reified T : Any> createInstance(clazz: Class<*>): T? {
+    return when {
+        clazz.isInterface || clazz.isEnum || clazz.isAnnotation || clazz.isObject -> {
+            // Handle objects (singletons) or invalid types
+            clazz.objectInstance as? T
+        }
+        else -> {
+            // Look for a constructor with no parameters
+            clazz.constructors
+                .filterNot { Modifier.isAbstract(it.declaringClass.modifiers) } // Avoid abstract constructors
+                .firstOrNull { it.parameterCount == 0 }?.newInstance() as? T
+        }
+    }
+}