From 29857bff0875c43e055e89d34bc0d616d5d7dc4f Mon Sep 17 00:00:00 2001
From: Linnea Gräf <nea@nea.moe>
Date: Wed, 29 Jan 2025 00:26:56 +0100
Subject: Load universe from json

---
 src/main/kotlin/util/KSerializable.kt | 112 ++++++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 src/main/kotlin/util/KSerializable.kt

(limited to 'src/main/kotlin/util/KSerializable.kt')

diff --git a/src/main/kotlin/util/KSerializable.kt b/src/main/kotlin/util/KSerializable.kt
new file mode 100644
index 0000000..ef4c953
--- /dev/null
+++ b/src/main/kotlin/util/KSerializable.kt
@@ -0,0 +1,112 @@
+package util
+import com.google.gson.*
+import com.google.gson.annotations.SerializedName
+import com.google.gson.reflect.TypeToken
+import com.google.gson.stream.JsonReader
+import com.google.gson.stream.JsonToken
+import com.google.gson.stream.JsonWriter
+import kotlin.reflect.*
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.jvm.javaType
+import com.google.gson.internal.`$Gson$Types` as InternalGsonTypes
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.CLASS)
+annotation class KSerializable(
+)
+
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.PROPERTY)
+annotation class ExtraData
+
+
+class KotlinTypeAdapterFactory : TypeAdapterFactory {
+
+    internal data class ParameterInfo(
+        val param: KParameter,
+        val adapter: TypeAdapter<Any?>,
+        val name: String,
+        val field: KProperty1<Any, Any?>
+    )
+
+    override fun <T : Any> create(gson: Gson, type: TypeToken<T>): TypeAdapter<T>? {
+        val kotlinClass = type.rawType.kotlin as KClass<T>
+        if (kotlinClass.findAnnotation<KSerializable>() == null) return null
+        if (!kotlinClass.isData) return null
+        val primaryConstructor = kotlinClass.primaryConstructor ?: return null
+        val params = primaryConstructor.parameters.filter { it.findAnnotation<ExtraData>() == null }
+        val extraDataParam = primaryConstructor.parameters
+            .find { it.findAnnotation<ExtraData>() != null }
+            ?.let { param ->
+				require(typeOf<MutableMap<String, JsonElement>>().isSubtypeOf(param.type))
+                param to kotlinClass.memberProperties.find { it.name == param.name && it.returnType.isSubtypeOf(typeOf<Map<String, JsonElement>>()) } as KProperty1<Any, Map<String, JsonElement>>
+            }
+        val parameterInfos = params.map { param ->
+            ParameterInfo(
+                param,
+                gson.getAdapter(
+                    TypeToken.get(InternalGsonTypes.resolve(type.type, type.rawType, param.type.javaType))
+                ) as TypeAdapter<Any?>,
+                param.findAnnotation<SerializedName>()?.value ?: param.name!!,
+                kotlinClass.memberProperties.find { it.name == param.name }!! as KProperty1<Any, Any?>
+            )
+        }.associateBy { it.name }
+        val jsonElementAdapter = gson.getAdapter(JsonElement::class.java)
+
+        return object : TypeAdapter<T>() {
+            override fun write(out: JsonWriter, value: T?) {
+                if (value == null) {
+                    out.nullValue()
+                    return
+                }
+                out.beginObject()
+                parameterInfos.forEach { (name, paramInfo) ->
+                    out.name(name)
+                    paramInfo.adapter.write(out, paramInfo.field.get(value))
+                }
+                if (extraDataParam != null) {
+                    val extraData = extraDataParam.second.get(value)
+                    extraData.forEach { (extraName, extraValue) ->
+                        out.name(extraName)
+                        jsonElementAdapter.write(out, extraValue)
+                    }
+                }
+                out.endObject()
+            }
+
+            override fun read(reader: JsonReader): T? {
+                if (reader.peek() == JsonToken.NULL) {
+                    reader.nextNull()
+                    return null
+                }
+                reader.beginObject()
+                val args = mutableMapOf<KParameter, Any?>()
+                val extraData = mutableMapOf<String, JsonElement>()
+                while (reader.peek() != JsonToken.END_OBJECT) {
+                    val name = reader.nextName()
+                    val paramData = parameterInfos[name]
+                    if (paramData == null) {
+                        extraData[name] = jsonElementAdapter.read(reader)
+                        continue
+                    }
+                    val value = paramData.adapter.read(reader)
+                    args[paramData.param] = value
+                }
+                reader.endObject()
+                if (extraDataParam == null) {
+                    if (extraData.isNotEmpty()) {
+                        throw JsonParseException("Encountered unknown keys ${extraData.keys} while parsing $type")
+                    }
+                } else {
+                    args[extraDataParam.first] = extraData
+                }
+                return primaryConstructor.callBy(args)
+            }
+        }
+    }
+}
+
-- 
cgit