Add serializer for ReferenceSet

Author: Rothes

core/src/main/kotlin/io/github/rothes/esu/core/configuration/ConfigLoader.kt

@@ -25,6 +25,7 @@ import io.github.rothes.esu.lib.configurate.yaml.NodeStyle
 import io.github.rothes.esu.lib.configurate.yaml.YamlConfigurationLoader
 import io.leangen.geantyref.GenericTypeReflector
 import io.leangen.geantyref.TypeToken
+import it.unimi.dsi.fastutil.objects.ReferenceSet
 import net.kyori.adventure.text.Component
 import java.io.File
 import java.lang.reflect.Type
@@ -354,6 +355,7 @@ object ConfigLoader {
                                     GenericTypeReflector.annotate(type).isAnnotationPresent(ConfigSerializable::class.java)
                                 }, objectSerializer
                             )
+                            .register(TypeToken.get(ReferenceSet::class.java), ReferenceSetSerializer)
                             .register(TypeToken.get(List::class.java), ListSerializer)
                             .register(TypeToken.get(Map::class.java), MapSerializer)
                             .register(TypeToken.get(Optional::class.java), OptionalSerializer)

core/src/main/kotlin/io/github/rothes/esu/core/configuration/serializer/AbstractListSerializer.kt

@@ -0,0 +1,35 @@
+package io.github.rothes.esu.core.configuration.serializer
+
+import io.github.rothes.esu.core.configuration.meta.NoDeserializeNull
+import io.github.rothes.esu.lib.configurate.ConfigurationOptions
+import io.github.rothes.esu.lib.configurate.serialize.AbstractListChildSerializer
+import io.github.rothes.esu.lib.configurate.serialize.SerializationException
+import io.github.rothes.esu.lib.configurate.util.CheckedConsumer
+import java.lang.reflect.AnnotatedParameterizedType
+import java.lang.reflect.AnnotatedType
+
+abstract class AbstractListSerializer<T>: AbstractListChildSerializer<T>() {
+
+    override fun emptyValue(specificType: AnnotatedType, options: ConfigurationOptions): T? {
+        if (specificType.isAnnotationPresent(NoDeserializeNull::class.java)) {
+            return null
+        }
+        return super.emptyValue(specificType, options)
+    }
+
+    override fun deserializeSingle(index: Int, collection: T, deserialized: Any?) {
+        @Suppress("UNCHECKED_CAST") (collection as MutableCollection<Any?>).add(deserialized)
+    }
+
+    override fun forEachElement(collection: T, action: CheckedConsumer<Any, SerializationException>) {
+        @Suppress("UNCHECKED_CAST") (collection as Iterable<Any?>).forEach { action.accept(it) }
+    }
+
+    override fun elementType(containerType: AnnotatedType?): AnnotatedType {
+        if (containerType !is AnnotatedParameterizedType) {
+            throw SerializationException(containerType, "Raw types are not supported for collections")
+        }
+        return containerType.annotatedActualTypeArguments[0]
+    }
+
+}

core/src/main/kotlin/io/github/rothes/esu/core/configuration/serializer/ListSerializer.kt

@@ -1,39 +1,11 @@
 package io.github.rothes.esu.core.configuration.serializer
 
-import io.github.rothes.esu.core.configuration.meta.NoDeserializeNull
-import io.github.rothes.esu.lib.configurate.ConfigurationOptions
-import io.github.rothes.esu.lib.configurate.serialize.AbstractListChildSerializer
-import io.github.rothes.esu.lib.configurate.serialize.SerializationException
-import io.github.rothes.esu.lib.configurate.util.CheckedConsumer
-import java.lang.reflect.AnnotatedParameterizedType
 import java.lang.reflect.AnnotatedType
 
-object ListSerializer: AbstractListChildSerializer<List<*>>() {
+object ListSerializer: AbstractListSerializer<List<*>>() {
 
-    override fun emptyValue(specificType: AnnotatedType, options: ConfigurationOptions): List<*>? {
-        if (specificType.isAnnotationPresent(NoDeserializeNull::class.java)) {
-            return null
-        }
-        return super.emptyValue(specificType, options)
-    }
-
-    override fun deserializeSingle(index: Int, collection: List<*>, deserialized: Any?) {
-        @Suppress("UNCHECKED_CAST") (collection as MutableList<Any?>).add(deserialized)
-    }
-
-    override fun forEachElement(collection: List<*>, action: CheckedConsumer<Any, SerializationException>) {
-        collection.forEach { action.accept(it) }
-    }
-
-    override fun elementType(containerType: AnnotatedType?): AnnotatedType {
-        if (containerType !is AnnotatedParameterizedType) {
-            throw SerializationException(containerType, "Raw types are not supported for collections")
-        }
-        return containerType.annotatedActualTypeArguments[0]
-    }
-
-    override fun createNew(length: Int, elementType: AnnotatedType?): List<*> {
-        return arrayListOf<Any>()
+    override fun createNew(length: Int, elementType: AnnotatedType?): List<Any?> {
+        return ArrayList(length)
     }
 
 }

core/src/main/kotlin/io/github/rothes/esu/core/configuration/serializer/ReferenceSetSerializer.kt

@@ -0,0 +1,14 @@
+package io.github.rothes.esu.core.configuration.serializer
+
+import it.unimi.dsi.fastutil.objects.ReferenceArraySet
+import it.unimi.dsi.fastutil.objects.ReferenceLinkedOpenHashSet
+import it.unimi.dsi.fastutil.objects.ReferenceSet
+import java.lang.reflect.AnnotatedType
+
+object ReferenceSetSerializer: AbstractListSerializer<ReferenceSet<*>>() {
+
+    override fun createNew(length: Int, elementType: AnnotatedType?): ReferenceSet<Any> {
+        return if (length <= 3) ReferenceArraySet(length) else ReferenceLinkedOpenHashSet(length)
+    }
+
+}