diff options
Diffstat (limited to 'src/main/kotlin/me/bush')
5 files changed, 97 insertions, 50 deletions
diff --git a/src/main/kotlin/me/bush/illnamethislater/CancelledState.kt b/src/main/kotlin/me/bush/illnamethislater/CancelledState.kt index 80022ba..d6ff39d 100644 --- a/src/main/kotlin/me/bush/illnamethislater/CancelledState.kt +++ b/src/main/kotlin/me/bush/illnamethislater/CancelledState.kt @@ -19,12 +19,14 @@ internal fun interface CancelledState { /** * Returns whether [event] is cancelled or not. [event] should only ever be of the type - * that was passed to [CancelledState.of], or this will cause an error. + * that was passed to [CancelledState.of], **or this will crash.** */ fun isCancelled(event: Any): Boolean companion object { - private val UNSAFE = Unsafe::class.declaredMembers.single { it.name == "theUnsafe" }.handleCall() as Unsafe + private val UNSAFE = runCatching { + Unsafe::class.declaredMembers.single { it.name == "theUnsafe" }.handleCall() as Unsafe + }.getOrNull() // soy jvm private val CANCELLED_NAMES = arrayOf("canceled", "cancelled") private val NOT_CANCELLABLE = CancelledState { false } private val OFFSETS = hashMapOf<KClass<*>, Long>() @@ -40,7 +42,7 @@ internal fun interface CancelledState { // Find a field named "cancelled" or "canceled" that is a boolean, and has a backing field. type.allMembers.filter { it.name in CANCELLED_NAMES && it.returnType == typeOf<Boolean>() } .filterIsInstance<KMutableProperty<*>>().filter { it.javaField != null }.toList().let { - if (it.isEmpty()) return NOT_CANCELLABLE + if (it.isEmpty() || UNSAFE == null) return NOT_CANCELLABLE if (it.size != 1) config.logger.warn("Multiple possible cancel fields found for event type $type") it[0].javaField!!.let { field -> if (Modifier.isStatic(field.modifiers)) OFFSETS[type] = UNSAFE.staticFieldOffset(field) diff --git a/src/main/kotlin/me/bush/illnamethislater/Event.kt b/src/main/kotlin/me/bush/illnamethislater/Event.kt index 476a34a..2881c0e 100644 --- a/src/main/kotlin/me/bush/illnamethislater/Event.kt +++ b/src/main/kotlin/me/bush/illnamethislater/Event.kt @@ -23,7 +23,7 @@ abstract class Event { /** * Determines if this event can be [cancelled]. This does not have to return a constant value. */ - abstract val cancellable: Boolean + protected abstract val cancellable: Boolean /** * Sets [cancelled] to true. diff --git a/src/main/kotlin/me/bush/illnamethislater/EventBus.kt b/src/main/kotlin/me/bush/illnamethislater/EventBus.kt index 6b9b0bf..5b278e3 100644 --- a/src/main/kotlin/me/bush/illnamethislater/EventBus.kt +++ b/src/main/kotlin/me/bush/illnamethislater/EventBus.kt @@ -3,31 +3,32 @@ package me.bush.illnamethislater import kotlin.reflect.KClass /** - * A simple event dispatcher - * - * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) + * [A simple event dispatcher.](https://github.com/therealbush/eventbus-kotlin#tododothething) * * @author bush * @since 1.0.0 */ class EventBus(private val config: Config = Config()) { private val listeners = hashMapOf<KClass<*>, ListenerGroup>() - private val subscribers = mutableSetOf<Any>() + private val subscribers = hashMapOf<Any, List<Listener>>() /** - * doc + * Searches [subscriber] for members that return [Listener] and registers them. + * + * This will not find top level listeners, use [register] instead. + * + * Returns `false` if [subscriber] was already subscribed, `true` otherwise. * * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) */ fun subscribe(subscriber: Any): Boolean { return if (subscriber in subscribers) false else runCatching { - subscriber::class.listeners.forEach { member -> - register(member.handleCall(subscriber).also { - it.subscriber = subscriber - }) - } - subscribers.add(subscriber) + // Register every listener into a group, but also + // keep a separate list just for this subscriber. + subscribers[subscriber] = subscriber::class.listeners.map { member -> + register(member.handleCall(subscriber).also { it.subscriber = subscriber }) + }.toList() true }.getOrElse { config.logger.error("Unable to register listeners for subscriber $subscriber", it) @@ -36,40 +37,64 @@ class EventBus(private val config: Config = Config()) { } /** - * doc + * Unregisters all listeners belonging to [subscriber]. + * + * This will not remove top level listeners, use [unregister] instead. + * + * Returns `true` if [subscriber] was subscribed, `false` otherwise. * * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) */ fun unsubscribe(subscriber: Any): Boolean { - return subscribers.remove(subscriber).also { contains -> - if (contains) listeners.entries.removeIf { - it.value.unsubscribe(subscriber) - it.value.sequential.isEmpty() && it.value.parallel.isEmpty() - } + val contained = subscriber in subscribers + // Unregister every listener for this subscriber, + // and return null so the map entry is removed. + subscribers.computeIfPresent(subscriber) { _, listeners -> + listeners.forEach { unregister(it) } + null } + return contained } /** - * Registers a listener (which may not belong to any subscriber) to this [EventBus]. If no object - * is given, a key will be returned which can be used in [unsubscribe] to remove the listener. + * Registers a [Listener] to this [EventBus]. * * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) */ - fun register(listener: Listener) = listener.also { - listeners.computeIfAbsent(it.type) { type -> ListenerGroup(type, config) }.register(it) + fun register(listener: Listener): Listener { + listeners.computeIfAbsent(listener.type) { + ListenerGroup(it, config) + }.register(listener) + return listener } /** - * doc + * Unregisters a [Listener] from this [EventBus]. * * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) */ - fun unregister(listener: Listener) = listener.also { - listeners[it.type]?.unregister(it) + fun unregister(listener: Listener): Boolean { + return listeners[listener.type]?.let { + val contained = it.unregister(listener) + if (it.parallel.isEmpty() && it.sequential.isEmpty()) { + listeners.remove(listener.type) + } + contained + } ?: false } /** - * Posts an event. doc + * Posts an [event] to every listener that accepts its type. + * + * Events are **not** queued: only listeners subscribed currently will be called. + * + * If [event] is a subclass of [Event], or has a field-backed mutable boolean property + * named "cancelled" or "canceled" and [Config.thirdPartyCompatibility] is `true`, + * it can be cancelled by a listener, and only future listeners with [Listener.receiveCancelled] + * will receive it. + * + * Sequential listeners are called in the order of [Listener.priority], and parallel + * listeners are called before or after, depending on the value of [Config.parallelFirst]. * * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) */ @@ -79,13 +104,15 @@ class EventBus(private val config: Config = Config()) { * Logs the subscriber count, total listener count, and listener count for every event type with at * least one subscriber to [Config.logger]. Per-event counts are sorted from greatest to least listeners. * + * **This may cause a [ConcurrentModificationException] if [register] or [subscribe] is called in parallel.** + * * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) * ``` * Subscribers: 5 - * Listeners: 8 sequential, 4 parallel - * BushIsSoCool: 4, 2 - * OtherEvent: 3, 1 - * String: 1, 1 + * Listeners: 8 sequential, 21 parallel + * BushIsSoCool: 4, 9 + * OtherEvent: 1, 10 + * String: 3, 0 */ fun debugInfo() { config.logger.info("Subscribers: ${subscribers.size}") diff --git a/src/main/kotlin/me/bush/illnamethislater/Listener.kt b/src/main/kotlin/me/bush/illnamethislater/Listener.kt index 7105baf..b2bb2ce 100644 --- a/src/main/kotlin/me/bush/illnamethislater/Listener.kt +++ b/src/main/kotlin/me/bush/illnamethislater/Listener.kt @@ -1,5 +1,6 @@ package me.bush.illnamethislater +import java.util.function.Consumer import kotlin.reflect.KClass /** @@ -26,16 +27,15 @@ class Listener @PublishedApi internal constructor( } /** - * Creates a listener that can be held in a variable, returned from - * a function or getter, or directly registered to an Eventbus. + * Creates a listener that can be held in a variable or returned from a function + * or getter belonging to an object to be subscribed with [EventBus.subscribe], + * or directly registered to an [EventBus] with [EventBus.register]. * * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) * - * @param T The type of event to listen for. Inheritance has no effect here. - * If [T] is a base class, subclass events will not be received. - * @param priority The priority of this listener. This can be any integer. - * Listeners with a higher [priority] will be invoked first. - * @param parallel If a listener should be invoked in parallel with other [parallel] listeners, or sequentially. todo finish parallel + * @param T The **exact** (no inheritance) type of event to listen for. + * @param priority The priority of this listener, high to low. + * @param parallel If a listener should be invoked in parallel with other parallel listeners, or sequentially. * @param receiveCancelled If a listener should receive events that have been cancelled by previous listeners. * @param listener The body of the listener that will be invoked. */ @@ -45,3 +45,29 @@ inline fun <reified T : Any> listener( receiveCancelled: Boolean = false, noinline listener: (T) -> Unit ) = Listener(listener, T::class, priority, parallel, receiveCancelled) + +/** + * **This function is intended for use in Java code.** + * + * Creates a listener that can be held in a variable or returned from a function + * or getter belonging to an object to be subscribed with [EventBus.subscribe], + * or directly registered to an [EventBus] with [EventBus.register]. + * + * [Information and examples](https://github.com/therealbush/eventbus-kotlin#tododothething) + * + * @param type The **exact** (no inheritance) type of event to listen for. + * @param priority The priority of this listener, high to low. + * @param parallel If a listener should be invoked in parallel with other parallel listeners, or sequentially. + * @param receiveCancelled If a listener should receive events that have been cancelled by previous listeners. + * @param listener The body of the listener that will be invoked. + */ +@JvmOverloads +fun <T : Any> listener( + type: Class<T>, + priority: Int = 0, + parallel: Boolean = false, + receiveCancelled: Boolean = false, + // This might introduce some overhead, but its worth + // not manually having to return "Kotlin.UNIT" from every Java listener. + listener: Consumer<T> +) = Listener({ event: T -> listener.accept(event) }, type.kotlin, priority, parallel, receiveCancelled) diff --git a/src/main/kotlin/me/bush/illnamethislater/ListenerGroup.kt b/src/main/kotlin/me/bush/illnamethislater/ListenerGroup.kt index 7b2a039..fdcc7bc 100644 --- a/src/main/kotlin/me/bush/illnamethislater/ListenerGroup.kt +++ b/src/main/kotlin/me/bush/illnamethislater/ListenerGroup.kt @@ -32,20 +32,12 @@ internal class ListenerGroup( /** * Removes [listener] from this [ListenerGroup]. */ - fun unregister(listener: Listener) { - if (listener.parallel) parallel.remove(listener) + fun unregister(listener: Listener): Boolean { + return if (listener.parallel) parallel.remove(listener) else sequential.remove(listener) } /** - * Removes every listener whose subscriber is [subscriber]. - */ - fun unsubscribe(subscriber: Any) { - parallel.removeIf { it.subscriber == subscriber } - sequential.removeIf { it.subscriber == subscriber } - } - - /** * Posts an event to every listener. Returns true of the event was cancelled. */ fun post(event: Any): Boolean { |