Kotlin

As of version 3.7, Configurate provides several extensions to improve integration with Kotlin.

Setup

In Gradle:

dependencies {
    implementation("org.spongepowered:configurate-extra-kotlin:4.0.0")
}

In Maven:

<dependencies>
    <!-- ... -->
    <dependency>
        <groupId>org.spongepowered</groupId>
        <artifactId>configurate-extra-kotlin</artifactId>
        <verison>4.0.0</version>
    </dependency>
    <!-- ... -->
</dependencies>

General

To interact more easily with mapped types, there are extensions using reified type parameters to generate the appropriate type token: node.get<T>(default: T? = null) and node.set<T>(value: T), and extensions using KClass<T> rather than Java's Class to remove some of the interoperability friction

Object Mapping

The T.mapper() extension function allows accessing an ObjectMapper built for any object type, and the function objectMapper<T>() allows accessing object mappers constructed for a specific generic type on the default object mapper factory. ObjectMapperFactory.getMapper<T>() and TypeSerializerCollection.get<T>() both allow accessing their respective types by using generic types, rather than explicit TypeTokens.

since 4.0: Kotlin extras adds support for using data classes with the ObjectMapper, as long as kotlin-reflect is available. The mapper factory returned by the extension functions in the extra-kotlin module is already configured to use this. When using other ways of accessing node values, you'll want to configure this yourself:

val loader = HoconConfigurationLoader.builder()
    .path(source)
    .defaultOptions { options ->
        options.serializers { builder ->
            builder.registerAnnotatedObjects(objectMapperFactory())
        }
    }
    .build()
val node = loader.load()
// set serialization type implicitly
var config: Config? = node.get()
// or specify it explicitly
config = node.get(Config::class)
config = node.get<Config>()

// This annotation is necessary for our objectMapperFactory above to match the filter
@ConfigSerializable
data class Config(val one: String?, val two: String?)

kotlinx.serialization

While Configurate does not directly provide support for kotlinx.serialization, there is a community project at ItsDoot/configurate-serialization that can currently deserialize a node into a Kotlin Serializable object.

Flows

With Configurate's Publisher API used for file and value watchers, listeners are able to be converted into Kotlin's Flows for better integration with Kotlin's coroutine concurrency.