#1037 Improve architecture of registration methods (#236)

* #1037 Improve architecture of registration methods
- Introduce parameters classes for each registration method
- RegistrationMethod has constants with the required parameters class -> no longer need to have a RegistrationExecutorProvider class that needs to be injected everywhere, let AsyncRegister be the only one to worry about which class will perform the registration
- Fix inheritance of password registration types - previously two-factor auth registration inherited from password registration directly

* Create matcher which checks for equality via reflections
- Allow to perform equality check on objects with default equals() method

src/main/java/fr/xephi/authme/initialization/factory/FactoryDependencyHandler.java

@@ -16,8 +16,8 @@ public class FactoryDependencyHandler implements DependencyHandler {
         if (dependencyDescription.getType() == Factory.class) {
             Class<?> genericType = ReflectionUtils.getGenericType(dependencyDescription.getGenericType());
             if (genericType == null) {
-                throw new IllegalStateException("Factory fields must have concrete generic type. " +
-                    "Cannot get generic type for field in '" + context.getMappedClass() + "'");
+                throw new IllegalStateException("Factory fields must have concrete generic type. "
+                    + "Cannot get generic type for field in '" + context.getMappedClass() + "'");
             }
 
             return new FactoryImpl<>(genericType, context.getInjector());

src/main/java/fr/xephi/authme/initialization/factory/SingletonStore.java

@@ -0,0 +1,37 @@
+package fr.xephi.authme.initialization.factory;
+
+import java.util.Collection;
+
+/**
+ * Injectable object to retrieve and create singletons of a common parent.
+ *
+ * @param <P> the parent class to which this store is limited to
+ */
+public interface SingletonStore<P> {
+
+    /**
+     * Returns the singleton of the given type, creating it if it hasn't been yet created.
+     *
+     * @param clazz the class to get the singleton for
+     * @param <C> type of the singleton
+     * @return the singleton of type {@code C}
+     */
+    <C extends P> C getSingleton(Class<C> clazz);
+
+    /**
+     * Returns all existing singletons of this store's type.
+     *
+     * @return all registered singletons of type {@code P}
+     */
+    Collection<P> retrieveAllOfType();
+
+    /**
+     * Returns all existing singletons of the given type.
+     *
+     * @param clazz the type to get singletons for
+     * @param <C> class type
+     * @return all registered singletons of type {@code C}
+     */
+    <C extends P> Collection<C> retrieveAllOfType(Class<C> clazz);
+
+}

src/main/java/fr/xephi/authme/initialization/factory/SingletonStoreDependencyHandler.java

@@ -0,0 +1,61 @@
+package fr.xephi.authme.initialization.factory;
+
+import ch.jalu.injector.Injector;
+import ch.jalu.injector.context.ResolvedInstantiationContext;
+import ch.jalu.injector.handlers.dependency.DependencyHandler;
+import ch.jalu.injector.handlers.instantiation.DependencyDescription;
+import ch.jalu.injector.utils.ReflectionUtils;
+
+import java.util.Collection;
+
+/**
+ * Dependency handler that builds {@link SingletonStore} objects.
+ */
+public class SingletonStoreDependencyHandler implements DependencyHandler {
+
+    @Override
+    public Object resolveValue(ResolvedInstantiationContext<?> context, DependencyDescription dependencyDescription) {
+        if (dependencyDescription.getType() == SingletonStore.class) {
+            Class<?> genericType = ReflectionUtils.getGenericType(dependencyDescription.getGenericType());
+            if (genericType == null) {
+                throw new IllegalStateException("Singleton store fields must have concrete generic type. "
+                    + "Cannot get generic type for field in '" + context.getMappedClass() + "'");
+            }
+
+            return new SingletonStoreImpl<>(genericType, context.getInjector());
+        }
+        return null;
+    }
+
+    private static final class SingletonStoreImpl<P> implements SingletonStore<P> {
+
+        private final Injector injector;
+        private final Class<P> parentClass;
+
+        SingletonStoreImpl(Class<P> parentClass, Injector injector) {
+            this.parentClass = parentClass;
+            this.injector = injector;
+        }
+
+        @Override
+        public <C extends P> C getSingleton(Class<C> clazz) {
+            if (parentClass.isAssignableFrom(clazz)) {
+                return injector.getSingleton(clazz);
+            }
+            throw new IllegalArgumentException(clazz + " not child of " + parentClass);
+        }
+
+        @Override
+        public Collection<P> retrieveAllOfType() {
+            return retrieveAllOfType(parentClass);
+        }
+
+        @Override
+        public <C extends P> Collection<C> retrieveAllOfType(Class<C> clazz) {
+            if (parentClass.isAssignableFrom(clazz)) {
+                return injector.retrieveAllOfType(clazz);
+            }
+            throw new IllegalArgumentException(clazz + " not child of " + parentClass);
+        }
+    }
+}