zdm/event-bus
3
Fork 0
Code Issues 2 Pull Requests Releases 8 Wiki Activity

Refactor EventProcessor for improved readability

Browse Source
This commit is contained in:
Kai S. K. Engelbart
2021-02-14 21:29:06 +01:00
parent 023acb9172
commit ab01845178
2 changed files with 55 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

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

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

@@ -21,51 +21,80 @@ import dev.kske.eventbus.core.*;
@SupportedSourceVersion(SourceVersion.RELEASE_11) @SupportedSourceVersion(SourceVersion.RELEASE_11)
public class EventProcessor extends AbstractProcessor { public class EventProcessor extends AbstractProcessor {
@SuppressWarnings("unchecked")
@Override @Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { 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 // Determine how the event type is defined
boolean useParameter;
try { try {
eventAnnotation.eventType(); eventAnnotation.eventType();
throw new EventBusException(
"Could not determine event type of handler " + eventHandler);
} catch (MirroredTypeException e) { } catch (MirroredTypeException e) {
// Task failed successfully // Task failed successfully
useParameter = processingEnv.getTypeUtils().isSameType(e.getTypeMirror(), 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 // 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, 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 // 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"); "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) { private void warning(Element e, String msg, Object... args) {