extract findChain

Author: Soroosh Sarabadani

operator-framework/src/main/java/io/javaoperatorsdk/operator/processing/annotation/ControllerAnnotationProcessor.java

@@ -49,7 +49,17 @@ public class ControllerAnnotationProcessor extends AbstractProcessor {
 
   private AccumulativeMappingWriter controllersResourceWriter;
   private AccumulativeMappingWriter doneablesResourceWriter;
-  private Set<String> generatedDoneableClassFiles = new HashSet<>();
+  final DeclaredType resourceControllerType =
+      processingEnv
+          .getTypeUtils()
+          .getDeclaredType(
+              processingEnv
+                  .getElementUtils()
+                  .getTypeElement(ResourceController.class.getCanonicalName()),
+              processingEnv.getTypeUtils().getWildcardType(null, null));
+  private final TypeParameterResolver typeParameterResolver = new TypeParameterResolver(
+      resourceControllerType, 0);
+  private final Set<String> generatedDoneableClassFiles = new HashSet<>();
 
   @Override
   public synchronized void init(ProcessingEnvironment processingEnv) {
@@ -147,7 +157,9 @@ private void generateDoneableClass(TypeElement controllerClassSymbol) {
 
   private TypeMirror findResourceType(TypeElement controllerClassSymbol) throws Exception {
     try {
-      final var chain = findChain((DeclaredType) controllerClassSymbol.asType());
+      final var chain = typeParameterResolver
+          .findChain(processingEnv.getTypeUtils(), processingEnv.getElementUtils(),
+              (DeclaredType) controllerClassSymbol.asType());
       final var customResourceClass = getCustomResourceClass(chain);
       return customResourceClass;
     } catch (Exception e) {
@@ -163,81 +175,6 @@ private String makeQualifiedClassName(String packageName, String className) {
     return packageName + "." + className;
   }
 
-  private List<DeclaredType> findChain(DeclaredType declaredType) {
-    final var resourceControllerType =
-        processingEnv
-            .getTypeUtils()
-            .getDeclaredType(
-                processingEnv
-                    .getElementUtils()
-                    .getTypeElement(ResourceController.class.getCanonicalName()),
-                processingEnv.getTypeUtils().getWildcardType(null, null));
-    final var result = new ArrayList<DeclaredType>();
-    result.add(declaredType);
-    var superElement = ((TypeElement) ((DeclaredType) declaredType).asElement());
-    var superclass = (DeclaredType) superElement.getSuperclass();
-    boolean interfaceFound = false;
-    final var matchingInterfaces =
-        superElement.getInterfaces().stream()
-            .filter(
-                intface ->
-                    processingEnv.getTypeUtils().isAssignable(intface, resourceControllerType))
-            .map(i -> (DeclaredType) i)
-            .collect(Collectors.toList());
-    if (!matchingInterfaces.isEmpty()) {
-      result.addAll(matchingInterfaces);
-      interfaceFound = true;
-    }
-
-    while (superclass.getKind() != TypeKind.NONE) {
-      if (interfaceFound) {
-        final var lastFoundInterface = result.get(result.size() - 1);
-        final var marchingInterfaces =
-            ((TypeElement) lastFoundInterface.asElement())
-                .getInterfaces().stream()
-                .filter(
-                    intface ->
-                        processingEnv
-                            .getTypeUtils()
-                            .isAssignable(intface, resourceControllerType))
-                .map(i -> (DeclaredType) i)
-                .collect(Collectors.toList());
-
-        if (marchingInterfaces.size() > 0) {
-          result.addAll(marchingInterfaces);
-          continue;
-        } else {
-          break;
-        }
-      }
-
-      if (processingEnv.getTypeUtils().isAssignable(superclass, resourceControllerType)) {
-        result.add(superclass);
-      }
-
-      superElement = (TypeElement) superclass.asElement();
-      final var matchedInterfaces =
-          superElement.getInterfaces().stream()
-              .filter(
-                  intface ->
-                      processingEnv.getTypeUtils().isAssignable(intface, resourceControllerType))
-              .map(i -> (DeclaredType) i)
-              .collect(Collectors.toList());
-      if (matchedInterfaces.size() > 0) {
-        result.addAll(matchedInterfaces);
-        interfaceFound = true;
-        continue;
-      }
-
-      if (superElement.getSuperclass().getKind() == TypeKind.NONE) {
-        break;
-      }
-      superclass = (DeclaredType) superElement.getSuperclass();
-    }
-
-    return result;
-  }
-
   private TypeMirror getCustomResourceClass(List<DeclaredType> chain) {
     var lastIndex = chain.size() - 1;
     String typeName;

operator-framework/src/main/java/io/javaoperatorsdk/operator/processing/annotation/TypeParameterResolver.java

@@ -0,0 +1,92 @@
+package io.javaoperatorsdk.operator.processing.annotation;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+
+class TypeParameterResolver {
+
+  private final DeclaredType interestedClass;
+  private final int interestedTypeArgumentIndex;
+
+  public TypeParameterResolver(DeclaredType interestedClass, int interestedTypeArgumentIndex) {
+
+    this.interestedClass = interestedClass;
+    this.interestedTypeArgumentIndex = interestedTypeArgumentIndex;
+  }
+
+
+  public List<DeclaredType> findChain(Types typeUtils, Elements elementUtils,
+      DeclaredType declaredType) {
+
+    final var result = new ArrayList<DeclaredType>();
+    result.add(declaredType);
+    var superElement = ((TypeElement) ((DeclaredType) declaredType).asElement());
+    var superclass = (DeclaredType) superElement.getSuperclass();
+    boolean interfaceFound = false;
+    final var matchingInterfaces =
+        superElement.getInterfaces().stream()
+            .filter(
+                intface ->
+                    typeUtils.isAssignable(intface, interestedClass))
+            .map(i -> (DeclaredType) i)
+            .collect(Collectors.toList());
+    if (!matchingInterfaces.isEmpty()) {
+      result.addAll(matchingInterfaces);
+      interfaceFound = true;
+    }
+
+    while (superclass.getKind() != TypeKind.NONE) {
+      if (interfaceFound) {
+        final var lastFoundInterface = result.get(result.size() - 1);
+        final var marchingInterfaces =
+            ((TypeElement) lastFoundInterface.asElement())
+                .getInterfaces().stream()
+                .filter(
+                    intface ->
+                        typeUtils
+                            .isAssignable(intface, interestedClass))
+                .map(i -> (DeclaredType) i)
+                .collect(Collectors.toList());
+
+        if (marchingInterfaces.size() > 0) {
+          result.addAll(marchingInterfaces);
+          continue;
+        } else {
+          break;
+        }
+      }
+
+      if (typeUtils.isAssignable(superclass, interestedClass)) {
+        result.add(superclass);
+      }
+
+      superElement = (TypeElement) superclass.asElement();
+      final var matchedInterfaces =
+          superElement.getInterfaces().stream()
+              .filter(
+                  intface ->
+                      typeUtils.isAssignable(intface, interestedClass))
+              .map(i -> (DeclaredType) i)
+              .collect(Collectors.toList());
+      if (matchedInterfaces.size() > 0) {
+        result.addAll(matchedInterfaces);
+        interfaceFound = true;
+        continue;
+      }
+
+      if (superElement.getSuperclass().getKind() == TypeKind.NONE) {
+        break;
+      }
+      superclass = (DeclaredType) superElement.getSuperclass();
+    }
+
+    return result;
+  }
+
+}