diff --git a/gradle.properties b/gradle.properties index acfa0f5bc..4dc5bdf62 100644 --- a/gradle.properties +++ b/gradle.properties @@ -7,6 +7,6 @@ org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled javaVersion=21 mcVersion=1.21.10 group=dev.slne.surf -version=1.21.10-2.42.4 +version=1.21.10-2.43.0 relocationPrefix=dev.slne.surf.surfapi.libs snapshot=false \ No newline at end of file diff --git a/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api b/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api index fdb8a7e71..981d4ce1a 100644 --- a/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api +++ b/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api @@ -5974,11 +5974,36 @@ public final class dev/slne/surf/surfapi/core/api/command/exception/WrapperComma public abstract interface annotation class dev/slne/surf/surfapi/core/api/config/JsonConfigFileNamePattern : java/lang/annotation/Annotation { } +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public synthetic fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public final fun getConfig ()Ljava/lang/Object; + protected final fun getConfigFolder ()Ljava/nio/file/Path; + protected final fun getFileName ()Ljava/lang/String; + public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; + public final fun init ()V + public final fun reloadFromFile ()Ljava/lang/Object; + public final fun save ()V +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + public abstract interface class dev/slne/surf/surfapi/core/api/config/SurfConfigApi { public static final field Companion Ldev/slne/surf/surfapi/core/api/config/SurfConfigApi$Companion; public abstract fun createDazzlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; public abstract fun createSpongeJsonConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeJsonConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun createSpongeYmlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeYmlConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun getDazzlConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfigManagerForConfig (Ljava/lang/Class;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; @@ -6034,6 +6059,8 @@ public final class dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigMan public static final field Companion Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager$Companion; public field config Ljava/lang/Object; public synthetic fun (Ljava/lang/Class;Ljava/lang/Object;Lorg/spongepowered/configurate/loader/ConfigurationLoader;Lorg/spongepowered/configurate/ConfigurationNode;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun reloadFromFile ()Ljava/lang/Object; public final fun save ()V } diff --git a/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/java/dev/slne/surf/surfapi/bukkit/test/BukkitPluginMain.java b/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/java/dev/slne/surf/surfapi/bukkit/test/BukkitPluginMain.java index 0cab53384..0dce23646 100644 --- a/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/java/dev/slne/surf/surfapi/bukkit/test/BukkitPluginMain.java +++ b/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/java/dev/slne/surf/surfapi/bukkit/test/BukkitPluginMain.java @@ -6,6 +6,7 @@ import dev.slne.surf.surfapi.bukkit.test.command.SurfApiTestCommand; import dev.slne.surf.surfapi.bukkit.test.command.subcommands.inventory.TestInventoryView; import dev.slne.surf.surfapi.bukkit.test.command.subcommands.reflection.Reflection; +import dev.slne.surf.surfapi.bukkit.test.config.ModernTestConfig; import dev.slne.surf.surfapi.bukkit.test.listener.ChatListener; import org.bukkit.plugin.java.JavaPlugin; import org.jetbrains.annotations.NotNull; @@ -19,6 +20,9 @@ public class BukkitPluginMain extends JavaPlugin { @Override public void onLoad() { + ModernTestConfig.Companion.init(); + ModernTestConfig.Companion.randomise(); + SurfBukkitPacketListenerApi.Companion.getInstance().registerListeners(new ChatListener()); InventoryFrameworkExtensions.register(TestInventoryView.INSTANCE); // TestConfig config = SurfCore#Api.getCore() diff --git a/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/kotlin/dev/slne/surf/surfapi/bukkit/test/config/ModernTestConfig.kt b/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/kotlin/dev/slne/surf/surfapi/bukkit/test/config/ModernTestConfig.kt new file mode 100644 index 000000000..5c129154e --- /dev/null +++ b/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/kotlin/dev/slne/surf/surfapi/bukkit/test/config/ModernTestConfig.kt @@ -0,0 +1,24 @@ +package dev.slne.surf.surfapi.bukkit.test.config + +import dev.slne.surf.surfapi.bukkit.test.BukkitPluginMain +import dev.slne.surf.surfapi.core.api.config.SpongeYmlConfigClass +import org.spongepowered.configurate.objectmapping.ConfigSerializable + +@ConfigSerializable +data class ModernTestConfig( + var message: String = "Hello from Modern Config!", + var number: Int = 42, + var enabled: Boolean = true +) { + companion object : SpongeYmlConfigClass( + ModernTestConfig::class.java, + BukkitPluginMain.getInstance().dataPath, + "modern-test-config.yml" + ) { + fun randomise() = edit { + message = "Random Message ${Math.random()}" + number = (Math.random() * 100).toInt() + enabled = Math.random() > 0.5 + } + } +} \ No newline at end of file diff --git a/surf-api-core/surf-api-core-api/api/surf-api-core-api.api b/surf-api-core/surf-api-core-api/api/surf-api-core-api.api index f1450ef07..a35b6503f 100644 --- a/surf-api-core/surf-api-core-api/api/surf-api-core-api.api +++ b/surf-api-core/surf-api-core-api/api/surf-api-core-api.api @@ -601,11 +601,36 @@ public final class dev/slne/surf/surfapi/core/api/command/exception/WrapperComma public abstract interface annotation class dev/slne/surf/surfapi/core/api/config/JsonConfigFileNamePattern : java/lang/annotation/Annotation { } +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public synthetic fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public final fun getConfig ()Ljava/lang/Object; + protected final fun getConfigFolder ()Ljava/nio/file/Path; + protected final fun getFileName ()Ljava/lang/String; + public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; + public final fun init ()V + public final fun reloadFromFile ()Ljava/lang/Object; + public final fun save ()V +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + public abstract interface class dev/slne/surf/surfapi/core/api/config/SurfConfigApi { public static final field Companion Ldev/slne/surf/surfapi/core/api/config/SurfConfigApi$Companion; public abstract fun createDazzlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; public abstract fun createSpongeJsonConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeJsonConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun createSpongeYmlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeYmlConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun getDazzlConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfigManagerForConfig (Ljava/lang/Class;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; @@ -661,6 +686,8 @@ public final class dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigMan public static final field Companion Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager$Companion; public field config Ljava/lang/Object; public synthetic fun (Ljava/lang/Class;Ljava/lang/Object;Lorg/spongepowered/configurate/loader/ConfigurationLoader;Lorg/spongepowered/configurate/ConfigurationNode;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun reloadFromFile ()Ljava/lang/Object; public final fun save ()V } diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt new file mode 100644 index 000000000..4b749949a --- /dev/null +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt @@ -0,0 +1,96 @@ +package dev.slne.surf.surfapi.core.api.config + +import dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager +import java.nio.file.Path + +/** + * Base convenience wrapper around a [SpongeConfigManager] for a specific config type [C]. + * + * This class is intended to be extended by companion objects of config data classes. + * It provides a simple, type-safe API to: + * - access the current config instance via [getConfig] + * - persist changes via [save] + * - reload the config from disk via [reloadFromFile] + * - perform in-place mutations via [edit] + * + * The actual manager instance is provided by subclasses and typically created by + * a central configuration API (e.g. [surfConfigApi]). + * + * @param C the type of the configuration data object. + * @param configClass the Java class of [C], used by underlying config frameworks + * to create and map configuration instances. + */ +sealed class SpongeConfigClass( + configClass: Class, + /** + * Folder where the configuration file is stored. + * + * Implementations should point this to a plugin- or module-specific config directory. + */ + protected val configFolder: Path, + /** + * The name of the configuration file, including its extension + * (for example `settings.yml` or `settings.json`). + */ + protected val fileName: String +) { + + /** + * The underlying configuration manager responsible for loading, saving, + * and tracking the config instance of type [C]. + */ + abstract val manager: SpongeConfigManager + + /** + * Persists the current configuration to disk. + * + * Delegates to [SpongeConfigManager.save]. + */ + fun save() = manager.save() + + /** + * Reloads the configuration from disk and replaces the current in-memory instance. + * + * Delegates to [SpongeConfigManager.reloadFromFile]. + * Use this when external changes to the config file should be picked up at runtime. + */ + fun reloadFromFile() = manager.reloadFromFile() + + /** + * Applies mutations to the current config instance in a safe way. + * + * The [block] receives the current config instance as receiver and can freely + * modify its properties. After the block completes, the config will be saved + * automatically if [save] is `true`. + * + * Example: + * ```kotlin + * MyConfig.edit { + * someField = "new value" + * } + * ``` + * + * @param save whether to persist the config to disk after applying [block]. Defaults to `true`. + * @param block mutation block executed on the current config instance. + */ + inline fun edit(save: Boolean = true, block: C.() -> Unit) = manager.edit(save, block) + + /** + * Returns the current in-memory configuration instance. + * + * The returned object is managed by the underlying [SpongeConfigManager] and + * will be replaced when [reloadFromFile] is called. + */ + fun getConfig(): C = manager.config + + /** + * Dummy initializer to force class loading and companion object initialization. + * + * This is useful in plugin entry points (e.g. `onLoad`) to ensure that: + * - the config manager is constructed + * - the configuration is loaded before first access via [getConfig] + * + * This method is a no-op and can be safely called multiple times. + */ + fun init() = Unit +} \ No newline at end of file diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt new file mode 100644 index 000000000..5813a91e8 --- /dev/null +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt @@ -0,0 +1,41 @@ +package dev.slne.surf.surfapi.core.api.config + +import java.nio.file.Path + +/** + * Convenience base class for JSON-backed Sponge configuration classes. + * + * This class wires the common configuration metadata ([configFolder], [fileName]) + * to a JSON-based [dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager] instance created by [surfConfigApi]. + * + * Typical usage is via a companion object on a `@ConfigSerializable` data class: + * ```kotlin + * @ConfigSerializable + * data class MyJsonConfig( + * var someField: String = "value" + * ) { + * companion object : SpongeJsonConfigClass( + * MyJsonConfig::class.java, + * Path("config/my-plugin"), + * "my-config.json" + * ) { + * } + * } + * ``` + * + * @param C the type of the configuration data object. + * @param configClass the Java class of [C], used by the underlying config framework. + */ +abstract class SpongeJsonConfigClass( + configClass: Class, configFolder: Path, fileName: String +) : SpongeConfigClass(configClass, configFolder, fileName) { + + /** + * JSON-backed configuration manager for this config type. + * + * The manager is created using [SurfConfigApi.createSpongeJsonConfigManager] + * with [configClass], [configFolder] and [fileName]. + */ + override val manager = + surfConfigApi.createSpongeJsonConfigManager(configClass, configFolder, fileName) +} \ No newline at end of file diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt new file mode 100644 index 000000000..466880a70 --- /dev/null +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt @@ -0,0 +1,41 @@ +package dev.slne.surf.surfapi.core.api.config + +import java.nio.file.Path + +/** + * Convenience base class for YAML-backed Sponge configuration classes. + * + * This class wires the common configuration metadata ([configFolder], [fileName]) + * to a YAML-based [dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager] instance created by [surfConfigApi]. + * + * Typical usage is via a companion object on a `@ConfigSerializable` data class: + * ```kotlin + * @ConfigSerializable + * data class MyConfig( + * var someField: String = "value" + * ) { + * companion object : SpongeYmlConfigClass( + * MyConfig::class.java, + * Path("config/my-plugin"), + * "my-config.yml" + * ) { + * } + * } + * ``` + * + * @param C the type of the configuration data object. + * @param configClass the Java class of [C], used by the underlying config framework. + */ +abstract class SpongeYmlConfigClass( + configClass: Class, configFolder: Path, fileName: String +) : SpongeConfigClass(configClass, configFolder, fileName) { + + /** + * YAML-backed configuration manager for this config type. + * + * The manager is created using [SurfConfigApi.createSpongeYmlConfigManager] + * with [configClass], [configFolder] and [fileName]. + */ + override val manager = + surfConfigApi.createSpongeYmlConfigManager(configClass, configFolder, fileName) +} \ No newline at end of file diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SurfConfigApi.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SurfConfigApi.kt index f7de1edbb..18300e47a 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SurfConfigApi.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SurfConfigApi.kt @@ -62,6 +62,21 @@ interface SurfConfigApi { configFileName: @YamlConfigFileNamePattern String, ): C + /** + * Creates a Sponge YAML configuration manager. + * + * @param C The type of the configuration class. + * @param configClass The class of the configuration. + * @param configFolder The folder where the configuration file is stored. + * @param configFileName The name of the configuration file. Must follow the YAML file name pattern. + * @return An instance of [SpongeConfigManager] for the configuration class [C]. + */ + fun createSpongeYmlConfigManager( + configClass: Class, + configFolder: Path, + configFileName: @YamlConfigFileNamePattern String, + ): SpongeConfigManager + /** * Creates a Sponge JSON configuration file. * @@ -77,6 +92,21 @@ interface SurfConfigApi { configFileName: @JsonConfigFileNamePattern String, ): C + /** + * Creates a Sponge JSON configuration manager. + * + * @param C The type of the configuration class. + * @param configClass The class of the configuration. + * @param configFolder The folder where the configuration file is stored. + * @param configFileName The name of the configuration file. Must follow the JSON file name pattern. + * @return An instance of [SpongeConfigManager] for the configuration class [C]. + */ + fun createSpongeJsonConfigManager( + configClass: Class, + configFolder: Path, + configFileName: @JsonConfigFileNamePattern String, + ): SpongeConfigManager + /** * Retrieves a Sponge configuration. * @@ -162,6 +192,19 @@ inline fun SurfConfigApi.createSpongeYmlConfig( configFileName: @YamlConfigFileNamePattern String, ) = createSpongeYmlConfig(C::class.java, configFolder, configFileName) +/** + * Creates a Sponge YAML configuration manager using a reified type. + * + * @param C The type of the configuration class. + * @param configFolder The folder where the configuration file is stored. + * @param configFileName The name of the configuration file. Must follow the YAML file name pattern. + * @return An instance of [SpongeConfigManager] for the configuration class [C]. + */ +inline fun SurfConfigApi.createSpongeYmlConfigManager( + configFolder: Path, + configFileName: @YamlConfigFileNamePattern String, +) = createSpongeYmlConfigManager(C::class.java, configFolder, configFileName) + /** * Creates a Sponge JSON configuration using a reified type. * @@ -175,6 +218,19 @@ inline fun SurfConfigApi.createSpongeJsonConfig( configFileName: @JsonConfigFileNamePattern String, ) = createSpongeJsonConfig(C::class.java, configFolder, configFileName) +/** + * Creates a Sponge JSON configuration manager using a reified type. + * + * @param C The type of the configuration class. + * @param configFolder The folder where the configuration file is stored. + * @param configFileName The name of the configuration file. Must follow the JSON file name pattern. + * @return An instance of [SpongeConfigManager] for the configuration class [C]. + */ +inline fun SurfConfigApi.createSpongeJsonConfigManager( + configFolder: Path, + configFileName: @JsonConfigFileNamePattern String, +) = createSpongeJsonConfigManager(C::class.java, configFolder, configFileName) + /** * Retrieves a Sponge configuration using a reified type. * diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager.kt index a9fd123f2..f384fd2ec 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager.kt @@ -78,6 +78,19 @@ class SpongeConfigManager @Contract(pure = true) private constructor( } } + /** + * Allows editing the configuration by applying changes within the provided block. + * Optionally saves the changes to the configuration file after applying the modifications. + * + * @param save Indicates whether the configuration should be saved after applying changes. Defaults to `true`. + * @param block A lambda with receiver scope of the configuration type to apply modifications. + */ + inline fun edit(save: Boolean = true, block: C.() -> Unit) { + config.block() + if (save) { + save() + } + } companion object { @@ -141,7 +154,8 @@ class SpongeConfigManager @Contract(pure = true) private constructor( try { val node: ScopedConfigurationNode<*> = loader.load() - val config = node.get(configClass) ?: throw LoadConfigException("Config is null after load") + val config = + node.get(configClass) ?: throw LoadConfigException("Config is null after load") loader.save(node) node.set(configClass, config) diff --git a/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SpongeConfigTracker.kt b/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SpongeConfigTracker.kt index a195aed6c..b81777ad3 100644 --- a/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SpongeConfigTracker.kt +++ b/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SpongeConfigTracker.kt @@ -1,12 +1,10 @@ package dev.slne.surf.surfapi.core.server.config import dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager -import dev.slne.surf.surfapi.core.api.util.mutableObject2ObjectMapOf -import dev.slne.surf.surfapi.core.api.util.synchronize +import java.util.concurrent.ConcurrentHashMap object SpongeConfigTracker { - private val configManagers = - mutableObject2ObjectMapOf, SpongeConfigManager<*>>().synchronize() + private val configManagers = ConcurrentHashMap, SpongeConfigManager<*>>() fun getConfig(configClass: Class): C? { return configManagers[configClass]?.config as? C @@ -24,5 +22,6 @@ object SpongeConfigTracker { } @Suppress("UNCHECKED_CAST") - fun getConfigManager(configClass: Class) = configManagers[configClass] as? SpongeConfigManager + fun getConfigManager(configClass: Class) = + configManagers[configClass] as? SpongeConfigManager } \ No newline at end of file diff --git a/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SurfConfigApiImpl.kt b/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SurfConfigApiImpl.kt index b063c93a5..deec1cf57 100644 --- a/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SurfConfigApiImpl.kt +++ b/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SurfConfigApiImpl.kt @@ -34,26 +34,42 @@ class SurfConfigApiImpl : SurfConfigApi { override fun reloadDazzlConfig(configClass: Class): C = DazzlConfConfigTracker.reloadConfig(configClass) - override fun createSpongeYmlConfig( + override fun createSpongeYmlConfigManager( configClass: Class, configFolder: Path, configFileName: @YamlConfigFileNamePattern String - ): C { + ): SpongeConfigManager { val manager = SpongeConfigManager.yaml(configClass, configFolder, configFileName) SpongeConfigTracker.registerConfig(configClass, manager) - return manager.config + return manager } - override fun createSpongeJsonConfig( + override fun createSpongeJsonConfigManager( configClass: Class, configFolder: Path, configFileName: @JsonConfigFileNamePattern String - ): C { + ): SpongeConfigManager { val manager = SpongeConfigManager.json(configClass, configFolder, configFileName) SpongeConfigTracker.registerConfig(configClass, manager) - return manager.config + return manager + } + + override fun createSpongeYmlConfig( + configClass: Class, + configFolder: Path, + configFileName: @YamlConfigFileNamePattern String + ): C { + return createSpongeYmlConfigManager(configClass, configFolder, configFileName).config + } + + override fun createSpongeJsonConfig( + configClass: Class, + configFolder: Path, + configFileName: @JsonConfigFileNamePattern String + ): C { + return createSpongeJsonConfigManager(configClass, configFolder, configFileName).config } override fun getSpongeConfig(configClass: Class): C = diff --git a/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api b/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api index d630db1d7..da145dbd0 100644 --- a/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api +++ b/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api @@ -3907,11 +3907,36 @@ public final class dev/slne/surf/surfapi/core/api/command/exception/WrapperComma public abstract interface annotation class dev/slne/surf/surfapi/core/api/config/JsonConfigFileNamePattern : java/lang/annotation/Annotation { } +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public synthetic fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public final fun getConfig ()Ljava/lang/Object; + protected final fun getConfigFolder ()Ljava/nio/file/Path; + protected final fun getFileName ()Ljava/lang/String; + public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; + public final fun init ()V + public final fun reloadFromFile ()Ljava/lang/Object; + public final fun save ()V +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + public abstract interface class dev/slne/surf/surfapi/core/api/config/SurfConfigApi { public static final field Companion Ldev/slne/surf/surfapi/core/api/config/SurfConfigApi$Companion; public abstract fun createDazzlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; public abstract fun createSpongeJsonConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeJsonConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun createSpongeYmlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeYmlConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun getDazzlConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfigManagerForConfig (Ljava/lang/Class;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; @@ -3967,6 +3992,8 @@ public final class dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigMan public static final field Companion Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager$Companion; public field config Ljava/lang/Object; public synthetic fun (Ljava/lang/Class;Ljava/lang/Object;Lorg/spongepowered/configurate/loader/ConfigurationLoader;Lorg/spongepowered/configurate/ConfigurationNode;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun reloadFromFile ()Ljava/lang/Object; public final fun save ()V }