Attempt at adding collection setting codecs

Author: emyfops

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

@@ -19,13 +19,14 @@ package com.lambda
 
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
-import com.lambda.config.serializer.BlockPosSerializer
-import com.lambda.config.serializer.BlockSerializer
+import com.lambda.config.serializer.BlockPosCodec
+import com.lambda.config.serializer.BlockCodec
 import com.lambda.config.serializer.ColorSerializer
-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.config.serializer.GameProfileCodec
+import com.lambda.config.serializer.ItemCodec
+import com.lambda.config.serializer.ItemStackCodec
+import com.lambda.config.serializer.KeyCodeCodec
+import com.lambda.config.serializer.OptionalCodec
 import com.lambda.core.Loader
 import com.lambda.event.events.ClientEvent
 import com.lambda.event.listener.UnsafeListener.Companion.listenOnceUnsafe
@@ -37,7 +38,12 @@ import net.fabricmc.api.ClientModInitializer
 import net.fabricmc.loader.api.FabricLoader
 import net.minecraft.block.Block
 import net.minecraft.client.MinecraftClient
+import net.minecraft.item.ArrowItem
+import net.minecraft.item.BlockItem
+import net.minecraft.item.Item
 import net.minecraft.item.ItemStack
+import net.minecraft.item.PotionItem
+import net.minecraft.item.RangedWeaponItem
 import net.minecraft.registry.DynamicRegistryManager
 import net.minecraft.text.Text
 import net.minecraft.util.math.BlockPos
@@ -66,14 +72,20 @@ object Lambda : ClientModInitializer {
 
     val gson: Gson = GsonBuilder()
         .setPrettyPrinting()
-        .registerTypeAdapter(KeyCode::class.java, KeyCodeSerializer)
+        .registerTypeAdapter(KeyCode::class.java, KeyCodeCodec)
         .registerTypeAdapter(Color::class.java, ColorSerializer)
-        .registerTypeAdapter(BlockPos::class.java, BlockPosSerializer)
-        .registerTypeAdapter(Block::class.java, BlockSerializer)
-        .registerTypeAdapter(GameProfile::class.java, GameProfileSerializer)
-        .registerTypeAdapter(Optional::class.java, OptionalSerializer)
-        .registerTypeAdapter(ItemStack::class.java, ItemStackSerializer)
+        .registerTypeAdapter(BlockPos::class.java, BlockPosCodec)
+        .registerTypeAdapter(Block::class.java, BlockCodec)
+        .registerTypeAdapter(GameProfile::class.java, GameProfileCodec)
+        .registerTypeAdapter(Optional::class.java, OptionalCodec)
+        .registerTypeAdapter(ItemStack::class.java, ItemStackCodec)
         .registerTypeAdapter(Text::class.java, Text.Serializer(DynamicRegistryManager.EMPTY))
+        // We have to add all item sub classes :/. I probably missed some
+        .registerTypeAdapter(Item::class.java, ItemCodec)
+        .registerTypeAdapter(BlockItem::class.java, ItemCodec)
+        .registerTypeAdapter(ArrowItem::class.java, ItemCodec)
+        .registerTypeAdapter(PotionItem::class.java, ItemCodec)
+        .registerTypeAdapter(RangedWeaponItem::class.java, ItemCodec)
         .create()
 
     override fun onInitializeClient() {} // nop

src/main/kotlin/com/lambda/config/Codec.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.config
+
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonSerializer
+
+interface Stringifiable<T> { fun stringify(value: T): String }
+
+interface Codec<T> : JsonSerializer<T>, JsonDeserializer<T>

src/main/kotlin/com/lambda/config/Configurable.kt

@@ -24,9 +24,8 @@ import com.lambda.Lambda.LOG
 import com.lambda.config.settings.CharSetting
 import com.lambda.config.settings.FunctionSetting
 import com.lambda.config.settings.StringSetting
-import com.lambda.config.settings.collections.ListSetting
+import com.lambda.config.settings.collections.CollectionSettings
 import com.lambda.config.settings.collections.MapSetting
-import com.lambda.config.settings.collections.SetSetting
 import com.lambda.config.settings.comparable.BooleanSetting
 import com.lambda.config.settings.comparable.EnumSetting
 import com.lambda.config.settings.complex.Bind
@@ -123,21 +122,41 @@ abstract class Configurable(
         visibility: () -> Boolean = { true },
     ) = StringSetting(name, defaultValue, multiline, flags, description, visibility).register()
 
+    inline fun <reified T : Any> setting(
+	    name: String,
+	    immutableList: Collection<T>,
+	    defaultValue: Collection<T> = immutableList,
+	    description: String = "",
+	    serializer: Stringifiable<T>,
+	    noinline visibility: () -> Boolean = { true },
+    ) = CollectionSettings(
+        name,
+        immutableList,
+        defaultValue.toMutableList(),
+        TypeToken.getParameterized(MutableList::class.java, T::class.java).type,
+        description,
+        serializer,
+        visibility,
+    ).register()
+
     inline fun <reified T : Any> setting(
         name: String,
-        immutableList: List<T>,
-        defaultValue: List<T>,
+        immutableList: Collection<T>,
+        defaultValue: Collection<T> = immutableList,
         description: String = "",
+        crossinline serializer: (T) -> String = { if (it::class.java.isPrimitive) it.toString() else it::class.java.simpleName },
         noinline visibility: () -> Boolean = { true },
-    ) = ListSetting(
+    ) = CollectionSettings(
         name,
         immutableList,
         defaultValue.toMutableList(),
-        TypeToken.getParameterized(MutableList::class.java, T::class.java).type,
+        TypeToken.getParameterized(Collection::class.java, T::class.java).type,
         description,
+        object : Stringifiable<T> { override fun stringify(value: T) = serializer(value) },
         visibility,
     ).register()
 
+    // ToDo: Actually implement maps
     inline fun <reified K : Any, reified V : Any> setting(
         name: String,
         defaultValue: Map<K, V>,
@@ -151,21 +170,6 @@ abstract class Configurable(
         visibility
     ).register()
 
-    inline fun <reified T : Any> setting(
-        name: String,
-        immutableList: Set<T>,
-        defaultValue: Set<T> = immutableList,
-        description: String = "",
-        noinline visibility: () -> Boolean = { true },
-    ) = SetSetting(
-        name,
-        immutableList,
-        defaultValue.toMutableSet(),
-        TypeToken.getParameterized(MutableSet::class.java, T::class.java).type,
-        description,
-        visibility,
-    ).register()
-
     fun setting(
         name: String,
         defaultValue: Double,

src/main/kotlin/com/lambda/config/UserAutomationConfig.kt

@@ -18,10 +18,12 @@
 package com.lambda.config
 
 import com.lambda.config.configurations.UserAutomationConfigs
+import com.lambda.config.serializer.ItemCodec
+import com.lambda.module.Module
 import com.lambda.module.ModuleRegistry.moduleNameMap
 
 class UserAutomationConfig(override val name: String) : AutomationConfig(name, UserAutomationConfigs) {
-    val linkedModules = setting("Linked Modules", moduleNameMap.filter { it.value.defaultAutomationConfig != Companion.DEFAULT }.keys, emptySet())
+    val linkedModules = setting<String>("Linked Modules", moduleNameMap.filter { it.value.defaultAutomationConfig != Companion.DEFAULT }.keys, emptySet(), serializer = { it })
         .onSelect { module -> moduleNameMap[module]?.automationConfig = this@UserAutomationConfig }
         .onDeselect { module ->
             moduleNameMap[module]?.let { module ->

src/main/kotlin/com/lambda/config/groups/ActionConfig.kt

@@ -23,7 +23,7 @@ import com.lambda.util.NamedEnum
 
 interface ActionConfig {
     val sorter: SortMode
-    val tickStageMask: Set<TickEvent>
+    val tickStageMask: Collection<TickEvent>
 
     enum class SortMode(
         override val displayName: String,

src/main/kotlin/com/lambda/config/groups/EatConfig.kt

@@ -31,19 +31,19 @@ import net.minecraft.item.ItemStack
 interface EatConfig {
     val eatOnHunger: Boolean
     val minFoodLevel: Int
-    val nutritiousFood: List<Item>
+    val nutritiousFood: Collection<Item>
     val saturated: Saturation
 
     val eatOnFire: Boolean
-    val resistanceFood: List<Item>
+    val resistanceFood: Collection<Item>
 
     val eatOnDamage: Boolean
     val minDamage: Int
-    val regenerationFood: List<Item>
+    val regenerationFood: Collection<Item>
 
     val selectionPriority: SelectionPriority
     val ignoreBadFood: Boolean
-    val badFood: List<Item>
+    val badFood: Collection<Item>
 
     enum class Saturation(
         override val displayName: String,

src/main/kotlin/com/lambda/config/groups/EatSettings.kt

@@ -19,7 +19,9 @@ package com.lambda.config.groups
 
 import com.lambda.config.Configurable
 import com.lambda.config.SettingGroup
+import com.lambda.config.serializer.ItemCodec
 import com.lambda.util.NamedEnum
+import net.minecraft.item.Item
 import net.minecraft.item.Items
 
 class EatSettings(
@@ -34,13 +36,13 @@ class EatSettings(
     override val eatOnHunger by c.setting("Eat On Hunger", true, "Whether to eat when hungry").group(baseGroup).index()
     override val minFoodLevel by c.setting("Minimum Food Level", 6, 0..20, 1, "The minimum food level to eat food", " food level") { eatOnHunger }.group(baseGroup).index()
     override val saturated by c.setting("Saturated", EatConfig.Saturation.EatSmart, "When to stop eating") { eatOnHunger }.group(baseGroup).index()
-    override val nutritiousFood by c.setting("Nutritious Food", nutritiousFoodDefaults, nutritiousFoodDefaults, "Items that are be considered nutritious") { eatOnHunger }.group(baseGroup).index()
+    override val nutritiousFood by c.setting<Item>("Nutritious Food", nutritiousFoodDefaults, nutritiousFoodDefaults, "Items that are be considered nutritious", ItemCodec) { eatOnHunger }.group(baseGroup).index()
     override val selectionPriority by c.setting("Selection Priority", EatConfig.SelectionPriority.MostNutritious, "The priority for selecting food items") { eatOnHunger }.group(baseGroup).index()
     override val eatOnFire by c.setting("Eat On Fire", true, "Whether to eat when on fire").group(baseGroup).index()
-    override val resistanceFood by c.setting("Resistance Food", resistanceFoodDefaults, resistanceFoodDefaults, "Items that give Fire Resistance") { eatOnFire }.group(baseGroup).index()
+    override val resistanceFood by c.setting<Item>("Resistance Food", resistanceFoodDefaults, resistanceFoodDefaults, "Items that give Fire Resistance", ItemCodec) { eatOnFire }.group(baseGroup).index()
     override val eatOnDamage by c.setting("Eat On Damage", true, "Whether to eat when damaged").group(baseGroup).index()
     override val minDamage by c.setting("Minimum Damage", 10, 0..20, 1, "The minimum damage threshold to trigger eating") { eatOnDamage }.group(baseGroup).index()
-    override val regenerationFood by c.setting("Regeneration Food", regenerationFoodDefaults, regenerationFoodDefaults, "Items that give Regeneration") { eatOnDamage }.group(baseGroup).index()
+    override val regenerationFood by c.setting<Item>("Regeneration Food", regenerationFoodDefaults, regenerationFoodDefaults, "Items that give Regeneration", ItemCodec) { eatOnDamage }.group(baseGroup).index()
     override val ignoreBadFood by c.setting("Ignore Bad Food", true, "Whether to eat when the food is bad").group(baseGroup).index()
-    override val badFood by c.setting("Bad Food", negativeFoodDefaults, negativeFoodDefaults, "Items that are considered bad food") { ignoreBadFood }.group(baseGroup).index()
+    override val badFood by c.setting<Item>("Bad Food", negativeFoodDefaults, negativeFoodDefaults, "Items that are considered bad food", ItemCodec) { ignoreBadFood }.group(baseGroup).index()
 }

…bda/config/serializer/BlockSerializer.kt …m/lambda/config/serializer/BlockCodec.ktsrc/main/kotlin/com/lambda/config/serializer/BlockSerializer.kt renamed to src/main/kotlin/com/lambda/config/serializer/BlockCodec.kt src/main/kotlin/com/lambda/config/serializer/BlockSerializer.kt renamed to src/main/kotlin/com/lambda/config/serializer/BlockCodec.kt

@@ -18,16 +18,16 @@
 package com.lambda.config.serializer
 
 import com.google.gson.JsonDeserializationContext
-import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
 import com.google.gson.JsonSerializationContext
-import com.google.gson.JsonSerializer
+import com.lambda.config.Codec
+import com.lambda.config.Stringifiable
 import com.mojang.serialization.JsonOps
 import net.minecraft.block.Block
 import net.minecraft.registry.Registries
 import java.lang.reflect.Type
 
-object BlockSerializer : JsonSerializer<Block>, JsonDeserializer<Block> {
+object BlockCodec : Codec<Block>, Stringifiable<Block> {
     override fun serialize(
         src: Block,
         typeOfSrc: Type,
@@ -43,4 +43,6 @@ object BlockSerializer : JsonSerializer<Block>, JsonDeserializer<Block> {
     ): Block =
         Registries.BLOCK.codec.parse(JsonOps.INSTANCE, json)
             .orThrow
+
+    override fun stringify(value: Block) = Registries.BLOCK.getId(value).path.replaceFirstChar { it.uppercase() }
 }

…/config/serializer/BlockPosSerializer.kt …ambda/config/serializer/BlockPosCodec.ktsrc/main/kotlin/com/lambda/config/serializer/BlockPosSerializer.kt renamed to src/main/kotlin/com/lambda/config/serializer/BlockPosCodec.kt src/main/kotlin/com/lambda/config/serializer/BlockPosSerializer.kt renamed to src/main/kotlin/com/lambda/config/serializer/BlockPosCodec.kt

@@ -22,12 +22,15 @@ import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
 import com.google.gson.JsonSerializationContext
 import com.google.gson.JsonSerializer
+import com.lambda.config.Codec
+import com.lambda.config.Stringifiable
+import com.lambda.util.Formatting.format
 import com.mojang.serialization.JsonOps
 import net.minecraft.util.math.BlockPos
 import java.lang.reflect.Type
 import kotlin.jvm.optionals.getOrElse
 
-object BlockPosSerializer : JsonSerializer<BlockPos>, JsonDeserializer<BlockPos> {
+object BlockPosCodec : Codec<BlockPos>, Stringifiable<BlockPos> {
     override fun serialize(
         src: BlockPos,
         typeOfSrc: Type,
@@ -44,4 +47,6 @@ object BlockPosSerializer : JsonSerializer<BlockPos>, JsonDeserializer<BlockPos>
         BlockPos.CODEC.parse(JsonOps.INSTANCE, json)
             .result()
             .getOrElse { BlockPos.ORIGIN }
+
+    override fun stringify(value: BlockPos) = value.format()
 }

src/main/kotlin/com/lambda/config/serializer/ColorSerializer.kt

@@ -18,36 +18,35 @@
 package com.lambda.config.serializer
 
 import com.google.gson.JsonDeserializationContext
-import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
-import com.google.gson.JsonNull
 import com.google.gson.JsonParseException
 import com.google.gson.JsonPrimitive
 import com.google.gson.JsonSerializationContext
-import com.google.gson.JsonSerializer
+import com.lambda.config.Codec
+import com.lambda.config.Stringifiable
 import java.awt.Color
 import java.lang.reflect.Type
 
-object ColorSerializer : JsonSerializer<Color>, JsonDeserializer<Color> {
+object ColorSerializer : Codec<Color>, Stringifiable<Color> {
     override fun serialize(
-        src: Color?,
-        typeOfSrc: Type?,
+        src: Color,
+        typeOfSrc: Type,
         context: JsonSerializationContext?,
     ): JsonElement =
-        src?.let {
-            JsonPrimitive("${it.red},${it.green},${it.blue},${it.alpha}")
-        } ?: JsonNull.INSTANCE
+        JsonPrimitive("${src.red},${src.green},${src.blue},${src.alpha}")
 
     override fun deserialize(
-        json: JsonElement?,
-        typeOfT: Type?,
+        json: JsonElement,
+        typeOfT: Type,
         context: JsonDeserializationContext?,
     ): Color =
-        json?.asString?.split(",")?.let {
+        json.asString.split(",").let {
             when (it.size) {
                 3 -> Color(it[0].toInt(), it[1].toInt(), it[2].toInt())
                 4 -> Color(it[0].toInt(), it[1].toInt(), it[2].toInt(), it[3].toInt())
                 else -> throw JsonParseException("Invalid color format")
             }
-        } ?: throw JsonParseException("Invalid color format")
+        }
+
+    override fun stringify(value: Color) = "${value.red},${value.green},${value.blue},${value.alpha}"
 }