From 390c383e82e16b18ac312cc55d8f546d3cea2c3f Mon Sep 17 00:00:00 2001
From: TheMode <themode@outlook.fr>
Date: Tue, 17 Aug 2021 02:24:21 +0200
Subject: [PATCH] Rename EventInterface, add `unregister`

---
 ...{EventInterface.java => EventBinding.java} | 28 +++++++++++--------
 .../net/minestom/server/event/EventNode.java  |  4 ++-
 .../minestom/server/event/EventNodeImpl.java  | 27 ++++++++++++------
 3 files changed, 37 insertions(+), 22 deletions(-)
 rename src/main/java/net/minestom/server/event/{EventInterface.java => EventBinding.java} (65%)

diff --git a/src/main/java/net/minestom/server/event/EventInterface.java b/src/main/java/net/minestom/server/event/EventBinding.java
similarity index 65%
rename from src/main/java/net/minestom/server/event/EventInterface.java
rename to src/main/java/net/minestom/server/event/EventBinding.java
index 17fadc53d..543ced590 100644
--- a/src/main/java/net/minestom/server/event/EventInterface.java
+++ b/src/main/java/net/minestom/server/event/EventBinding.java
@@ -9,7 +9,7 @@ import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
-public interface EventInterface<E extends Event> {
+public interface EventBinding<E extends Event> {
 
     static <E extends Event, T> @NotNull FilteredBuilder<E, T> filtered(@NotNull EventFilter<E, T> filter, @NotNull Predicate<T> predicate) {
         return new FilteredBuilder<>(filter, predicate);
@@ -17,8 +17,7 @@ public interface EventInterface<E extends Event> {
 
     @NotNull Collection<Class<? extends Event>> eventTypes();
 
-    Consumer<E> consumer(Class<? extends Event> eventType);
-
+    @NotNull Consumer<@NotNull E> consumer(@NotNull Class<? extends Event> eventType);
 
     class FilteredBuilder<E extends Event, T> {
         private final EventFilter<E, T> filter;
@@ -37,23 +36,28 @@ public interface EventInterface<E extends Event> {
             return this;
         }
 
-        public @NotNull EventInterface<E> build() {
+        public @NotNull EventBinding<E> build() {
             final var copy = Map.copyOf(mapped);
             final var eventTypes = copy.keySet();
-            return new EventInterface<>() {
+
+            Map<Class<? extends Event>, Consumer<E>> consumers = new HashMap<>(eventTypes.size());
+            for (var eventType : eventTypes) {
+                final var consumer = copy.get(eventType);
+                consumers.put(eventType, event -> {
+                    final T handler = filter.getHandler(event);
+                    if (!predicate.test(handler)) return;
+                    consumer.accept(handler, event);
+                });
+            }
+            return new EventBinding<>() {
                 @Override
                 public @NotNull Collection<Class<? extends Event>> eventTypes() {
                     return eventTypes;
                 }
 
                 @Override
-                public Consumer<E> consumer(Class<? extends Event> eventType) {
-                    final var consumer = copy.get(eventType);
-                    return event -> {
-                        final T handler = filter.getHandler(event);
-                        if (!predicate.test(handler)) return;
-                        consumer.accept(handler, event);
-                    };
+                public @NotNull Consumer<E> consumer(@NotNull Class<? extends Event> eventType) {
+                    return consumers.get(eventType);
                 }
             };
         }
diff --git a/src/main/java/net/minestom/server/event/EventNode.java b/src/main/java/net/minestom/server/event/EventNode.java
index f867a6bd9..f39e65cc0 100644
--- a/src/main/java/net/minestom/server/event/EventNode.java
+++ b/src/main/java/net/minestom/server/event/EventNode.java
@@ -320,5 +320,7 @@ public interface EventNode<T extends Event> {
 
     boolean unmap(@NotNull Object value);
 
-    void registerInterface(@NotNull EventInterface<? extends T> eventInterface);
+    void register(@NotNull EventBinding<? extends T> binding);
+
+    void unregister(@NotNull EventBinding<? extends T> binding);
 }
diff --git a/src/main/java/net/minestom/server/event/EventNodeImpl.java b/src/main/java/net/minestom/server/event/EventNodeImpl.java
index 020d469ba..efb01f53a 100644
--- a/src/main/java/net/minestom/server/event/EventNodeImpl.java
+++ b/src/main/java/net/minestom/server/event/EventNodeImpl.java
@@ -221,13 +221,23 @@ class EventNodeImpl<T extends Event> implements EventNode<T> {
     }
 
     @Override
-    public void registerInterface(@NotNull EventInterface<? extends T> eventInterface) {
+    public void register(@NotNull EventBinding<? extends T> binding) {
         synchronized (GLOBAL_CHILD_LOCK) {
-            for (var eventType : eventInterface.eventTypes()) {
+            for (var eventType : binding.eventTypes()) {
                 var entry = getEntry((Class<? extends T>) eventType);
-                final var consumer = eventInterface.consumer(eventType);
-                entry.interfaces.add((EventInterface<T>) eventInterface);
-                entry.interfaceConsumers.add((Consumer<T>) consumer);
+                final var consumer = binding.consumer(eventType);
+                entry.bindingConsumers.add((Consumer<T>) consumer);
+            }
+        }
+    }
+
+    @Override
+    public void unregister(@NotNull EventBinding<? extends T> binding) {
+        synchronized (GLOBAL_CHILD_LOCK) {
+            for (var eventType : binding.eventTypes()) {
+                var entry = listenerMap.get(eventType);
+                if (entry == null) return;
+                entry.bindingConsumers.remove(binding.consumer(eventType));
             }
         }
     }
@@ -304,8 +314,7 @@ class EventNodeImpl<T extends Event> implements EventNode<T> {
 
         final List<EventFilter<?, ?>> filters;
         final List<EventListener<T>> listeners = new CopyOnWriteArrayList<>();
-        final Set<EventInterface<T>> interfaces = new CopyOnWriteArraySet<>();
-        final Set<Consumer<T>> interfaceConsumers = new CopyOnWriteArraySet<>();
+        final Set<Consumer<T>> bindingConsumers = new CopyOnWriteArraySet<>();
         final Map<Object, EventNode<T>> mappedNode = new WeakHashMap<>();
         volatile int childCount;
 
@@ -315,8 +324,8 @@ class EventNodeImpl<T extends Event> implements EventNode<T> {
 
         void call(T event) {
             // Event interfaces
-            if (!interfaceConsumers.isEmpty()) {
-                for (var consumer : interfaceConsumers) {
+            if (!bindingConsumers.isEmpty()) {
+                for (var consumer : bindingConsumers) {
                     consumer.accept(event);
                 }
             }