How to do reverse lookup enum constant by value in Kotlin
Tags: kotlin, programming, toolsandtricks, advice
Published: 2019-12-11 17:11:39

---
title: How to do reverse lookup enum constant by value in Kotlin
published: true
date: 2019-12-11 17:04:57 UTC
canonical_url: https://automationhacks.io/2019/12/11/how-to-do-reverse-lookup-enum-constant-by-value-in-kotlin/
---

This is a neat trick I discovered recently

[enums](https://kotlinlang.org/docs/reference/enum-classes.html) are a very useful concept in programming and allow us to define constant values which can easily hold grouped data and even declare members

I use them heavily in my automation code to define constant values and they work very well when we have the define different branches in `when` clause in kotlin to maybe perform different sort of actions

## A common use case

One common use case for me is when I want to do **enum constant lookup using its value**. For example, I might declare different configurations for my tests and based on these values, I might want to take different actions, trigger some flows or perform some assertions

Let’s understand this with an example

{% gist https://gist.github.com/gaurav-singh/7d7c10f16e207006786dc43cd5d4f3c0 %}

In the above example, we have defined an enum class called `Mouses`which has all different mouses and a short brand name for each.

If we want to get the **enum constant** value which has the **value = “logi” ** then we can write a simple `foreach` loop in kotlin to iterate over all the values and if the desired value is found (Ln 17 – 21) then assign it to the temporary enum variable (Ln 15)

Fair and simple enough right.

However, we would have to write this simple logic again and again for all the different enum constants that we declare.

## A slightly better way using companion objects

The above code gets the job done, however, this could be written in a slightly more elegant way.

Below is the updated code

{% gist https://gist.github.com/gaurav-singh/60259d002899666c563bd066de609c48 %}

Let’s understand this:

Ln 10 – 13, we have declared a `companion object` block to tie a member and a function to the enum class itself rather than its instance

Ln 11: We have a private immutable variable called `mapping` which has the mapping of all the enum constants with their values. This is done by using `associateBy()` which is called upon the `values()` array

if we peek into the code for this function, we can see that it returns a `Map<K, T>`, where K is the value of the enum constant and T is the actual constant itself

![Screenshot 2019-12-11 at 10.33.57 PM.png](https://automationhacksblog.files.wordpress.com/2019/12/screenshot-2019-12-11-at-10.33.57-pm.png?w=1100)

Finally, we have a `fromValue()` method which accepts the enum constant value and returns the associated constant from the mapping variable. If for some reason the value does not match an existing constant, then we raise an exception **like below (Ln 19)** with the name of the class

```
java.lang.IllegalStateException: Look up failed for class experiments.MousesV1
```

Now we can easily call this `fromValue` method on the enum constant and get the associated constant (Ln 18)

And that’s it. This has already made my code look much more concise and made it easier for me to use enums. Hopefully, you found this useful.

Until next time. Happy coding.