Kotlin - Impossible d'utiliser 'T' comme paramètre de type réifié. Utilisez une classe à la place

Question

J'ai une simple fonction d'aide pour obtenir la valeur de SharedPreferences comme ceci:

operator inline fun <reified T : Any> SharedPreferences.get(key: String, defaultValue: T? = null): T? { 
    return when (T::class) { 
     String::class -> getString(key, defaultValue as? String) as T? 
     Int::class -> getInt(key, defaultValue as? Int ?: -1) as T? 
     Boolean::class -> getBoolean(key, defaultValue as? Boolean ?: false) as T? 
     Float::class -> getFloat(key, defaultValue as? Float ?: -1f) as T? 
     Long::class -> getLong(key, defaultValue as? Long ?: -1) as T? 
     else -> throw UnsupportedOperationException("Not yet implemented") 
    } 
} 

J'ai utilisé paramètre de type réifiée d'avoir commutation type de classe et comme il est une fonction de l'opérateur, je devrais être capable d'appeler avec la syntaxe carrée de crochets comme ci-dessous:

val name: String? = prefs[Constants.PREF_NAME] 

Mais, chaque fois que je l'appelle, est fonction UnsupportedOperationException indiquant ne peut pas propulsée vers d'obtenir le type de classe.

Quand j'attache débogueur et d'évaluer T::class, il me donne une erreur "Cannot use 'T' as reified type parameter. Use a class instead."

Quel est le problème avec ma fonction? Je ne pouvais pas attraper l'erreur. quelqu'un peut-il aider?

Éditer: Toute la classe est here et this is where Je reçois l'erreur.

Mise à jour: Il semble s'agir d'un problème de compilation Kotlin. Piste https://youtrack.jetbrains.com/issue/KT-17748 et https://youtrack.jetbrains.com/issue/KT-17748 pour les mises à jour.

Answer 1

Le problème est curieux, mais il semble que Int::class n'est pas la même chose que Int?::class (ce qui est une expression illégale de toute façon).

Lorsque vous ajoutez la ligne:

println(T::class) 

Pour la méthode get et appelez val age: Int? = prefs["AGE", 23], vous verrez qu'il imprime java.lang.Integer. Il semble que Int? est traduit en java.lang.Integer.

Un possible (mais IMHO type de aki) solution est d'utiliser les références à des classes Java comme les cas lorsque:

operator inline fun <reified T : Any> get(key: String, defaultValue: T? = null): T? { 
    return when (T::class) { 
     String::class -> getString(key, defaultValue as? String) as T? 
     java.lang.Integer::class -> getInt(key, defaultValue as? Int ?: -1) as T? 
     java.lang.Boolean::class -> getBoolean(key, defaultValue as? Boolean ?: false) as T? 
     java.lang.Float::class -> getFloat(key, defaultValue as? Float ?: -1f) as T? 
     java.lang.Long::class -> getLong(key, defaultValue as? Long ?: -1) as T? 
     else -> throw UnsupportedOperationException("Not yet implemented") 
    } 
}