Add support for nested iota providers using DFS topological sorter

object-Object · object-Object · commit 36a91088959f · 2025-10-02T00:31:40.000-04:00
diff --git a/Common/src/main/java/gay/object/hexdebug/api/client/splicing/SplicingTableIotaRendererParser.java b/Common/src/main/java/gay/object/hexdebug/api/client/splicing/SplicingTableIotaRendererParser.java
@@ -2,8 +2,7 @@
 
 import com.google.gson.Gson;
 import com.google.gson.JsonObject;
-import com.mojang.datafixers.util.Function3;
-import com.mojang.datafixers.util.Function4;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -14,6 +13,7 @@ public interface SplicingTableIotaRendererParser<T extends SplicingTableIotaRend
      * Throws {@link IllegalArgumentException} or {@link com.google.gson.JsonParseException} if
      * the input is invalid.
      */
+    @ApiStatus.OverrideOnly
     @NotNull
     T parse(@NotNull Gson gson, @NotNull JsonObject jsonObject, @Nullable T parent);
 
diff --git a/Common/src/main/java/gay/object/hexdebug/api/client/splicing/SplicingTableIotaRendererProvider.java b/Common/src/main/java/gay/object/hexdebug/api/client/splicing/SplicingTableIotaRendererProvider.java
@@ -1,11 +1,7 @@
 package gay.object.hexdebug.api.client.splicing;
 
 import at.petrak.hexcasting.api.casting.iota.IotaType;
-import at.petrak.hexcasting.common.lib.hex.HexIotaTypes;
 import gay.object.hexdebug.api.splicing.SplicingTableIotaClientView;
-import gay.object.hexdebug.gui.splicing.SplicingTableScreen;
-import net.minecraft.client.gui.components.Tooltip;
-import net.minecraft.network.chat.Component;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
diff --git a/Common/src/main/java/gay/object/hexdebug/api/client/splicing/SplicingTableIotaRenderers.java b/Common/src/main/java/gay/object/hexdebug/api/client/splicing/SplicingTableIotaRenderers.java
@@ -1,7 +1,9 @@
 package gay.object.hexdebug.api.client.splicing;
 
 import com.google.common.collect.Maps;
+import com.google.gson.JsonObject;
 import gay.object.hexdebug.HexDebug;
+import gay.object.hexdebug.resources.splicing.SplicingTableIotasResourceReloadListener;
 import net.minecraft.resources.ResourceLocation;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -18,18 +20,40 @@ public final class SplicingTableIotaRenderers {
      * This is used to parse resource files and create providers for iota renderers.
      */
     public static void register(
-        @NotNull ResourceLocation id,
+        @NotNull ResourceLocation parserId,
         @NotNull SplicingTableIotaRendererParser<?> parser
     ) {
-        if (PARSERS.containsKey(id)) {
-            HexDebug.LOGGER.warn("Overriding existing splicing table iota renderer parser: {}", id);
+        if (PARSERS.containsKey(parserId)) {
+            HexDebug.LOGGER.warn("Overriding existing splicing table iota renderer parser: {}", parserId);
         }
-        PARSERS.put(id, parser);
+        PARSERS.put(parserId, parser);
+    }
+
+    /**
+     * Get/load a provider by ID. Throws if the referenced provider does not exist or fails to load.
+     * Intended for use in providers that reference other providers.
+     * <br>
+     * This should only be called from inside of {@link SplicingTableIotaRendererParser#parse}.
+     */
+    @NotNull
+    public static SplicingTableIotaRendererProvider loadProvider(@NotNull ResourceLocation providerId) {
+        return SplicingTableIotasResourceReloadListener.loadProvider(providerId);
+    }
+
+    /**
+     * Parse a provider from a raw JSON object. Intended for use in providers that contain other
+     * providers.
+     * <br>
+     * This should only be called from inside of {@link SplicingTableIotaRendererParser#parse}.
+     */
+    @NotNull
+    public static SplicingTableIotaRendererProvider parseProvider(@NotNull JsonObject jsonObject) {
+        return SplicingTableIotasResourceReloadListener.parseProvider(jsonObject);
     }
 
     @ApiStatus.Internal
     @Nullable
-    public static SplicingTableIotaRendererParser<?> getParser(@NotNull ResourceLocation id) {
-        return PARSERS.get(id);
+    public static SplicingTableIotaRendererParser<?> getParser(@NotNull ResourceLocation parserId) {
+        return PARSERS.get(parserId);
     }
 }
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/gui/splicing/widgets/BaseIotaButton.kt b/Common/src/main/kotlin/gay/object/hexdebug/gui/splicing/widgets/BaseIotaButton.kt
@@ -61,9 +61,9 @@ abstract class BaseIotaButton(x: Int, y: Int) : HexagonButton(
 
         try {
             renderer = iotaType
-                ?.let { SplicingTableIotasResourceReloadListener.PROVIDERS[it] }
+                ?.let { SplicingTableIotasResourceReloadListener.getProvider(it) }
                 ?.createRenderer(iotaType, iotaView, x, y)
-                ?: SplicingTableIotasResourceReloadListener.FALLBACK
+                ?: SplicingTableIotasResourceReloadListener.fallback
                     ?.createRenderer(iotaType, iotaView, x, y)
 
             tooltip = renderer?.createTooltip()
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/resources/splicing/SplicingTableIotasResourceReloadListener.kt b/Common/src/main/kotlin/gay/object/hexdebug/resources/splicing/SplicingTableIotasResourceReloadListener.kt
@@ -5,130 +5,156 @@ import at.petrak.hexcasting.common.lib.hex.HexIotaTypes
 import com.google.gson.GsonBuilder
 import com.google.gson.JsonElement
 import com.google.gson.JsonObject
+import com.google.gson.JsonParseException
 import gay.`object`.hexdebug.HexDebug
-import gay.`object`.hexdebug.api.client.splicing.SplicingTableIotaRendererParser
-import gay.`object`.hexdebug.api.client.splicing.SplicingTableIotaRendererProvider
 import gay.`object`.hexdebug.api.client.splicing.SplicingTableIotaRenderers
+import gay.`object`.hexdebug.utils.contains
+import gay.`object`.hexdebug.utils.getAsResourceLocation
+import gay.`object`.hexdebug.utils.getOrNull
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.packs.resources.ResourceManager
 import net.minecraft.server.packs.resources.SimpleJsonResourceReloadListener
 import net.minecraft.util.profiling.ProfilerFiller
+import gay.`object`.hexdebug.api.client.splicing.SplicingTableIotaRendererParser as RendererParser
+import gay.`object`.hexdebug.api.client.splicing.SplicingTableIotaRendererProvider as RendererProvider
+
+private typealias AnyRendererParser = RendererParser<RendererProvider>
 
 private val GSON = GsonBuilder()
     .registerTypeAdapter(ResourceLocation::class.java, ResourceLocation.Serializer())
     .create()
 
+// this is effectively a topological sorting algorithm using depth-first search
+// https://en.wikipedia.org/wiki/Topological_sorting#Depth-first_search
+
 object SplicingTableIotasResourceReloadListener :
     SimpleJsonResourceReloadListener(GSON, "hexdebug_splicing_iotas")
 {
-    val PROVIDERS = mutableMapOf<IotaType<*>, SplicingTableIotaRendererProvider>()
-    var FALLBACK: SplicingTableIotaRendererProvider? = null
+    var fallback: RendererProvider? = null
+        private set
+
+    private val providersByType = mutableMapOf<IotaType<*>, RendererProvider>()
+
+    private val objects = mutableMapOf<ResourceLocation, JsonObject>()
+    private val parsersByProviderId = mutableMapOf<ResourceLocation, AnyRendererParser>()
+    private val providersById = mutableMapOf<ResourceLocation, RendererProvider>()
+    private val visitingProviders = linkedSetOf<ResourceLocation>() // use a linked set so the error message is ordered
+    private val failedProviders = mutableSetOf<ResourceLocation>()
+
+    fun getProvider(iotaType: IotaType<*>): RendererProvider? = providersByType[iotaType]
+
+    @JvmStatic
+    fun loadProvider(providerId: ResourceLocation): RendererProvider {
+        check(visitingProviders.isNotEmpty()) {
+            "Tried to call loadProvider outside of SplicingTableIotaRendererParser#parse"
+        }
+        val jsonObject = objects[providerId]
+            ?: throw IllegalArgumentException("Provider $providerId not found")
+        return visit(providerId, jsonObject)
+    }
+
+    @JvmStatic
+    fun parseProvider(jsonObject: JsonObject): RendererProvider {
+        check(visitingProviders.isNotEmpty()) {
+            "Tried to call parseProvider outside of SplicingTableIotaRendererParser#parse"
+        }
+        return visit(jsonObject).second
+    }
 
     override fun apply(
         map: MutableMap<ResourceLocation, JsonElement>,
         manager: ResourceManager,
         profiler: ProfilerFiller
     ) {
         HexDebug.LOGGER.info("Loading splicing table iota renderers...")
-        PROVIDERS.clear()
-        FALLBACK = null
 
-        // first, filter out any weird non-object files
-        val objects = mutableMapOf<ResourceLocation, JsonObject>()
+        fallback = null
+        providersByType.clear()
+
+        objects.clear()
+        parsersByProviderId.clear()
+        providersById.clear()
+        visitingProviders.clear()
+        failedProviders.clear()
+
+        // filter out any weird non-object files
         for ((id, jsonElement) in map) {
             if (!jsonElement.isJsonObject) continue
             objects[id] = jsonElement.asJsonObject
         }
 
-        // next, find a topological order to load the providers
-        val stack = mutableListOf<ResourceLocation>()
-        val parsers = mutableMapOf<ResourceLocation, SplicingTableIotaRendererParser<SplicingTableIotaRendererProvider>>()
-        for (id in objects.keys) {
-            findParents(objects, id)?.let { (toAdd, parser) ->
-                for (it in toAdd) {
-                    stack.add(it)
-                    @Suppress("UNCHECKED_CAST")
-                    parsers[it] = parser as SplicingTableIotaRendererParser<SplicingTableIotaRendererProvider>
-                }
+        // visit all providers
+        for ((id, jsonObject) in objects) {
+            if (id in failedProviders) continue
+            try {
+                visit(id, jsonObject)
+            } catch (e: Exception) {
+                HexDebug.LOGGER.error("Caught exception while loading renderer for $id, skipping", e)
+                failedProviders.add(id)
+                failedProviders.addAll(visitingProviders)
+                visitingProviders.clear()
             }
         }
 
-        // finally, actually load the providers
-        val providers = mutableMapOf<ResourceLocation, SplicingTableIotaRendererProvider>()
-        val failed = mutableSetOf<ResourceLocation>()
-        for (id in stack.asReversed()) {
-            if (id in providers || id in failed) continue
-
-            val provider = try {
-                val parser = parsers[id]!!
-                val jsonObject = objects[id]!!
-                val parent = if (jsonObject.has("parent")) {
-                    val parentId = ResourceLocation(jsonObject.getAsJsonPrimitive("parent").asString)
-                    // we're loading parents first, so this should always be present unless the parent failed
-                    providers[parentId] ?: continue
-                } else null
-                parser.parse(GSON, jsonObject, parent)
-            } catch (e: Exception) {
-                HexDebug.LOGGER.error("Caught exception while parsing $id, ignoring", e)
-                failed.add(id)
-                continue
-            }
+        HexDebug.LOGGER.info("Loaded ${providersById.size} splicing table iota renderers for ${providersByType.size} iota types")
+    }
 
-            providers[id] = provider
-            if (HexIotaTypes.REGISTRY.containsKey(id)) {
-                PROVIDERS[HexIotaTypes.REGISTRY.get(id)!!] = provider
-            }
-            if (id == HexDebug.id("builtin/generic")) {
-                FALLBACK = provider
-            }
+    private fun visit(providerId: ResourceLocation, jsonObject: JsonObject): RendererProvider {
+        providersById[providerId]?.let { return it }
+
+        if (!visitingProviders.add(providerId)) {
+            throw IllegalStateException("Cycle detected: ${visitingProviders.joinToString()}, $providerId")
+        }
+
+        val (parser, provider) = try {
+            visit(jsonObject)
+        } catch (e: ProviderVisitException) {
+            throw e // don't make a huge unnecessary stack trace
+        } catch (e: Exception) {
+            throw ProviderVisitException("Failed to parse provider $providerId", e)
+        }
+
+        visitingProviders.remove(providerId)
+
+        parsersByProviderId[providerId] = parser
+        providersById[providerId] = provider
+        HexIotaTypes.REGISTRY.getOrNull(providerId)?.let {
+            providersByType[it] = provider
+        }
+        if (providerId == HexDebug.id("builtin/generic")) {
+            fallback = provider
         }
 
-        HexDebug.LOGGER.info("Loaded ${providers.size} splicing table iota renderers for ${PROVIDERS.size} iota types")
+        return provider
     }
 
-    private fun findParents(
-        objects: Map<ResourceLocation, JsonObject>,
-        id: ResourceLocation,
-    ): Pair<List<ResourceLocation>, SplicingTableIotaRendererParser<*>>? {
-        var jsonObject = objects[id]!!
-        val knownIds = mutableSetOf(id)
-        val stack = mutableListOf(id)
-
-        while (jsonObject.has("parent")) {
-            val parentId = try {
-                ResourceLocation(jsonObject.getAsJsonPrimitive("parent").asString)
-            } catch (e: Exception) {
-                HexDebug.LOGGER.error("Failed to parse parent field of ${stack.last()} while loading $id, ignoring", e)
-                return null
-            }
+    private fun visit(jsonObject: JsonObject): Pair<AnyRendererParser, RendererProvider> {
+        val (parser, parent) = when {
+            "parent" in jsonObject -> {
+                val parentId = jsonObject.getAsResourceLocation("parent")
+                val parentObject = objects[parentId]
+                    ?: throw JsonParseException("Parent $parentId not found")
 
-            if (!knownIds.add(parentId)) {
-                HexDebug.LOGGER.error("Loop found in parents of $id ($parentId appears twice), ignoring")
-                return null
-            }
+                // DFS recursion - ensure the parent has been loaded first
+                val provider = visit(parentId, parentObject)
 
-            if (parentId !in objects) {
-                HexDebug.LOGGER.error("Parent id $parentId not found while loading $id, ignoring")
-                return null
+                parsersByProviderId[parentId]!! to provider
             }
 
-            stack.add(parentId)
-            jsonObject = objects[parentId]!!
-        }
-
-        val typeId = try {
-            ResourceLocation(jsonObject.getAsJsonPrimitive("type").asString)
-        } catch (e: Exception) {
-            HexDebug.LOGGER.error("Failed to parse type field of ${stack.last()} while loading $id, ignoring", e)
-            return null
-        }
+            "type" in jsonObject -> {
+                val typeId = jsonObject.getAsResourceLocation("type")
+                val parser = SplicingTableIotaRenderers.getParser(typeId)
+                    ?: throw JsonParseException("Parser type $typeId not found")
+                @Suppress("UNCHECKED_CAST") // shhhhhhh
+                parser as AnyRendererParser to null
+            }
 
-        val parser = SplicingTableIotaRenderers.getParser(typeId)
-        if (parser == null) {
-            HexDebug.LOGGER.error("Unrecognized type $typeId for ${stack.last()} while loading $id, ignoring")
-            return null
+            else -> throw JsonParseException("Expected parent or type field but got neither")
         }
 
-        return stack to parser
+        // there may be more recursion here if the parser calls loadProvider or parseProvider
+        return parser to parser.parse(GSON, jsonObject, parent)
     }
 }
+
+class ProviderVisitException(message: String? = null, cause: Throwable? = null) : IllegalStateException(message, cause)
