Hi guys, I have some condition inside method and I want to find the type in different function, so how can we improve this piece of code? Thanks

class Abc {

    val list by lazy {
        mutableListOf(
           getFirstItem(),
           getSecondItem(),
           getThirdItem(),
          // more function in here
         )
    }

    fun getFirstItem(): Item {
        return Item("Hello") { itemOne, itemTwo ->
            (itemOne < 10 && itemTwo < 20)
        }
    }
   // fun getSecondItem()
   // fun getThirdItem()
   // more this type of method which is checking condition in here.

    fun getItem(itemOne: Int, itemTwo: Int): Item {
        for (item in list) {
            if (item.condition(itemOne, itemTwo)) {
                return item
            }
        }
        return Item("Hello") { valueOne, valueTwo ->
            (valueOne < 10 && valueTwo < 20)
        }
    }
}

data class Item(
    val itemName: String,
    val condition: (Int, Int) -> Boolean,
)

For me it would look better if the factory method

getItem

checks the condition instead of the

Item

class. Could you move the condition check out of the

Item

? Would e.g. having an

IntRange

instead of the

condition: (Int,Int) -> Boolean

work for you?

class Abc {

    val list by lazy {
        listOf(
            Item("Hello", 10 until 20),
            Item("Hello2", 20 until 30),
            //...
        )
    }

    fun getItem(itemOne: Int, itemTwo: Int): Item {
        return list.firstOrNull { itemOne in it.range && itemTwo in it.range }
            ?: Item("Hello", 10 until 20)
    }
}

data class Item(
    val itemName: String,
    val range: IntRange,
)

Thanks for great advice, I think I have to add my all condition as well. Sorry previous I didn't think that condition will be necessary in above code snippets. I think your above code works in my

1st

and

2nd

condition very well. So what about this below conditions?

fun getThirdItem(): Item {
    return Item("Hello") { itemOne, itemTwo ->
        (itemOne in 10..19 && itemTwo in 15..20)
    }
}

fun getFourthItem(): Item {
    return Item("Hello") { itemOne, itemTwo ->
        (itemOne in 20..29 || itemTwo < 20)
    }
}

fun getFifthItem(): Item {
    return Item("Hello") { itemOne, itemTwo ->
        (itemOne > 30 || itemTwo > 20)
    }
}

So this 3 condition fits in

IntRange

?

Maybe this could work for you?

fun getItem(itemOne: Int, itemTwo: Int): String = when {
        itemOne in 0..90 && itemTwo in 0..60 -> "Low"
        itemOne in 90..119 && itemTwo in 60..80 -> "Normal"
        itemOne in 120..129 || itemTwo < 80 -> "Elevated"
        itemOne in 130..139 || itemTwo in 80..89 -> "High"
        itemOne in 140..179 || itemTwo in 90..119 -> "Very High"
        else -> "Extremely High"
    }

You could also make those “Low”, “Normal”, … an enum:

fun getItem(itemOne: Int, itemTwo: Int): String = when {
        itemOne in 0..90 && itemTwo in 0..60 -> Level.LOW
        itemOne in 90..119 && itemTwo in 60..80-> Level.NORMAL
        itemOne in 120..129 || itemTwo < 80 -> Level.ELEVATED
        itemOne in 130..139 || itemTwo in 80..89-> Level.HIGH
        itemOne in 140..179 || itemTwo in 90..119-> Level.VERY_HIGH
        else -> Level.EXTREMELY_HIGH
    }

enum class Level { LOW, NORMAL, ELEVATED, HIGH, VERY_HIGH, EXTREMELY_HIGH }

And btw enums are comparable, so you could also convert each item individually to an

Level

enum and then compare them for e.g. finding the maximum.

It's really work for me. Thanks it works..