Início / coding / Perguntas / 79290494
Accepted
William Hu
Asked: 2024-12-18 16:50:50 +0800 CST

Use o tipo genérico para obter o tipo associado em enum pelo valor bruto

  • 772

Esta é uma classe Enum:

enum class Foo(rawValue: Int) {
    FIRST(1),
    SECOND(2)
}

Posso usar companion objectpara recuperar o tipo pelo valor bruto:

enum class Foo(rawValue: Int) {
    FIRST(1),
    SECOND(2)


   companion object {
    
      fun getCaseBy(value: Int): Foo? {
        return entries.firstOrNull { it.rawValue == value }
      }
   }
}

Então use assim: Foo.getCaseBy(1)

Existe alguma maneira de usar um tipo genérico para colocar isso getCaseByem interface? Então não há necessidade de adicionar esse método para cada enum?

Algo como:

interface EnumInterface<T> {
    
    companion object {
        
        fun getCaseBy(value: E): T? {
            return T.entries.firstOrNull { it.rawValue == value }
        }
    }
}

enum class Foo(rawValue: Int): EnumInterface(Foo::class) {
    FIRST(1),
    SECOND(2)
}
  1. Té restrito à Enumclasse, Eé To tipo rawValue de retrieve.
  2. Somente Enumo tipo pode confirmar esta interfaceEnumInterface

Isso é possível?

kotlin

1 respostas

  1. Best Answer

    Esta é uma implementação mais limpa inspirada no comentário de Louis Wasserman .

    import kotlin.reflect.KClass

abstract class EnumGetter<E : Enum<E>, V>(private val enumClass: KClass<E>) {

  abstract fun predicate(e: E, value: V): Boolean;

  fun getEnum(value: V): E? {
    return enumClass.java.enumConstants.firstOrNull { predicate(it, value) }
  }
}

enum class Foo(val rawValue: Int) {
  FIRST(1),
  SECOND(2);

  companion object : EnumGetter<Foo, Int>(Foo::class) {

    override fun predicate(e: Foo, value: Int): Boolean {
      return e.rawValue == value
    }
  }
}

fun main() {
  println(Foo.getEnum(1))
  println(Foo.getEnum(2))
  println(Foo.getEnum(3))
}

    Se você acha que substituir predicatea função é muito problemático, você pode aplicar o mesmo método da versão antiga abaixo para criar uma anotação para o campo-chave.

    Esta é a versão antiga .

    Você pode implementar isso por meio da reflexão.

    import kotlin.reflect.full.hasAnnotation
import kotlin.reflect.full.memberProperties

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Key

inline fun <reified E : Enum<E>> getValue(enumObject: E): Any? {
  val field = E::class.memberProperties.first { it.hasAnnotation<Key>() }
  return field.get(enumObject)
}

inline fun <reified E : Enum<E>> getValueBy(value: Any?): E {
  return enumValues<E>().first { getValue<E>(it) == value }
}

enum class Foo(@Key val rawValue: Int) {
  FIRST(1),
  SECOND(2);
}

fun main() {
  println(getValueBy<Foo>(2));
}

    Como a classe enum pode ter vários nomes de propriedade, a anotação Keyé usada para marcar a propriedade usada para comparação.

    Observe que se nenhuma propriedade for anotada, getValueserá gerado um NoSuchElementerro.

    • 0

relate perguntas