Refactor EventProcessor for improved readability

.gitignore

@@ -1,5 +1,8 @@
 # Maven build directories
 target/
 
+# Dependency reduced POM from Maven Shade Plugin
+dependency-reduced-pom.xml
+
 # Eclipse settings directories
 .settings/

event-bus-ap/src/main/java/dev/kske/eventbus/ap/EventProcessor.java

@@ -21,51 +21,80 @@ import dev.kske.eventbus.core.*;
 @SupportedSourceVersion(SourceVersion.RELEASE_11)
 public class EventProcessor extends AbstractProcessor {
 
+	@SuppressWarnings("unchecked")
 	@Override
 	public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
-		for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(Event.class)) {
+		if (!roundEnv.errorRaised() && !roundEnv.processingOver())
-			ExecutableElement	method			= (ExecutableElement) annotatedElement;
+			processRound(
-			Event				eventAnnotation	= method.getAnnotation(Event.class);
+				(Set<ExecutableElement>) roundEnv.getElementsAnnotatedWith(Event.class));
-			boolean				useParameter	= false;
+
+		// Do not claim the processed annotations
+		return false;
+	}
+
+	private void processRound(Set<ExecutableElement> eventHandlers) {
+		for (ExecutableElement eventHandler : eventHandlers) {
+			TypeElement	eventListener	= (TypeElement) eventHandler.getEnclosingElement();
+			Event		eventAnnotation	= eventHandler.getAnnotation(Event.class);
 
 			// Determine how the event type is defined
+			boolean useParameter;
 			try {
 				eventAnnotation.eventType();
+				throw new EventBusException(
+					"Could not determine event type of handler " + eventHandler);
 			} catch (MirroredTypeException e) {
 
 				// Task failed successfully
 				useParameter = processingEnv.getTypeUtils().isSameType(e.getTypeMirror(),
-					processingEnv.getElementUtils()
+					getTypeMirror(Event.USE_PARAMETER.class));
-						.getTypeElement(Event.USE_PARAMETER.class.getCanonicalName()).asType());
 			}
 
 			// Check for correct method signature and return type
-			if (method.getParameters().size() == 0 && useParameter)
+			if (eventHandler.getParameters().size() == 0 && useParameter)
-				error(method, "The method or the annotation should define the event type");
+				error(eventHandler, "The method or the annotation must define the event type");
 
-			if (method.getParameters().size() == 1 && !useParameter)
+			if (eventHandler.getParameters().size() == 1 && !useParameter)
-				error(method, "Either the method or the annotation should define the event type");
+				error(eventHandler,
+					"Either the method or the annotation must define the event type");
 
-			if (method.getParameters().size() > 1)
+			if (eventHandler.getParameters().size() > 1)
-				error(method, "Method should not have more than one parameter");
+				error(eventHandler, "Method must not have more than one parameter");
 
-			if (!method.getReturnType().getKind().equals(TypeKind.VOID))
+			if (eventHandler.getReturnType().getKind() != TypeKind.VOID)
-				error(method, "Method needs a return type of void");
+				error(eventHandler, "Method must return void");
 
-			// Check event type
+			// Get first parameter as type and element
-			var paramType = ((ExecutableType) method.asType()).getParameterTypes().get(0);
+			var	paramElement	= eventHandler.getParameters().get(0);
+			var	paramType		= paramElement.asType();
+
+			// Check for valid event type
 			if (useParameter && !processingEnv.getTypeUtils().isAssignable(paramType,
-				processingEnv.getElementUtils()
+				getTypeMirror(IEvent.class)))
-					.getTypeElement(IEvent.class.getCanonicalName()).asType()))
+				error(paramElement, "Parameter must implement IEvent");
-				error(method.getParameters().get(0), "Parameter should implement IEvent");
+
+			// Check for handlers for abstract types that don't include subtypes
+			if (!eventAnnotation.includeSubtypes() && paramType.getKind() == TypeKind.DECLARED) {
+				var declaredElement = ((DeclaredType) paramType).asElement();
+				if (declaredElement.getKind() == ElementKind.INTERFACE
+					|| declaredElement.getModifiers().contains(Modifier.ABSTRACT))
+					warning(paramElement,
+						"Parameter should be instantiable or handler should include subtypes");
+			}
 
 			// Check listener for interface implementation
-			if (!((TypeElement) method.getEnclosingElement()).getInterfaces().contains(processingEnv
+			if (!eventListener.getInterfaces().contains(getTypeMirror(EventListener.class)))
-				.getElementUtils().getTypeElement(EventListener.class.getCanonicalName()).asType()))
+				warning(eventHandler.getEnclosingElement(),
-				warning(method.getEnclosingElement(),
 					"Class should implement EventListener interface");
 		}
-		return true;
+	}
+
+	private TypeMirror getTypeMirror(Class<?> clazz) {
+		return getTypeElement(clazz).asType();
+	}
+
+	private TypeElement getTypeElement(Class<?> clazz) {
+		return processingEnv.getElementUtils().getTypeElement(clazz.getCanonicalName());
 	}
 
 	private void warning(Element e, String msg, Object... args) {