adam-arold

interface EventBus {

   fun <T : Event> subscribe(klass: KClass<T>,
                             callback: (T) -> Unit)

}

adam-arold

class EventBus {

   private val subscriptions = 
     mutableMapOf<KClass<out Any>, (Any) -> Unit>()

   inline fun <reified T : Event> subscribe(
       noinline callback: (T) -> Unit) {
       return subscribe(
               klass = T::class,
               callback = callback)

adam-arold

fun usage() {
  
   val subscriptions = mutableListOf<Subscription>()
  
   subscriptions.cancelAll()
  
}

adam-arold

fun <T: Subscription> MutableList<T>.cancelAll() {
   forEach {
       it.cancel()
   }
   clear()
}

adam-arold

fun cancelAllSubscriptions() {
   subscriptions.forEach {
       it.cancel()
   }
   subscriptions.clear()
}

adam-arold

val subscriptions: MutableList<Subscription> =
    mutableListOf()

adam-arold

fun Subscription.Companion.create(): Subscription {
   TODO("Create new Subscription")
}

fun useIt() {
   Subscription.create()
}

adam-arold

interface Subscription {
  
   fun cancel()
  
   companion object
}

adam-arold

// safe to use
package api

interface Component
interface DrawSurface
interface Container



// use them at your own risk!

adam-arold

object ComponentFactory {

   fun createComponent(
       children: Iterable<Component>,
       drawSurface: DrawSurface): Component {
       return MyComponent(
               children = children,
               drawSurface = drawSurface)
   }
}