Effektive Enums in Kotlin mit Reverse Lookup?

Ich versuche, den besten Weg zu finden, um eine Enum-Suche in einer Aufzählung in Kotlin durchzuführen. Eine meiner Erkenntnisse aus Effective Java war, dass Sie eine statische Karte in die Enumeration einführen, um die umgekehrte Suche durchzuführen. Wenn ich dies mit einer einfachen Aufzählung nach Kotlin portiere, komme ich zu Code, der so aussieht:

enum class Type(val value: Int) {
    A(1),
    B(2),
    C(3);

    companion object {
        val map: MutableMap<Int, Type> = HashMap()

        init {
            for (i in Type.values()) {
                map[i.value] = i
            } 
        }

        fun fromInt(type: Int?): Type? {
            return map[type]
        }
    }
}

Meine Frage ist, ist dies der beste Weg, oder gibt es einen besseren Weg? Was ist, wenn ich mehrere Aufzählungen habe, die einem ähnlichen Muster folgen? Gibt es in Kotlin eine Möglichkeit, diesen Code über Aufzählungen hinweg wiederverwendbarer zu machen?

Zuallererst sollte das Argument von fromInt()ein sein Int, nicht ein Int?. Der Versuch, eine Typeusing-Null zu erhalten, führt offensichtlich zu null, und ein Anrufer sollte dies nicht einmal versuchen. Das Maphat auch keinen Grund, veränderlich zu sein. Der Code kann reduziert werden auf:

companion object {
    private val map = Type.values().associateBy(Type::value)
    fun fromInt(type: Int) = map[type]
}

Dieser Code ist so kurz, dass ich ehrlich gesagt nicht sicher bin, ob es sich lohnt, eine wiederverwendbare Lösung zu finden.

Wir können verwenden, findwelches das erste Element zurückgibt, das mit dem angegebenen Prädikat übereinstimmt, oder null, wenn kein solches Element gefunden wurde.

companion object {
   fun valueOf(value: Int): Type? = Type.values().find { it.value == value }
}

In diesem Fall macht es nicht viel Sinn, aber hier ist eine "Logikextraktion" für die Lösung von @ JBNized:

open class EnumCompanion<T, V>(private val valueMap: Map<T, V>) {
    fun fromInt(type: T) = valueMap[type]
}

enum class TT(val x: Int) {
    A(10),
    B(20),
    C(30);

    companion object : EnumCompanion<Int, TT>(TT.values().associateBy(TT::x))
}

//sorry I had to rename things for sanity

Im Allgemeinen ist dies die Sache bei Begleitobjekten, die wiederverwendet werden können (im Gegensatz zu statischen Elementen in einer Java-Klasse).

Eine andere Option, die als "idiomatischer" angesehen werden könnte, wäre die folgende:

companion object {
    private val map = Type.values().associateBy(Type::value)
    operator fun get(value: Int) = map[value]
}

Welches kann dann wie verwendet werden Type[type].

Ich fand mich dabei wieder, die umgekehrte Suche durch benutzerdefinierte, handcodierte Werte einige Male durchzuführen, und fand den folgenden Ansatz.

Lassen Sie enums eine gemeinsame Schnittstelle implementieren:

interface Codified<out T : Serializable> {
    val code: T
}

enum class Alphabet(val value: Int) : Codified<Int> {
    A(1),
    B(2),
    C(3);

    override val code = value
}

Diese Schnittstelle (wie seltsam der Name auch sein mag :)) markiert einen bestimmten Wert als expliziten Code. Das Ziel ist es, schreiben zu können:

val a = Alphabet::class.decode(1) //Alphabet.A
val d = Alphabet::class.tryDecode(4) //null

Was mit dem folgenden Code leicht erreicht werden kann:

interface Codified<out T : Serializable> {
    val code: T

    object Enums {
        private val enumCodesByClass = ConcurrentHashMap<Class<*>, Map<Serializable, Enum<*>>>()

        inline fun <reified T, TCode : Serializable> decode(code: TCode): T where T : Codified<TCode>, T : Enum<*> {
            return decode(T::class.java, code)
        }

        fun <T, TCode : Serializable> decode(enumClass: Class<T>, code: TCode): T where T : Codified<TCode> {
            return tryDecode(enumClass, code) ?: throw IllegalArgumentException("No $enumClass value with code == $code")
        }

        inline fun <reified T, TCode : Serializable> tryDecode(code: TCode): T? where T : Codified<TCode> {
            return tryDecode(T::class.java, code)
        }

        @Suppress("UNCHECKED_CAST")
        fun <T, TCode : Serializable> tryDecode(enumClass: Class<T>, code: TCode): T? where T : Codified<TCode> {
            val valuesForEnumClass = enumCodesByClass.getOrPut(enumClass as Class<Enum<*>>, {
                enumClass.enumConstants.associateBy { (it as T).code }
            })

            return valuesForEnumClass[code] as T?
        }
    }
}

fun <T, TCode> KClass<T>.decode(code: TCode): T
        where T : Codified<TCode>, T : Enum<T>, TCode : Serializable 
        = Codified.Enums.decode(java, code)

fun <T, TCode> KClass<T>.tryDecode(code: TCode): T?
        where T : Codified<TCode>, T : Enum<T>, TCode : Serializable
        = Codified.Enums.tryDecode(java, code)

Eine Variante einiger früherer Vorschläge könnte die folgende sein, wobei Ordnungsfeld und getValue verwendet werden:

enum class Type {
A, B, C;

companion object {
    private val map = values().associateBy(Type::ordinal)

    fun fromInt(number: Int): Type {
        require(number in 0 until map.size) { "number out of bounds (must be positive or zero & inferior to map.size)." }
        return map.getValue(number)
    }
}

}}

Eine weitere Beispielimplementierung. Dies setzt auch den Standardwert (hier auf OPEN), wenn nein, die Eingabe stimmt mit keiner Aufzählungsoption überein:

enum class Status(val status: Int) {
OPEN(1),
CLOSED(2);

companion object {
    @JvmStatic
    fun fromInt(status: Int): Status =
        values().find { value -> value.status == status } ?: OPEN
}

}}

Hat eine allgemeinere Lösung gefunden

inline fun <reified T : Enum<*>> findEnumConstantFromProperty(predicate: (T) -> Boolean): T? =
T::class.java.enumConstants?.find(predicate)

Anwendungsbeispiel:

findEnumConstantFromProperty<Type> { it.value == 1 } // Equals Type.A

True Idiomatic Kotlin Way. Ohne aufgeblähten Reflexionscode:

interface Identifiable<T : Number> {

    val id: T
}

abstract class GettableById<T, R>(values: Array<R>) where T : Number, R : Enum<R>, R : Identifiable<T> {

    private val idToValue: Map<T, R> = values.associateBy { it.id }

    operator fun get(id: T): R = getById(id)

    fun getById(id: T): R = idToValue.getValue(id)
}

enum class DataType(override val id: Short): Identifiable<Short> {

    INT(1), FLOAT(2), STRING(3);

    companion object: GettableById<Short, DataType>(values())
}

fun main() {
    println(DataType.getById(1))
    // or
    println(DataType[2])
}

val t = Type.values ​​() [ordinal]

:) :)