support multiple components of a type in BasePlugin

Author: HSGamer

plugin/plugin-base/src/main/java/io/github/projectunified/minelib/plugin/base/BasePlugin.java

@@ -7,13 +7,14 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 /**
  * Base plugin class that provides a simple way to manage components
  */
 public class BasePlugin extends JavaPlugin implements Loadable {
     private final List<Object> components;
-    private final Map<Class<?>, Object> lookupMap;
+    private final Map<Class<?>, List<Object>> lookupMap;
 
     /**
      * Create a new plugin instance
@@ -33,6 +34,25 @@ protected List<Object> getComponents() {
         return Collections.emptyList();
     }
 
+    private List<Object> getComponents(Class<?> type) {
+        return lookupMap.computeIfAbsent(
+                type,
+                t -> components.stream().filter(t::isInstance).map(t::cast).collect(Collectors.toList())
+        );
+    }
+
+    /**
+     * Get all components that are the instanced of the given type
+     *
+     * @param type the class of the component
+     * @param <T>  the type
+     * @return the type of the component
+     */
+    @SuppressWarnings("unchecked")
+    public final <T> List<T> getAll(Class<T> type) {
+        return (List<T>) getComponents(type);
+    }
+
     /**
      * Get a component by its class.
      *
@@ -41,14 +61,11 @@ protected List<Object> getComponents() {
      * @return the component
      */
     public final <T> T get(Class<T> type) {
-        return type.cast(lookupMap.computeIfAbsent(type, t -> {
-            for (Object component : components) {
-                if (type.isInstance(component)) {
-                    return component;
-                }
-            }
+        List<Object> components = getComponents(type);
+        if (components.isEmpty()) {
             throw new IllegalArgumentException("No component of type " + type.getName() + " found");
-        }));
+        }
+        return type.cast(components.get(0));
     }
 
     /**
@@ -60,8 +77,10 @@ public final <T> T get(Class<T> type) {
      * @param <T>      the type of the component
      */
     public final <T> void call(Class<T> type, Consumer<T> consumer, boolean reverse) {
-        int size = components.size();
+        List<T> components = getAll(type);
+        if (components.isEmpty()) return;
 
+        int size = components.size();
         int index, step;
         if (reverse) {
             index = size - 1;
@@ -72,10 +91,8 @@ public final <T> void call(Class<T> type, Consumer<T> consumer, boolean reverse)
         }
 
         while (index >= 0 && index < size) {
-            Object component = components.get(index);
-            if (type.isInstance(component)) {
-                consumer.accept(type.cast(component));
-            }
+            T component = components.get(index);
+            consumer.accept(component);
             index += step;
         }
     }
@@ -107,5 +124,6 @@ public final void onEnable() {
     public final void onDisable() {
         this.call(Loadable.class, Loadable::disable, true);
         this.disable();
+        this.lookupMap.clear();
     }
 }