Large update to how EventBus works. Made it alot more complicated but also added support for record events...

Author: RealMangorage

src/main/java/org/mangorage/eventbus/EventBus.java

@@ -23,40 +23,60 @@
 package org.mangorage.eventbus;
 
 import it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap;
+import org.mangorage.eventbus.annotations.SubscribeEvent;
 import org.mangorage.eventbus.event.core.Event;
+import org.mangorage.eventbus.event.core.GenericEvent;
+import org.mangorage.eventbus.interfaces.IEvent;
 import org.mangorage.eventbus.interfaces.IEventBus;
 import org.mangorage.eventbus.interfaces.IEventType;
+import org.mangorage.eventbus.interfaces.IEventTypeHandler;
 import org.mangorage.eventbus.interfaces.IGenericEvent;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.Map;
-import java.util.concurrent.Semaphore;
 import java.util.function.Consumer;
 
-public final class EventBus<F extends IEventType<F>> implements IEventBus<F> {
+public final class EventBus<EE extends IEvent & IEventType<F>, GG extends IGenericEvent<?> & IEventType<F>, F extends IEventType<F>> implements IEventBus<F> {
 
-    public static <F extends IEventType<F>> IEventBus<F> create() {
-        return new EventBus<>();
+    public static <E extends IEvent & IEventType<F>, G extends IGenericEvent<?> & IEventType<F>, F extends IEventType<F>> IEventBus<F> create(IEventTypeHandler<E, G, F> handler, Class<F> flagType) {
+        return new EventBus<>(handler, flagType);
     }
 
-
     private final Map<EventKey<?, ?>, ListenerList<?>> LISTENERS = new Object2ObjectArrayMap<>();
-    private final Semaphore writeLock = new Semaphore(1, true);
+    private final IEventTypeHandler<EE, GG, F> handler;
+    private final Class<F> flagType;
 
-    private EventBus() {
+    private EventBus(IEventTypeHandler<EE, GG, F> handler, Class<F> flagType) {
+        this.handler = handler;
+        this.flagType = flagType;
     }
 
+
     @Override
-    public <E extends Event & IEventType<F>> void addListener(int priority, Class<E> eventClass, Consumer<E> consumer) {
+    public <E extends IEvent & IEventType<F>> void addListener(int priority, Class<E> eventClass, Consumer<E> consumer) {
         var list = getListenerList(eventClass, null);
         if (list != null) list.register(priority, consumer);
     }
 
     @Override
-    public <E extends Event & IGenericEvent<G> & IEventType<F>, G> void addGenericListener(int priority, Class<G> baseFilterClass, Class<E> eventClass, Consumer<E> consumer) {
+    public <E extends IEvent & IGenericEvent<G> & IEventType<F>, G> void addGenericListener(int priority, Class<G> baseFilterClass, Class<E> eventClass, Consumer<E> consumer) {
         var list = getListenerList(eventClass, baseFilterClass);
         if (list != null) list.register(priority, consumer);
     }
 
+
+    private <E extends IEvent & IGenericEvent<G> & IEventType<F>, G> void addGenericListenerCast(int priority, Class<G> baseFilterClass, Class<?> eventClass, Consumer<?> consumer) {
+        addGenericListener(
+                priority,
+                baseFilterClass,
+                (Class<E>) eventClass,
+                (Consumer<E>) consumer
+        );
+    }
+
+
     @Override
     public void registerClass(Class<?> clazz) {
         register(clazz, null);
@@ -70,7 +90,6 @@ public void registerObject(Object object) {
     @SuppressWarnings("unchecked")
     private void register(Class<?> clazz, Object instance) {
         // TODO: FIX LATER
-        /**
         for (Method method : clazz.getDeclaredMethods()) {
             var subscribeEvent = method.getDeclaredAnnotation(SubscribeEvent.class);
 
@@ -94,9 +113,9 @@ private void register(Class<?> clazz, Object instance) {
             }
 
             var eventClass = (Class<Event>) params[0].getType();
-            if (IGenericEvent.class.isAssignableFrom(eventClass)) {
-                var genericClass = (Class<GenericEvent<Object>>) params[0].getType();
+            if (handler.canHandle(eventClass, ListenerType.GENERIC)) {
                 var genericType = subscribeEvent.genericType();
+                var genericClass = handler.castGenericClass(params[0].getType(), genericType);
                 if (genericType == SubscribeEvent.NullClass.class) {
                     throw new IllegalStateException("Cannot Register a GenericListener due to no GenericType being defined...");
                 }
@@ -109,8 +128,13 @@ private void register(Class<?> clazz, Object instance) {
                     }
                 };
 
-                addGenericListener(subscribeEvent.priority(), (Class<Object>) genericType, genericClass, consumer);
-            } else {
+                addGenericListenerCast(
+                        subscribeEvent.priority(),
+                        (Class<Object>) genericType,
+                        genericClass,
+                        consumer
+                );
+            } else if (handler.canHandle(eventClass, ListenerType.NORMAL)) {
                 Consumer<Event> consumer = e -> {
                     try {
                         method.invoke(instance, e);
@@ -119,14 +143,19 @@ private void register(Class<?> clazz, Object instance) {
                     }
                 };
 
-                addListener(subscribeEvent.priority(), eventClass, consumer);
+                addListener(
+                        subscribeEvent.priority(),
+                        handler.castNormalClass(eventClass),
+                        handler.castNormalConsumer(consumer)
+                );
+            } else {
+                throw new IllegalStateException("Cannot register Method %s with EventType of %s needs to implement %s".formatted(method, eventClass, flagType));
             }
         }
-         **/
     }
 
     @SuppressWarnings("unchecked")
-    private <E extends Event> ListenerList<E> getListenerList(Class<E> eventClass, Class<?> genericType) {
+    private <E extends IEvent> ListenerList<E> getListenerList(Class<E> eventClass, Class<?> genericType) {
         var key = new EventKey<>(eventClass, genericType);
         var list = LISTENERS.get(key);
 
@@ -143,7 +172,7 @@ private <E extends Event> ListenerList<E> getListenerList(Class<E> eventClass, C
 
     @Override
     @SuppressWarnings("unchecked")
-    public <E extends Event & IEventType<F>> void post(E event) {
+    public <E extends IEvent & IEventType<F>> void post(E event) {
         Class<?> genericType = null;
         if (event instanceof IGenericEvent<?> genericEvent)
             genericType = genericEvent.getGenericType();

src/main/java/org/mangorage/eventbus/EventKey.java

@@ -22,7 +22,7 @@
 
 package org.mangorage.eventbus;
 
-import org.mangorage.eventbus.event.core.Event;
+import org.mangorage.eventbus.interfaces.IEvent;
 
-public record EventKey<E extends Event, G>(Class<E> eventClass, Class<G> genericClass) {
+public record EventKey<E extends IEvent, G>(Class<E> eventClass, Class<G> genericClass) {
 }

src/main/java/org/mangorage/eventbus/EventListener.java

@@ -23,12 +23,12 @@
 package org.mangorage.eventbus;
 
 import org.jetbrains.annotations.NotNull;
-import org.mangorage.eventbus.event.core.Event;
+import org.mangorage.eventbus.interfaces.IEvent;
 
 import java.util.function.Consumer;
 
-public record EventListener<E extends Event>(int priority,
-                                             Consumer<E> consumer) implements Comparable<EventListener<E>> {
+public record EventListener<E extends IEvent>(int priority,
+                                              Consumer<E> consumer) implements Comparable<EventListener<E>> {
     /**
      * @param o the object to be compared.
      * @return

src/main/java/org/mangorage/eventbus/ListenerList.java

@@ -22,7 +22,7 @@
 
 package org.mangorage.eventbus;
 
-import org.mangorage.eventbus.event.core.Event;
+import org.mangorage.eventbus.interfaces.IEvent;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -31,7 +31,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 
-public final class ListenerList<E extends Event> {
+public final class ListenerList<E extends IEvent> {
     private final List<EventListener<E>> listeners = Collections.synchronizedList(new ArrayList<>(2));
     private final List<ListenerList<E>> children = Collections.synchronizedList(new ArrayList<>(2));
     private final ListenerList<?> parent;

src/main/java/org/mangorage/eventbus/ListenerType.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2024. MangoRage
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+ * OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package org.mangorage.eventbus;
+
+public enum ListenerType {
+    GENERIC,
+    NORMAL
+}

src/main/java/org/mangorage/eventbus/event/NormalEventHandler.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024. MangoRage
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+ * OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package org.mangorage.eventbus.event;
+
+import org.mangorage.eventbus.ListenerType;
+import org.mangorage.eventbus.event.core.GenericEvent;
+import org.mangorage.eventbus.interfaces.IEventType;
+import org.mangorage.eventbus.interfaces.IEventTypeHandler;
+
+public class NormalEventHandler implements IEventTypeHandler<NormalEvent, NormalGenericEvent<?>, IEventType.INormalBusEvent> {
+
+
+    @Override
+    public boolean canHandle(Class<?> eventClass, ListenerType listenerType) {
+        return switch (listenerType) {
+            case NORMAL -> NormalEvent.class.isAssignableFrom(eventClass);
+            case GENERIC -> NormalGenericEvent.class.isAssignableFrom(eventClass);
+        };
+    }
+
+    @Override
+    public <GT, T extends GenericEvent<GT> & IEventType<IEventType.INormalBusEvent>> Class<T> castGenericClass(Class<?> clz, Class<GT> genericType) {
+        return (Class<T>) clz;
+    }
+
+}

src/main/java/org/mangorage/eventbus/event/Test.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024. MangoRage
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+ * OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package org.mangorage.eventbus.event;
+
+import org.mangorage.eventbus.EventBus;
+import org.mangorage.eventbus.annotations.SubscribeEvent;
+import org.mangorage.eventbus.interfaces.IEventBus;
+import org.mangorage.eventbus.interfaces.IEventType;
+
+public class Test {
+    private static final IEventBus<IEventType.INormalBusEvent> NORMAL = EventBus.create(new NormalEventHandler(), IEventType.INormalBusEvent.class);
+
+
+    public static class MyGeneric<S> extends NormalGenericEvent<S> {
+
+        public MyGeneric(Class<S> tClass) {
+            super(tClass);
+        }
+    }
+
+
+    public static void main(String[] args) {
+        NORMAL.registerClass(Test.class);
+        NORMAL.post(new MyGeneric<>(String.class));
+    }
+
+    @SubscribeEvent(genericType = String.class)
+    public static void test(MyGeneric<String> test) {
+        System.out.println(test.getGenericType());
+    }
+}

src/main/java/org/mangorage/eventbus/event/core/Event.java

@@ -22,5 +22,7 @@
 
 package org.mangorage.eventbus.event.core;
 
-public abstract class Event {
+import org.mangorage.eventbus.interfaces.IEvent;
+
+public abstract class Event implements IEvent {
 }

src/main/java/org/mangorage/eventbus/interfaces/IEvent.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024. MangoRage
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+ * OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package org.mangorage.eventbus.interfaces;
+
+public interface IEvent {
+}

src/main/java/org/mangorage/eventbus/interfaces/IEventBus.java

@@ -22,21 +22,19 @@
 
 package org.mangorage.eventbus.interfaces;
 
-import org.mangorage.eventbus.event.core.Event;
-
 import java.util.function.Consumer;
 
 public interface IEventBus<F extends IEventType<F>> {
-    <E extends Event & IEventType<F>> void addListener(int priority, Class<E> eventClass, Consumer<E> consumer);
+    <E extends IEvent & IEventType<F>> void addListener(int priority, Class<E> eventClass, Consumer<E> consumer);
 
-    <E extends Event & IGenericEvent<G> & IEventType<F>, G> void addGenericListener(int priority, Class<G> baseFilterClass, Class<E> eventClass, Consumer<E> consumer);
+    <E extends IEvent & IGenericEvent<G> & IEventType<F>, G> void addGenericListener(int priority, Class<G> baseFilterClass, Class<E> eventClass, Consumer<E> consumer);
 
     void registerClass(Class<?> clazz);
 
     void registerObject(Object object);
 
 
-    <E extends Event & IEventType<F>> void post(E event);
+    <E extends IEvent & IEventType<F>> void post(E event);
 
     void startup();
     void shutdown();