Add Annotation Processor for compile time checks

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/Handler.java

@@ -19,11 +19,15 @@
 
 package de.steamwar.command;
 
+import lombok.Getter;
+
 import java.lang.annotation.*;
 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
 
@@ -58,17 +62,29 @@ public interface Handler {
         Class<? extends Handler> value();
     }
 
+    class HandlerException extends Exception {
+        public HandlerException(String message) {
+            super(message);
+        }
+    }
+
     interface DataCheckable {
         boolean hasExecutorMapper(Class<?> clazz);
+
         boolean hasMapper(String key);
+
         boolean hasValidator(String key);
+
         boolean hasSupplier(String key);
     }
 
     interface DataReadable {
         Function<?, ?> getExecutorMapper(Class<?> clazz);
+
         <A, B> AbstractTypeMapper<A, B> getMapper(String key);
+
         <A, B> AbstractTypeValidator<A, B> getValidator(String key);
+
         <A, B> AbstractTypeSupplier<A, B> getSupplier(String key);
     }
 
@@ -76,17 +92,26 @@ public interface Handler {
         Function<?, ?> getExecutorMapper(Class<?> clazz);
 
         <A, B> void addMapper(String key, boolean local, AbstractTypeMapper<A, B> mapper);
+
         <A, B> void addValidator(String key, boolean local, AbstractTypeValidator<A, B> validator);
+
         <A, B> void addSupplier(String key, boolean local, AbstractTypeSupplier<A, B> supplier);
+
         /**
          * Invoking the same method twice will result in the exact same result.
          */
         <T> T invoke(Method method);
+
         void addCommand(Method method, String[] subCommand, String[] description, boolean noTabComplete);
     }
 
     interface HandlerMethod<T extends Annotation> extends Handler {
-        void check(T annotation, Method method, DataCheckable dataCheckable) throws Exception;
+        default void check(T annotation, Method method, DataCheckable dataCheckable) throws Exception {
+            check(annotation, new MethodWrapper.ForMethod(method), dataCheckable);
+        }
+
+        default void check(T annotation, MethodWrapper method, DataCheckable dataCheckable) throws HandlerException {
+        }
 
         int getRunPriority();
 
@@ -94,7 +119,12 @@ public interface Handler {
     }
 
     interface HandlerParameter<T extends Annotation, A, B> extends Handler {
-        void check(T annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception;
+        default void check(T annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            check(annotation, new MethodWrapper.ForMethod((Method) parameter.getDeclaringExecutable()), new ParameterWrapper.ForParameter(parameter), index, dataCheckable);
+        }
+
+        default void check(T annotation, MethodWrapper methodWrapper, ParameterWrapper parameter, int index, DataCheckable dataCheckable) throws HandlerException {
+        }
 
         default boolean needsParentTypeMapper() {
             return false;
@@ -118,4 +148,179 @@ public interface Handler {
             return null;
         }
     }
+
+    interface MethodWrapper {
+        String getName();
+
+        int getParameterCount();
+
+        TypeWrapper getReturnType();
+
+        ParameterWrapper[] getParameters();
+
+        class ForMethod implements MethodWrapper {
+
+            @Getter
+            private final Method method;
+
+            public ForMethod(Method method) {
+                this.method = method;
+            }
+
+            @Override
+            public String getName() {
+                return method.getName();
+            }
+
+            @Override
+            public int getParameterCount() {
+                return method.getParameterCount();
+            }
+
+            @Override
+            public TypeWrapper getReturnType() {
+                return new TypeWrapper.ForClass(method.getReturnType());
+            }
+
+            @Override
+            public ParameterWrapper[] getParameters() {
+                return Arrays.stream(method.getParameters()).map(ParameterWrapper.ForParameter::new).toArray(ParameterWrapper[]::new);
+            }
+        }
+    }
+
+    interface ParameterWrapper {
+        TypeWrapper getType();
+
+        boolean isVarArgs();
+
+        boolean isAnnotationPresent(Class<? extends Annotation> annotation);
+
+        <A extends Annotation> A getAnnotation(Class<A> annotation);
+
+        String getName();
+
+        List<Annotation> getAnnotations();
+
+        class ForParameter implements ParameterWrapper {
+
+            @Getter
+            private final Parameter parameter;
+
+            public ForParameter(Parameter parameter) {
+                this.parameter = parameter;
+            }
+
+            @Override
+            public TypeWrapper getType() {
+                return new TypeWrapper.ForClass(this.parameter.getType());
+            }
+
+            @Override
+            public boolean isVarArgs() {
+                return parameter.isVarArgs();
+            }
+
+            @Override
+            public boolean isAnnotationPresent(Class<? extends Annotation> annotation) {
+                return parameter.isAnnotationPresent(annotation);
+            }
+
+            @Override
+            public <A extends Annotation> A getAnnotation(Class<A> annotation) {
+                return parameter.getAnnotation(annotation);
+            }
+
+            @Override
+            public String getName() {
+                return parameter.getName();
+            }
+
+            @Override
+            public List<Annotation> getAnnotations() {
+                return CommandUtils.getAnnotations(parameter);
+            }
+        }
+    }
+
+    interface TypeWrapper {
+
+        boolean isAssignableTo(Class<?> clazz);
+
+        boolean isAssignableTo(TypeWrapper type);
+
+        boolean isPrimitive();
+
+        boolean isArray();
+
+        boolean isEnum();
+
+        boolean is(Class<?> clazz);
+
+        boolean is(TypeWrapper type);
+
+        TypeWrapper getComponentType();
+
+        String getName();
+
+        class ForClass implements TypeWrapper {
+            @Getter
+            private final Class<?> clazz;
+
+            public ForClass(Class<?> clazz) {
+                this.clazz = clazz;
+            }
+
+            @Override
+            public boolean isAssignableTo(Class<?> clazz) {
+                return clazz.isAssignableFrom(this.clazz);
+            }
+
+            @Override
+            public boolean isAssignableTo(TypeWrapper type) {
+                if (type instanceof ForClass) {
+                    return ((ForClass) type).getClazz().isAssignableFrom(clazz);
+                }
+                return false;
+            }
+
+            @Override
+            public boolean isPrimitive() {
+                return clazz.isPrimitive();
+            }
+
+            @Override
+            public boolean isArray() {
+                return clazz.isArray();
+            }
+
+            @Override
+            public boolean isEnum() {
+                return clazz.isEnum();
+            }
+
+            @Override
+            public boolean is(Class<?> clazz) {
+                return this.clazz == clazz;
+            }
+
+            @Override
+            public boolean is(TypeWrapper type) {
+                if (type instanceof ForClass) {
+                    return ((ForClass) type).getClazz() == this.clazz;
+                }
+                return false;
+            }
+
+            @Override
+            public TypeWrapper getComponentType() {
+                return new TypeWrapper.ForClass(this.clazz.getComponentType());
+            }
+
+            @Override
+            public String getName() {
+                return this.clazz.getName();
+            }
+        }
+    }
 }