EVENTBUS

An extremely fast, flexible, lightweight, and simple event system aimed towards Minecraft utility mods.

Usage

Adding to your project:

If you have not already, add Jitpack as a repository:

repositories {
    maven { url 'https://jitpack.io' }
}

Add the release of your choice in the dependencies block:

dependencies {
    implementation 'com.github.therealbush:eventbus:1.0.2'
}

Creating an EventBus:

When creating a new EventBus, there are 3 different arguments it can accept:

A handler type.
A consumer for logging errors.
A consumer for logging debug info.
Alternatively, one consumer for both info and errors.

The default handler type is LambdaHandler

The default consumer logs to console, with the prefix [EVENTBUS]:

The following are all valid:

new EventBus();
new EventBus(ASMHandler.class);
new EventBus(MyUtilityMod.logger::error);
new EventBus(System.out::println, info -> mc.player.sendChatMessage("I love bush's event bus! " + info));
new EventBus(ReflectHandler.class, MyUtilityMod.logger::error);
new EventBus(ASMHandler.class, MyUtilityMod.logger::error, MyUtilityMod.logger::info);

Creating an Event:

Extend Event, and implement the method isCancellable().

Example:

import me.bush.eventbus.event.Event;

public class MyEvent extends Event {

    @Override
    protected boolean isCancellable() {
        return true;
    }
}

Creating a Listener:

Create a public void method with one parameter, which is a subclass of Event. Annotate the method with @EventListener.

There are two modifiers you can add to the annotation:

priority: Listeners with high priority will recieve events before listeners with low priority.
recieveCancelled: Listeners with recieveCancelled enabled will recieve events even after they are cancelled.

Example:

@EventListener
public void onEvent(MyEvent event) {}

Subscribing an Object/Class:

Calling EventBus#subscribe and EventBus#unsubscribe will add and remove listeners from the EventBus. Only listeners in subscribed objects and classes will recieve events.

For non static listeners to recieve events, you must subscribe an object.
For static listeners to recieve events, you must subscribe a class.

Static listeners will not recieve events if only an object is subscribed, and vice versa.

Posting an Event:

Calling EventBus#post will post an event to every listener with an exactly matching event type. For example, if event B extends event A, and event A is posted, B listeners will not recieve it.

This method will return true if the posted event was cancelled, and false otherwise.

Features

Thread Safe

I tried to make it fail, and it wouldn't.

Simple to Use

Simple implementation, and simple listener syntax.

Fast

Nearly twice as fast as the default Forge EventBus.

Flexible

3 Different Handler Types
You can also make your own by extending Handler
~~Kinda pointless, but it was fun to make (just use lambdahandler lol)~~

ASMHandler:

The same invocation style Forge uses. This is pretty fast, but a little hacky.

LambdaHandler:

Uses LambdaMetaFactory to create a "function object", which is nearly as fast as direct access.

ReflectHandler:

The most basic style, but also the most reliable.

therealbush/eventbus