companion object

Enum.values()

jsonValue

T: Enum

companion object {
  val myConverter = Converter(SomeType::class)
}

SomeType

SomeOtherType

interface JsonValue {
    val jsonValue: String
}

interface JsonConverter<T: JsonValue> {    
    fun getValues(): Array<T>
    
    fun convertFromJsonType(jsonValue: String): T {
        return try {
            getValues().first { it.jsonValue == jsonValue }
        } catch (e: NoSuchElementException) {
            throw NoSuchElementException("Cannot find a SomeType for jsonValue $jsonValue")
        }
    }
}

enum class SomeType(override val jsonValue: String): JsonValue {
   // X = enum name, a = value in JSON
   X("a"),
   Y("b"),
   ;
    
   // now this is the annoying part...
   companion object : JsonConverter<SomeType>  {
       override fun getValues() = SomeType.values()
   }
}

enumValues<T>

class MyConverter<E: Enum<E>>(val clazz: KClass<E>, val values: () -> Array<E>) where E: JsonValue

inline fun createConverter<reified E: Enum<E>>() where E: JsonValue = MyConverter { enumValues<T>() }

JsonValueEnum

interface JsonValueEnum {
   val jsonValue: String
}

enum class SomeType(override val jsonValue: String): JsonValueEnum {
   // X = enum name, a = value in JSON
   X("a"),
   Y("b"),
   ;
    
    val GSON_TYPE_ADAPTER = createAdapter<SomeType>()
}
    
class MyAdapter<E: JsonValueEnum>(val values: () -> Array<E>) : TypeAdapter<E?>() {
    override fun write(output: JsonWriter?, value: E?) {
        if (value != null) output?.jsonValue(value.jsonValue) else output?.nullValue()
    }

    override fun read(input: JsonReader?): E? {
        val strValue = input?.nextString()
        return if (strValue != null) convertFromJsonValue(strValue) else null
    }
        
    private fun convertFromJsonValue(jsonValue: String): E {
        return try {
            // what should I put here?
            values().first { it.jsonValue == jsonValue }
        } catch (e: NoSuchElementException) {
            throw NoSuchElementException("Cannot find Enum-Value for jsonValue $jsonValue")
        }
    }
}

inline fun <reified E> createAdapter() where E: JsonValueEnum, E: Enum<E> = MyAdapter { enumValues<E>() }

Illegal usage of inline-parameter 'jsonValue' in 'public inline fun <reified E : Enum<E>> createJsonConverter(jsonValue: (E) -> String): MyConverter<E> defined in YadaYada.kt'. Add 'noinline' modifier to the parameter declaration

interface JsonValueEnum {
    val jsonValue: String
}

class MyAdapter<E>(val serialize: (E) -> String, val deserialize: (String) -> E) : TypeAdapter<E?>() {
    override fun write(output: JsonWriter?, value: E?) {
        if (value != null) output?.jsonValue(serialize(value)) else output?.nullValue()
    }

    override fun read(input: JsonReader?): E? {
        val strValue = input?.nextString()
        return if (strValue != null) deserialize(strValue) else null
    }
}

inline fun <reified E: Enum<E>> createEnumAdapter(noinline serialize: (E) -> String, noinline  match: (E, String) -> Boolean): MyAdapter<E> {
    return MyAdapter(serialize, { jsonValue -> enumValues<E>().first { match(it, jsonValue) } })
}

inline fun <reified E> createJsonValueEnumAdapter(): MyAdapter<E> where E: Enum<E>, E: JsonValueEnum {
    return createEnumAdapter<E>({ it.jsonValue }, { enumValue, stringValue -> enumValue.jsonValue == stringValue })
}