Inheritance & Interfaces

open class Notifier(val channel: String) {
    open fun format(msg: String) = "[$channel] $msg"
    fun send(msg: String) = println(format(msg))   // final: not overridable
}

class UrgentNotifier : Notifier("pager") {
    override fun format(msg: String) = super.format(msg.uppercase()) + " !!!"
}

fun main() {
    Notifier("email").send("build passed")
    UrgentNotifier().send("disk full")
}

open class Base {
    init { println("Base sees: ${describe()}") }
    open fun describe() = "base"
}

class Child : Base() {
    private val name: String = "child"
    override fun describe() = "name=$name"
}

fun main() {
    val c = Child()
    println("After construction: ${c.describe()}")
}

abstract class Report(val title: String) {
    abstract fun rows(): List<String>
    open fun footer() = "-- end --"

    fun render(): String = buildString {       // template method
        appendLine("== $title ==")
        rows().forEachIndexed { i, r -> appendLine("${i + 1}. $r") }
        append(footer())
    }
}

class SalesReport(private val sales: Map<String, Int>) : Report("Sales") {
    override fun rows() = sales.map { (who, amt) -> "$who: $amt" }
    override fun footer() = "total ${sales.values.sum()}"
}

fun main() {
    println(SalesReport(mapOf("north" to 120, "south" to 80)).render())
}

interface Identifiable {
    val id: String                          // abstract: implementer provides it
    val shortId: String get() = id.take(4)  // computed from id
}

interface Auditable {
    fun describe(): String
    fun audit() = println("audit: ${describe()}")   // default method
}

class Invoice(override val id: String, val amount: Int) : Identifiable, Auditable {
    override fun describe() = "invoice $shortId for $amount"
}

fun main() {
    val inv = Invoice("INV-20931", 499)
    inv.audit()
    val things: List<Identifiable> = listOf(inv, object : Identifiable { override val id = "TMP-1" })
    println(things.map { it.shortId })
}

interface Printer {
    fun hello() = "Printer"
    fun print(doc: String) = "printing $doc"
}
interface Scanner {
    fun hello() = "Scanner"
    fun scan() = "scanning"
}

class Copier : Printer, Scanner {
    override fun hello() = super<Printer>.hello() + "+" + super<Scanner>.hello()
    fun copy(doc: String) = "${scan()} then ${print(doc)}"
}

fun main() {
    val c = Copier()
    println(c.hello())
    println(c.copy("contract.pdf"))
    val p: Printer = c
    println(p.hello())       // still the Copier override
}

open class Employee(val name: String) {
    open fun pay(): Int = 1000
    fun payslip() = "$name: ${pay()}"
}

class Manager(name: String, private val reports: Int) : Employee(name) {
    override fun pay() = super.pay() + reports * 200
}

class Contractor(name: String, private val hours: Int) : Employee(name) {
    override fun pay() = hours * 50
}

fun main() {
    val staff: List<Employee> = listOf(
        Employee("Ada"), Manager("Linus", 3), Contractor("Grace", 10),
    )
    staff.forEach { println(it.payslip()) }
    println(staff.sumOf { it.pay() })
}

open class Animal(val name: String)
class Dog(name: String) : Animal(name) { fun fetch() = "$name fetches" }
class Cat(name: String) : Animal(name) { fun purr() = "$name purrs" }

fun act(a: Animal): String = when (a) {
    is Dog -> a.fetch()          // smart cast to Dog
    is Cat -> a.purr()           // smart cast to Cat
    else -> "${a.name} idles"
}

fun main() {
    val zoo = listOf(Dog("Rex"), Cat("Tom"), Animal("Generic"))
    zoo.forEach { println(act(it)) }

    val maybeDog = zoo[1] as? Dog
    println(maybeDog?.fetch() ?: "not a dog")
    println(zoo.filterIsInstance<Cat>().map { it.name })
}

class CountingSet<T>(
    private val inner: MutableSet<T> = mutableSetOf(),
) : MutableSet<T> by inner {
    var attempts = 0
        private set

    override fun add(element: T): Boolean {
        attempts++
        return inner.add(element)
    }

    override fun addAll(elements: Collection<T>): Boolean {
        attempts += elements.size
        return inner.addAll(elements)
    }

    override fun toString() = inner.toString()
}

fun main() {
    val s = CountingSet<String>()
    s.add("a")
    s.addAll(listOf("a", "b", "c"))
    println("${s.attempts} attempts, ${s.size} stored: $s")
    println("b" in s)            // contains() is forwarded untouched
}

import kotlin.properties.Delegates
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

class Trimmed : ReadWriteProperty<Any?, String> {
    private var value = ""
    override fun getValue(thisRef: Any?, property: KProperty<*>) = value
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("setting ${property.name}")
        this.value = value.trim()
    }
}

class Profile {
    var displayName: String by Trimmed()
    var age: Int by Delegates.vetoable(0) { _, _, new -> new in 0..150 }
    val slug: String by lazy { displayName.lowercase().replace(' ', '-') }
}

fun main() {
    val p = Profile()
    p.displayName = "   Ada Lovelace  "
    p.age = 36
    p.age = -4                    // vetoed: keeps 36
    println("[${p.displayName}] ${p.age} ${p.slug}")
}