I have an enum with some instances Foo and Bar. If I have a string "Foo", how can I instantiate a Foo enum from that? In C# it would be Enum.Parse(...), is there an equivalent in Kotlin?
Currently, the best I have found is to create a factory that switches on all possible strings, but that is error prone and performs poorly for large enumerations.
Kotlin enum classes have "static" function valueOf to get enum entry by string(like Java enums). Additionally they have "static" function values to get all enum entries. Example:
enum class MyEnum {
Foo, Bar, Baz
}
fun main(args : Array<String>) {
println(MyEnum.valueOf("Foo") == MyEnum.Foo)
println(MyEnum.valueOf("Bar") == MyEnum.Bar)
println(MyEnum.values().toList())
}
valueOfIgnoringCase method is, they just use valueOf like normal
As bashor suggested, use MyEnum.valueOf() but please have in mind that it throws an exception if value can't be found. I recommend using:
enum class MyEnum {
Foo, Bar, Baz
}
try {
myVar = MyEnum.valueOf("Qux")
} catch(e: IllegalArgumentException) {
Log.d(TAG, "INVALID MyEnum value: 'Qux' | $e")
}
Would do it like
enum class MyEnum {
Foo, Bar, Baz
}
val value = MyEnum.values().firstOrNull {it.name == "Foo"} // results to MyEnum.Foo
The default solution in Kotlin will throw an exception. If you want a reliable solution that works statically for all enums, try this!
Now just call valueOf<MyEnum>("value"). If the type is invalid, you'll get null and have to handle it, instead of an exception.
inline fun <reified T : Enum<T>> valueOf(type: String): T? {
return try {
java.lang.Enum.valueOf(T::class.java, type)
} catch (e: Exception) {
null
}
}
Alternatively, you can set a default value, calling valueOf<MyEnum>("value", MyEnum.FALLBACK), and avoid a null response. You can extend your specific enum to have the default be automatic
inline fun <reified T : Enum<T>> valueOf(type: String, default: T): T {
return try {
java.lang.Enum.valueOf(T::class.java, type)
} catch (e: Exception) {
default
}
}
Or if you want both, make the second:
inline fun <reified T : Enum<T>> valueOf(type: String, default: T): T = valueOf<T>(type) ?: default
If you want to create an enum constant from one of its properties, instead of the name, this funny code does a pretty decent job:
import kotlin.enums.enumEntries
import kotlin.reflect.KProperty1
@OptIn(ExperimentalStdlibApi::class)
inline fun <reified T : Enum<T>, V> KProperty1<T, V>.findOrNull(value: V): T? =
enumEntries<T>().firstOrNull { this(it) == value }
inline fun <reified T : Enum<T>, V> KProperty1<T, V>.find(value: V): T =
findOrNull(value) ?: throw IllegalArgumentException(
"Could not find enum constant with property `$name` of value `$value`"
)
These can be used like this:
enum class Algorithms(val string: String) {
Sha1("SHA-1"),
Sha256("SHA-256"),
}
fun main() {
// This will print `Sha256`
println(Algorithms::string.findOrNull("SHA-256"))
// This will crash with:
// IllegalArgumentException: Could not find enum constant with property `string` of value `SHA-420`
Algorithms::string.find("SHA-420")
}
If not using Kotlin 1.9.20 or beyond, replace enumEntries with the less efficient enumValues. This also does not require opting into experimental APIs.
Note also that string interpolation consumes resources and may lead to bugs, so depending on your use case you may want to create a custom parametrized exception, or just not include the details when constructing the IllegalArgumentException.
I think the best solution is enumValueOf<T>(String):
enum class MyEnum { Foo, Bar }
@Test
fun test() {
assertEquals(MyEnum.Foo, enumValueOf<MyEnum>("Foo"))
}
You can create this kind of enum class which will take a string and convert it to enum type
enum class EmployeeType(val value: String) {
Contractor("CONTRACTOR"),
FullTime("FULL_TIME"),
PartTime("PART_TIME");
companion object {
public fun fromValue(value: String): EmployeeType = when (value) {
"CONTRACTOR" -> Contractor
"FULL_TIME" -> FullTime
"PART_TIME" -> PartTime
else -> throw IllegalArgumentException()
}
}
}
you can use parameter like : val rgb: Int
for example :
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
so that for Int and you can use String for all items like bellow :
enum class NoteStatus(val value: String) {
PENDING("PENDING"),
PLANNING("PLANNING"),
USED("USED")
}
and you can use like this :
data class MoneyNoteData (
val name: String,
val value: Int,
val status: NoteStatus = NoteStatus.USED
)
