Enum efficaci in Kotlin con ricerca inversa?

Sto cercando di trovare il modo migliore per eseguire una "ricerca inversa" su un enum in Kotlin. Uno dei miei suggerimenti da Effective Java è stato l'introduzione di una mappa statica all'interno dell'enum per gestire la ricerca inversa. Portare questo su Kotlin con una semplice enumerazione mi porta a un codice simile a questo:

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]
        }
    }
}

La mia domanda è: è questo il modo migliore per farlo, o c'è un modo migliore? Cosa succede se ho più enumerazioni che seguono uno schema simile? C'è un modo in Kotlin per rendere questo codice più riutilizzabile tra le enumerazioni?

Prima di tutto, l'argomento di fromInt()dovrebbe essere an Int, non an Int?. Il tentativo di ottenere un valore Typenull porterà ovviamente a null e un chiamante non dovrebbe nemmeno provare a farlo. L' Mapha anche ragione di essere mutevole. Il codice può essere ridotto a:

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

Quel codice è così breve che, francamente, non sono sicuro che valga la pena provare a trovare una soluzione riutilizzabile.

possiamo usare findwhich Restituisce il primo elemento che corrisponde al predicato dato, o null se non è stato trovato alcun elemento di questo tipo.

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

Non ha molto senso in questo caso, ma ecco una "estrazione logica" per la soluzione di @ 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

In generale è questo il problema degli oggetti companion che possono essere riutilizzati (a differenza dei membri statici in una classe Java)

Un'altra opzione, che potrebbe essere considerata più "idiomatica", sarebbe la seguente:

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

Che può quindi essere utilizzato come Type[type].

Mi sono ritrovato a fare la ricerca inversa per un paio di volte personalizzato, codificato a mano, valore e ho trovato il seguente approccio.

Fai enumimplementare un'interfaccia condivisa:

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
}

Questa interfaccia (per quanto strano sia il nome :)) contrassegna un certo valore come codice esplicito. L'obiettivo è riuscire a scrivere:

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

Che può essere facilmente ottenuto con il seguente codice:

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)

Una variante di alcune proposte precedenti potrebbe essere la seguente, utilizzando il campo ordinale e getValue:

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)
    }
}

}

Un altro esempio di implementazione. Questo imposta anche il valore predefinito (qui a OPEN) se l'input non corrisponde a nessuna opzione enum:

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
}

}

È venuto con una soluzione più generica

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

Utilizzo di esempio:

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

True Idiomatic Kotlin Way. Senza codice di riflessione gonfio:

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]

:)