What I actually want is to have the flexibility to use these kotlinlang #announcements

Paul Woitaschek

05/08/2017, 9:22 AM

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

05/08/2017, 9:26 AM

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

Paul Woitaschek

05/08/2017, 9:27 AM

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

05/08/2017, 9:29 AM

ah sorry. of course 🙈

Paul Woitaschek

05/08/2017, 9:30 AM

What I need acutally is some kind of a static interface

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

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

05/08/2017, 9:35 AM

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)

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

reified

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