Skuteczne wyliczenia w Kotlin z odwrotnym wyszukiwaniem?

Próbuję znaleźć najlepszy sposób na „wyszukiwanie wsteczne” wyliczenia w Kotlinie. Jednym z moich wniosków z Effective Java było wprowadzenie statycznej mapy do wyliczenia w celu obsługi wyszukiwania wstecznego. Przeniesienie tego do Kotlina za pomocą prostego wyliczenia prowadzi mnie do kodu, który wygląda następująco:

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

Moje pytanie brzmi: czy to najlepszy sposób, czy jest lepszy sposób? A co, jeśli mam kilka wyliczeń, które mają podobny wzór? Czy w Kotlinie jest sposób, aby ten kod był bardziej nadający się do ponownego wykorzystania w wyliczeniach?

Przede wszystkim argument fromInt()powinien być an Int, a nie Int?. Próba uzyskania Typeusing null oczywiście prowadzi do null, a dzwoniący nie powinien nawet próbować tego robić. Nie Mapma również powodu, aby być zmiennym. Kod można zredukować do:

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

Ten kod jest tak krótki, że, szczerze mówiąc, nie jestem pewien, czy warto szukać rozwiązania wielokrotnego użytku.

możemy użyć findwhich Zwraca pierwszy element pasujący do danego predykatu lub null, jeśli takiego elementu nie znaleziono.

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

W tym przypadku nie ma to większego sensu, ale oto „wyodrębnianie logiki” dla rozwiązania @ 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

Ogólnie rzecz biorąc, chodzi o obiekty towarzyszące, które można ponownie wykorzystać (w przeciwieństwie do statycznych elementów członkowskich w klasie Java)

Inna opcja, którą można by uznać za bardziej „idiomatyczną”, byłaby następująca:

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

Które można następnie wykorzystać jak Type[type].

Znalazłem się kilka razy, wykonując wyszukiwanie wsteczne przez niestandardowe, ręcznie kodowane, wartości i wymyśliłem następujące podejście.

Make enums implementuje wspólny interfejs:

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
}

Ten interfejs (jakkolwiek dziwna nazwa to :)) oznacza określoną wartość jako jawny kod. Celem jest umiejętność pisania:

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

Co można łatwo osiągnąć za pomocą następującego kodu:

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)

Wariantem niektórych poprzednich propozycji może być następujący, wykorzystujący pole porządkowe i 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)
    }
}

}

Kolejna przykładowa realizacja. Spowoduje to również ustawienie wartości domyślnej (tutaj na OPEN), jeśli żadne dane wejściowe nie pasują do żadnej opcji wyliczenia:

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
}

}

Pojawił się z bardziej ogólnym rozwiązaniem

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

Przykładowe użycie:

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

True Idiomatic Kotlin Way. Bez nadętego kodu odbicia:

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

Nieco rozszerzone podejście do przyjętego rozwiązania z funkcją sprawdzania wartości null i wywołania

fun main(args: Array<String>) {
    val a = Type.A // find by name
    val anotherA = Type.valueOf("A") // find by name with Enums default valueOf
    val aLikeAClass = Type(3) // find by value using invoke - looks like object creation

    val againA = Type.of(3) // find by value
    val notPossible = Type.of(6) // can result in null
    val notPossibleButThrowsError = Type.ofNullSave(6) // can result in IllegalArgumentException

    // prints: A, A, 0, 3
    println("$a, ${a.name}, ${a.ordinal}, ${a.value}")
    // prints: A, A, A null, java.lang.IllegalArgumentException: No enum constant Type with value 6
    println("$anotherA, $againA, $aLikeAClass $notPossible, $notPossibleButThrowsError")
}

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

    companion object {
        private val map = values().associateBy(Type::value)
        operator fun invoke(type: Int) = ofNullSave(type)
        fun of(type: Int) = map[type]
        fun ofNullSave(type: Int) = map[type] ?: IllegalArgumentException("No enum constant Type with value $type")
    }
}

val t = Type.values ​​() [porządkowa]

:)