Kotlin utility for condition-based data selection with dynamic condition supports

Constraint.kt

interface Constraint<INPUT, OUTPUT> {
    suspend fun invoke(input: INPUT): OUTPUT?
}

abstract class SatisfyConstraint<INPUT, OUTPUT> : Constraint<INPUT, OUTPUT> {
    abstract suspend fun isSatisfied(input: INPUT): Boolean

    abstract suspend fun process(input: INPUT): OUTPUT

    override suspend fun invoke(input: INPUT): OUTPUT? =
        if (isSatisfied(input)) process(input)
        else null
}

interface DefaultConstraint<INPUT, OUTPUT> {
    suspend fun invoke(input: INPUT): OUTPUT
}

ConstraintedSelector.kt

open class ConstraintedSelector<INPUT, OUTPUT> {
    private val constraints: MutableList<Constraint<INPUT, OUTPUT>> = mutableListOf()

    suspend fun get(input: INPUT): OUTPUT? {
        constraints.forEach {
            val output = it.invoke(input)
            if (output != null) return output
        }
        return null
    }

    fun addConstraint(constraint: Constraint<INPUT, OUTPUT>) = this.apply {
        constraints.add(constraint)
    }

    fun addConstraints(constraint: List<Constraint<INPUT, OUTPUT>>) = this.apply {
        constraints.addAll(constraint)
    }

    fun addConstraints(vararg constraint: Constraint<INPUT, OUTPUT>) = this.apply {
        constraints.addAll(constraint)
    }

    fun withDefault(default: DefaultConstraint<INPUT, OUTPUT>) = DefaultConstraintedSelector(default).apply {
        [email protected](constraints)
    }
}

open class DefaultConstraintedSelector<INPUT, OUTPUT>(
    private val defaultConstraint: DefaultConstraint<INPUT, OUTPUT>
) {
    private val constraints: MutableList<Constraint<INPUT, OUTPUT>> = mutableListOf()

    suspend fun get(input: INPUT): OUTPUT {
        constraints.forEach {
            val output = it.invoke(input)
            if (output != null) return output
        }
        return defaultConstraint.invoke(input)
    }
}

Basic sample

class NumberConstraintedSelector : ConstraintedSelector<Int, String>()

class DivisibleByThreeConstraint : Constraint<Int, String> {
    override suspend fun invoke(input: Int): String? =
        if (input % 3 == 0) "Divisible by three" else null
}

class DivisibleByFiveConstraint : Constraint<Int, String> {
    override suspend fun invoke(input: Int): String? =
        if (input % 5 == 0) "Divisible by five" else null
}

class OutOfRangeConstraint : DefaultConstraint<Int, String> {
    override suspend fun invoke(input: Int): String = "Out of range"
}

// Usage
val selector = NumberConstraintedSelector().apply {
    addConstraint(DivisibleByThreeConstraint())
    addConstraint(DivisibleByFiveConstraint())
}.withDefault(OutOfRangeConstraint())

val result: Int = selector.get(Random.nextInt(100))
/*
 * 0 => "Out of range"
 * 3 => "Divisible by three"
 * 5 => "Divisible by five"
 * 15 => "Divisible by three"
 * 29 => "Out of range"
 * 30 => "Divisible by five"
 */ 

More sample

data class Place(val name: String, val location: LatLng)

data class LatLng(val latitude: Double, val longitude: Double)

class LocationConstrainedSelector : ConstraintedSelector<LatLng, Place>()

class LocationProvider {
    fun getPreviousLocation(): Place? { /* ... */ }
}

class PreviousLocationConstraint(private val provider: LocationProvider) : Constraint<LatLng, Place> {
    override suspend fun invoke(input: LatLng): Place? {
        return provider.getPreviousLocation()
    }
}

class PoiProvider {
    fun isInAnyPoiArea(input: LatLng): Boolean = /* ... */

    fun getClosestPoi(reference: LatLng): Place = /* ... */
}

class PoiConstraint(private val provider: PoiProvider) : SatisfyConstraint<LatLng, Place>() {
    override suspend fun isSatisfied(input: LatLng): Boolean {
        return provider.isInAnyPoiArea(input)
    }

    override suspend fun process(input: LatLng): Place {
        return provider.getClosestPoi(input)
    }
}

class DefaultLocationConstraint : DefaultConstraint<LatLng, Place> {
    override suspend fun invoke(input: LatLng) =
        Place(name = "Default", location = input)
}

// Usage
val selector = LocationConstrainedSelector().apply {
    val locationProvider = LocationProvider()
    addConstraint(PreviousLocationConstraint(locationProvider))

    val poiProvider = PoiProvider()
    addConstraint(PoiConstraint(poiProvider))
}.withDefault(DefaultLocationConstraint())

val currentLocation = LatLng(13.7465172, 100.5355243)
val result: Place = selector.get(currentLocation)
// name = "Siam Paragon"
// location = LatLng(13.7462515, 100.5347943)