What I actually want is to have the flexibility to...

# announcements

[Paul Woitaschek]

What I actually want is to have the flexibility to use these as extension functions so my implementing classes can just call .toBundle()

[lovis]

paulwoitaschek: if the class has to implement it anyway, why do you need it to be an extension function?

[Paul Woitaschek]

The class can't implement it as fromBundle is creating instances so it's kind of static

[lovis]

ah sorry. of course 🙈

[Paul Woitaschek]

What I need acutally is some kind of a static interface

[Paul Woitaschek]

I could split the interface and let the class implement bundler and the companion object unbundler

[Paul Woitaschek]

But that's still inconvenient as I now have this implicit contract

[lovis]

something like this?

fun <T,R: Bundler> T.fromBundle(b: Bundle) : R {
    return UnBundler().fromBundle(b) //will throw if not possible
}

val thing: Thing = fromBundle(extras)

[lovis]

ah this doesn’t really work because generics. 😞 could imagine that it works with reified though

[lovis]

ok this works:

abstract class UnBundler(val canHandle: KClass<*>) {

    companion object {
        val unbundlers: MutableList<UnBundler> = arrayListOf()

        inline fun <reified R> unBundle(b: Bundle): R {
            val unbundler = unbundlers.find { it.canHandleClass(R::class) }

            if (unbundler == null)
                throw UnBundlerNotRegistered()

            return unbundler.unbundle(b) as R

        }
    }

    fun canHandleClass(kClass: KClass<*>): Boolean {
        return kClass == canHandle
    }

    abstract fun unbundle(b: Bundle): Any

}

...

inline fun <reified R: Bundler> Any.fromBundle(b: Bundle) : R {
    return UnBundler.unBundle<R>(b)
}

Of course, just as you said, you have to manage two classes. Register a new UnBundler for each new class that implements Bundler