Reputation: 6882
I have a generic method like below
private fun <T> getSomething(): T {
return "something" as T
}
How can I call this method with a variable T
type?
val types = arrayListOf<Type>(String::class.java, Boolean::class.java)
types.forEach { type ->
val something = getSomething<type>() // Unresolved reference: type
}
At runtime, I don't know what would be generic type T
. I am getting the type from types
and should pass it with generic getSomething
method.
I want to call database which has several table. Example models are like this
class User{
}
class Student{
}
Since all the calling queries are basically same, I want to have generic method for calling database and get data.
private fun <T> getData(model: String): List<T>?{
return when(model){
"user" -> getUsers()
"student" -> getStudents()
else -> null
}
}
So when I call above method. Within my loop I want to pass Type
as either User
or Student
.
val types = arrayListOf<Type>(User::class.java, Student::class.java)
types.forEach { type ->
val data = getData<type>(type.javaClass.simpleName) // Unresolved reference: type in <type>
}
How can I achieve it.
Upvotes: 62
Views: 100680
Reputation: 1387
If you want to restrict your types to something other than Any, you can create a parameterized DataType:
data class Datatype<T> {
companion object {
val USERS = Datatype<User>
val STUDENTS = Datatype<Student>
...
...
And send that to your generic function:
fun <T> getData(datatype: Datatype<T>): List<T>? {
return when(datatype) {
Datatype.USERS -> getUsers() as List<T>
Datatype.STUDENTS -> getStudents() as List<T>
else -> null
}
}
Upvotes: 0
Reputation: 344
I would stick to concrete types like
import kotlin.reflect.KClass
interface IBaseData
interface IDataTable<out T> where T : IBaseData
{
fun getData(): List<T>
}
class User : IBaseData
class Student : IBaseData
class UserTable : IDataTable<User>
{
override fun getData(): List<User>
{
return listOf(User())
}
}
class StudentTable : IDataTable<Student>
{
override fun getData(): List<Student>
{
return listOf(Student())
}
}
inline fun <reified T: IBaseData> getDataTable() : IDataTable<T>?
{
return when(T::class)
{
User::class -> UserTable() as IDataTable<T>
Student::class -> StudentTable() as IDataTable<T>
else -> null
}
}
fun main()
{
var user = getDataTable<User>()?.getData()
var student = getDataTable<Student>()?.getData()
}
But still, it's an overhead, why not to use getUser()
or getStudents()
directly
Upvotes: 3
Reputation: 692181
Here's a complete example:
import kotlin.reflect.KClass
data class User(val name: String)
data class Student(val name: String)
fun getUsers(): List<User> = listOf(User("JB"))
fun getStudents(): List<Student> = listOf(Student("Claire"))
fun <T: Any> getData(clazz: KClass<T>): List<T>? {
return when(clazz) {
User::class -> getUsers() as List<T>
Student::class -> getStudents() as List<T>
else -> null
}
}
fun main(args: Array<String>) {
val types = listOf(User::class, Student::class)
types.forEach { type ->
val data = getData(type)
println(data)
}
}
Upvotes: 74