Hi guys, I have some condition inside method and I...

# codereview

[KotlinLeaner]

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,
)

[Sebastian Heil]

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,
)

[KotlinLeaner]

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 ?

[KotlinLeaner]

I think it's better to send my whole logic in here..

[KotlinLeaner]

class Abc {

    val list by lazy {
        mutableListOf(
            getFirstItem(),
            getSecondItem(),
            getThirdItem(),
            getFourthItem(),
            getFifthItem(),
            getSixthItem()
        )
    }

    private fun getFirstItem(): Item {
        return Item("Low") { itemOne, itemTwo ->
            (itemOne < 90 && itemTwo < 60)
        }
    }

    private fun getSecondItem(): Item {
        return Item("Normal") { itemOne, itemTwo ->
            (itemOne in 90..119 && itemTwo in 60..80)
        }
    }

    private fun getThirdItem(): Item {
        return Item("Elevated") { itemOne, itemTwo ->
            (itemOne in 120..129 && itemTwo < 80)
        }
    }

    private fun getFourthItem(): Item {
        return Item("High") { itemOne, itemTwo ->
            (itemOne in 130..139 || itemTwo in 80..89)
        }
    }

    private fun getFifthItem(): Item {
        return Item("Very high") { itemOne, itemTwo ->
            (itemOne in 140..179 || itemTwo in 90..119)
        }
    }

    private fun getSixthItem(): Item {
        return Item("Extremely High") { itemOne, itemTwo ->
            (itemOne >= 180 || itemTwo >= 120)
        }
    }

    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,
)

[Sebastian Heil]

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.

[KotlinLeaner]

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