Processor.java

package com.jetdrone.vertx.yoke.annotations;

import com.jetdrone.vertx.yoke.annotations.processors.ContentNegotiationProcessorHandler;
import com.jetdrone.vertx.yoke.annotations.processors.JsonSchemaProcessorHandler;
import com.jetdrone.vertx.yoke.annotations.processors.RegExParamProcessorHandler;
import com.jetdrone.vertx.yoke.annotations.processors.RouterProcessorHandler;
import org.jetbrains.annotations.NotNull;

import java.lang.annotation.Annotation;
import java.lang.invoke.CallSite;
import java.lang.invoke.ConstantCallSite;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

public final class Processor {

    private static final MethodHandles.Lookup lookup = MethodHandles.publicLookup();

    private static final List<AnnotationHandler<?>> handlers = new ArrayList<>();

    private Processor() {
    }

    static {
        handlers.add(new ContentNegotiationProcessorHandler());
        handlers.add(new JsonSchemaProcessorHandler());
        handlers.add(new RegExParamProcessorHandler());
        handlers.add(new RouterProcessorHandler());
    }

    public static void registerProcessor(String className) {
        try {
            registerProcessor(Class.forName(className));
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    public static synchronized void registerProcessor(Class<?> processor) {
        try {
            // if already registered skip
            for (AnnotationHandler<?> annotationHandler : handlers) {
                if (annotationHandler.getClass().equals(processor)) {
                    // skip
                    return;
                }
            }

            if (AnnotationHandler.class.isAssignableFrom(processor)) {
                // always insert before router processor
                handlers.add(handlers.size() - 1, (AnnotationHandler) processor.newInstance());
            }
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    @SuppressWarnings("unchecked")
    public static <T> void process(@NotNull T context, @NotNull Object instance) {
        final Class<?> clazz = instance.getClass();

        for (final Field field : clazz.getFields()) {
            for (AnnotationHandler<?> handler : handlers) {
                if (handler.isFor(context.getClass())) {
                    final AnnotationHandler<T> _handler = (AnnotationHandler<T>) handler;
                    _handler.process(context, instance, clazz, field);
                }
            }
        }

        for (final Method method : clazz.getMethods()) {
            for (AnnotationHandler<?> handler : handlers) {
                if (handler.isFor(context.getClass())) {
                    final AnnotationHandler<T> _handler = (AnnotationHandler<T>) handler;
                    _handler.process(context, instance, clazz, method);
                }
            }
        }
    }

    public static MethodHandle getMethodHandle(Method m, Class<?>... paramTypes) {
        try {
            Class[] methodParamTypes = m.getParameterTypes();

            if (methodParamTypes != null) {
                if (methodParamTypes.length == paramTypes.length) {
                    for (int i = 0; i < methodParamTypes.length; i++) {
                        if (!paramTypes[i].isAssignableFrom(methodParamTypes[i])) {
                            // for groovy and other languages that do not do type check at compile time
                            if (!methodParamTypes[i].equals(Object.class)) {
                                return null;
                            }
                        }
                    }
                } else {
                    return null;
                }
            } else {
                return null;
            }

            MethodHandle methodHandle = lookup.unreflect(m);
            CallSite callSite = new ConstantCallSite(methodHandle);
            return callSite.dynamicInvoker();

        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public static boolean isCompatible(Method m, Class<? extends Annotation> annotation, Class<?>... paramTypes) {
        if (getAnnotation(m, annotation) != null) {
            if (getMethodHandle(m, paramTypes) != null) {
                return true;
            } else {
                throw new RuntimeException("Method signature not compatible!");
            }
        }
        return false;
    }

    public static boolean isCompatible(Field f, Class<? extends Annotation> annotation, Class<?> type) {
        if (getAnnotation(f, annotation) != null) {
            Class<?> fieldType = f.getType();

            if (fieldType != null) {
                if (!type.isAssignableFrom(fieldType)) {
                    return false;
                }
            } else {
                return false;
            }

            return true;
        }
        return false;
    }

    @SuppressWarnings("unchecked")
    public static <T extends Annotation> T getAnnotation(Method m, Class<T> annotation) {
        // skip static methods
        if (Modifier.isStatic(m.getModifiers())) {
            return null;
        }
        // skip non public methods
        if (!Modifier.isPublic(m.getModifiers())) {
            return null;
        }

        Annotation[] annotations = m.getAnnotations();
        // this method is not annotated
        if (annotations == null) {
            return null;
        }

        // verify if the method is annotated
        for (Annotation ann : annotations) {
            if (ann.annotationType().equals(annotation)) {
                return (T) ann;
            }
        }

        return null;
    }

    @SuppressWarnings("unchecked")
    public static <T extends Annotation> T getAnnotation(Field f, Class<T> annotation) {
        // skip non final methods
        if (!Modifier.isFinal(f.getModifiers())) {
            return null;
        }
        // skip non public methods
        if (!Modifier.isPublic(f.getModifiers())) {
            return null;
        }

        Annotation[] annotations = f.getAnnotations();
        // this method is not annotated
        if (annotations == null) {
            return null;
        }

        // verify if the method is annotated
        for (Annotation ann : annotations) {
            if (ann.annotationType().equals(annotation)) {
                return (T) ann;
            }
        }

        return null;
    }

    @SuppressWarnings("unchecked")
    public static <T extends Annotation> T getAnnotation(Class<?> c, Class<T> annotation) {
        // skip non public classes
        if (!Modifier.isPublic(c.getModifiers())) {
            return null;
        }

        Annotation[] annotations = c.getAnnotations();
        // this method is not annotated
        if (annotations == null) {
            return null;
        }

        // verify if the method is annotated
        for (Annotation ann : annotations) {
            if (ann.annotationType().equals(annotation)) {
                return (T) ann;
            }
        }

        return null;
    }
}