com.simiacryptus.util.DynamicEnum.kt Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of jo-penai Show documentation

A Java client for OpenAI's API

There is a newer version: 1.1.12

package com.simiacryptus.util

import com.fasterxml.jackson.core.JsonGenerator
import com.fasterxml.jackson.core.JsonParser
import com.fasterxml.jackson.databind.*
import com.fasterxml.jackson.databind.node.ObjectNode
import com.fasterxml.jackson.databind.node.TextNode
import com.fasterxml.jackson.databind.ser.std.StdSerializer

open class DynamicEnum>(val name: String) {
    companion object {
        private val registries = mutableMapOf, MutableList>>>()

        internal fun  getRegistry(clazz: Class): MutableList> {
            @Suppress("UNCHECKED_CAST")
            return registries.getOrPut(clazz) { mutableListOf() } as MutableList>
        }

        fun  valueOf(clazz: Class, name: String): T {
            return getRegistry(clazz).toMap().get(name)
                ?: throw IllegalArgumentException("Unknown enum constant: $name")
        }

        fun > values(clazz: Class): List {
            return getRegistry(clazz).map { it.second }
        }

        @JvmStatic
        fun > register(clazz: Class, enumConstant: T) {
            getRegistry(clazz).add(enumConstant.name to enumConstant)
        }
    }

    override fun toString() = name
    override fun hashCode() = name.hashCode()
    override fun equals(other: Any?): Boolean {
        return this === other || other is DynamicEnum<*> && name == other.name
    }
}

abstract class DynamicEnumSerializer>(
    private val clazz: Class
) : StdSerializer(clazz) {
    override fun serialize(value: T, gen: JsonGenerator, provider: SerializerProvider) {
        DynamicEnum.getRegistry(clazz).find { it.second == value }?.first?.let { gen.writeString(it) }
    }
}

abstract class DynamicEnumDeserializer>(
    private val clazz: Class
) : JsonDeserializer() {
    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): T {
        return when (val node = p.codec.readTree(p)) {
            is TextNode -> DynamicEnum.getRegistry(clazz).toMap()[node.asText()]
                ?: throw JsonMappingException(p, "Unknown enum constant: " + node.asText())

            is ObjectNode -> DynamicEnum.getRegistry(clazz).toMap()[node.get("name")?.asText()]
                ?: throw JsonMappingException(p, "Unknown enum constant: " + node.toPrettyString())

            else -> throw JsonMappingException(p, "Unexpected JSON value type: ${node.nodeType}")
        }
    }
}