feather-core · JarvisCraft · Jun 18, 2019 · Jun 18, 2019 · Jun 19, 2019 · Jun 19, 2019
diff --git a/eventbus/pom.xml b/eventbus/pom.xml
@@ -26,6 +26,11 @@
     <artifactId>feathercore-eventbus</artifactId>
 
     <dependencies>
+        <dependency>
+            <groupId>ru.progrm-jarvis</groupId>
+            <artifactId>reflector</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>

diff --git a/eventbus/src/main/java/org/feathercore/eventbus/SimpleEventManager.java b/eventbus/src/main/java/org/feathercore/eventbus/SimpleEventManager.java
@@ -21,11 +21,9 @@
 import lombok.experimental.FieldDefaults;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import ru.progrm_jarvis.reflector.invoke.InvokeUtil;
 
-import java.lang.invoke.LambdaMetafactory;
 import java.lang.invoke.MethodHandles.Lookup;
-import java.lang.invoke.MethodType;
-import java.lang.reflect.Method;
 import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Queue;
@@ -83,7 +81,14 @@ public void register(@NonNull final Object listener) {
             }
 
             EventHandler annotation = method.getAnnotation(EventHandler.class);
-            register((Class<? extends E>) parameterType, constructConsumer(listener, method), annotation.priority());
+            register(
+                    (Class<E>) parameterType,
+                    InvokeUtil.<Consumer<E>, Object>invokeFactory()
+                              .boundTo(listener)
+                              .implementing(Consumer.class)
+                              .via(method)
+                    .createUnsafely(),
+                    annotation.priority());
         }
     }
 
@@ -106,23 +111,6 @@ public <T extends E> void call(@NotNull final T event) {
         }
     }
 
-    @SuppressWarnings("unchecked")
-    protected static <E extends Event> Consumer<E> constructConsumer(Object listener, Method method) {
-        try {
-            Lookup lookup = constructLookup(listener.getClass());
-            return (Consumer<E>) LambdaMetafactory.metafactory(
-                    lookup,
-                    "accept",
-                    MethodType.methodType(Consumer.class, listener.getClass()),
-                    MethodType.methodType(void.class, Object.class),
-                    lookup.unreflect(method),
-                    MethodType.methodType(void.class, method.getParameterTypes()[0])
-            ).getTarget().invoke(listener);
-        } catch (Throwable t) {
-            throw new RuntimeException("Could not create event listener", t);
-        }
-    }
-
     /**
      * We are in need of our own Lookup creation with an argument of given owner class, because we want to be able
      * to execute private and any other non-public methods.

diff --git a/module-api/pom.xml b/module-api/pom.xml
@@ -31,6 +31,16 @@
             <artifactId>feathercore-shared</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>ru.progrm-jarvis</groupId>
+            <artifactId>java-commons</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
@@ -45,6 +55,10 @@
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>

diff --git a/module-api/src/main/java/ru/feathercore/moduleapi/AbstractModuleLoader.java b/module-api/src/main/java/ru/feathercore/moduleapi/AbstractModuleLoader.java
@@ -20,58 +20,116 @@
 import lombok.experimental.FieldDefaults;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Collection;
-import java.util.Collections;
+import java.util.*;
 
 /**
  * An abstract implementation of {@link ModuleLoader<M>} sufficient for all operations it requires.
  *
- * @param <M> super-type of all modules managed
+ * @param <M> super-type of modules which this module-loader can manage
+ *
+ * // TODO: 15.11.2019 Docs
  */
 @ToString
 @EqualsAndHashCode
 @FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true)
-public abstract class AbstractModuleLoader<M extends Module> implements ModuleLoader<M> {
+public class AbstractModuleLoader<M extends Module> implements ModuleLoader<M> {
+
+    @NonNull Map<Class<? extends M>, M> modules;
+    /**
+     * Storage of unique instanced of loaded modules.
+     */
+    @NonNull Set<M> loadedModules, loadedModulesView;
+
+    /**
+     * Creates new instance of module loader using the given {@link Collection collections} for storage of modules.
+     *
+     * @param modulesMap set which will be used for storage of associations of module types with their implementations
+     * @param loadedModulesSet set which will be used for storage of loaded modules
+     * @throws IllegalArgumentException if the given set is non-empty
+     */
+    public AbstractModuleLoader(@NonNull final Map<Class<? extends M>, M> modulesMap,
+                                @NonNull final Set<M> loadedModulesSet) {
+        if (!modulesMap.isEmpty()) throw new IllegalArgumentException("modules map should be empty");
+        if (!loadedModulesSet.isEmpty()) throw new IllegalArgumentException("loaded modules set should be empty");
+
+        modules = modulesMap;
+        loadedModules = loadedModulesSet;
+        loadedModulesView = Collections.unmodifiableSet(loadedModules);
+    }
 
-    @NonNull Collection<M> modules, modulesView;
+    /* ************************************************* Callbacks ************************************************* */
 
-    public AbstractModuleLoader(@NonNull final Collection<M> modules) {
-        this.modules = modules;
-        modulesView = Collections.unmodifiableCollection(modules);
+    /**
+     * Callback used by method-loading methods to notify that the module has been loaded.
+     *
+     * @param module module which has just been loaded
+     */
+    protected void onModuleLoad(@NotNull final M module) {}
+
+    /**
+     * Callback used by {@link #unloadModule(Class)} to notify that the module has been unloaded.
+     *
+     * @param module module which has just been unloaded
+     */
+    protected void onModuleUnload(@NotNull final M module) {}
+
+    /* *************************************************** Logic *************************************************** */
+
+    @Override
+    public Collection<M> getModules() {
+        return loadedModulesView;
     }
 
     @Override
-    public Collection<? extends M> getModules() {
-        return modulesView;
+    @SuppressWarnings("unchecked")
+    public <T extends M> Optional<? extends T> getModule(@NonNull final Class<T> type) {
+        return Optional.ofNullable((T) modules.get(type));
     }
 
     @Override
-    public <T extends M, C> T loadModule(@NonNull final ModuleInitializer<T, C> initializer, final C configuration) {
+    public boolean isModuleLoaded(@NonNull final Class<? extends M> type) {
+        return modules.containsKey(type);
+    }
+
+    @Override
+    public <T extends M> boolean isModuleLoaded(@NonNull final T module) {
+        return modules.containsValue(module);
+    }
+
+    @Override
+    public <T extends M, C> T loadModule(@NonNull final ModuleInitializer<T, C> initializer, final C configuration,
+                                         final Iterable<Class<T>> moduleTypes) {
         val module = initializer.loadModule(configuration);
-        if (modules.add(module)) onModuleLoad(module);
+        for (val moduleType : moduleTypes) modules.put(moduleType, module);
+        loadedModules.add(module);
+
+        onModuleLoad(module);
 
         return module;
     }
 
     @Override
-    public <T extends M> boolean unloadModule(@NonNull final T module) {
-        val unloaded = modules.remove(module);
-        if (unloaded) onModuleUnload(module);
+    public <T extends M> Optional<T> unloadModule(@NonNull final Class<? extends T> moduleType) {
+        @SuppressWarnings("unchecked") val module = (T) modules.remove(moduleType);
+        if (module != null) {
+            if (!modules.containsValue(module)) loadedModules.remove(module);
+            onModuleUnload(module);
+
+            return Optional.of(module);
+        }
 
-        return unloaded;
+        return Optional.empty();
     }
 
-    /**
-     * Callback used by {@link #loadModule(ModuleInitializer, Object)} to notify that the module has been loaded.
-     *
-     * @param module module which has just been loaded
-     */
-    protected void onModuleLoad(@NotNull final M module) {}
+    @Override
+    public Collection<? extends M> unloadAllModules() {
+        val modulesUnloaded = new ArrayList<>(loadedModules);
 
-    /**
-     * Callback used by {@link #unloadModule(Module)} to notify that the module has been unloaded.
-     *
-     * @param module module which has just been loaded
-     */
-    protected void onModuleUnload(@NotNull final M module) {}
+        for (val module : modulesUnloaded) onModuleUnload(module);
+
+        modules.clear();
+        loadedModules.clear();
+
+        return modulesUnloaded;
+    }
 }
diff --git a/module-api/src/main/java/ru/feathercore/moduleapi/ModuleInitializer.java b/module-api/src/main/java/ru/feathercore/moduleapi/ModuleInitializer.java
@@ -16,8 +16,8 @@
 
 package ru.feathercore.moduleapi;
 
-import org.feathercore.shared.object.ValueContainer;
 import org.jetbrains.annotations.NotNull;
+import ru.progrm_jarvis.javacommons.object.ValueContainer;
 
 /**
  * Initializer of a module which is normally used by {@link ModuleLoader} to load a specific module.