document processor

Author: Soroosh Sarabadani

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

@@ -10,7 +10,13 @@
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.tools.StandardLocation;
 
+/**
+ * The writer is able to load an existing resource file as a Map and override it with the new
+ * mappings added to the existing mappings. Every entry corresponds to a line in the resource file
+ * where key and values are separated by comma.
+ */
 class AccumulativeMappingWriter {
+
   private Map<String, String> mappings = new ConcurrentHashMap<>();
   private final String resourcePath;
   private final ProcessingEnvironment processingEnvironment;
@@ -41,11 +47,17 @@ public AccumulativeMappingWriter loadExistingMappings() {
     return this;
   }
 
+  /**
+   * Add a new mapping
+   */
   public AccumulativeMappingWriter add(String key, String value) {
     this.mappings.put(key, value);
     return this;
   }
 
+  /**
+   * Generates or overrise the resource file with the given path ({@linkAccumulativeMappingWriter#resourcePath})
+   */
   public void flush() {
     PrintWriter printWriter = null;
     try {

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

@@ -15,6 +15,9 @@
 import javax.lang.model.type.TypeVariable;
 import javax.lang.model.util.Types;
 
+/**
+ * This class can resolve a type parameter in the given index to the actual type defined.
+ */
 class TypeParameterResolver {
 
   private final DeclaredType interestedClass;
@@ -26,6 +29,14 @@ public TypeParameterResolver(DeclaredType interestedClass, int interestedTypeArg
     this.interestedTypeArgumentIndex = interestedTypeArgumentIndex;
   }
 
+  /**
+   * @param typeUtils    Type utilities, During the annotation processing processingEnv.getTypeUtils()
+   *                     can be passed.
+   * @param declaredType Class or Interface which extends or implements the interestedClass, and the
+   *                     interest is getting the actual declared type is used.
+   * @return the type of the parameter if it can be resolved from the the given declareType,
+   * otherwise it returns null
+   */
   public TypeMirror resolve(Types typeUtils, DeclaredType declaredType) {
     final var chain = findChain(typeUtils, declaredType);
     var lastIndex = chain.size() - 1;
@@ -78,6 +89,8 @@ private List<DeclaredType> findChain(Types typeUtils, DeclaredType declaredType)
     var superclass = (DeclaredType) superElement.getSuperclass();
 
     final var matchingInterfaces = getMatchingInterfaces(typeUtils, superElement);
+    //if chain of interfaces is not empty, there is no reason to continue the lookup
+    //  as interfaces do not extend the classes
     if (matchingInterfaces.size() > 0) {
       result.addAll(matchingInterfaces);
       return result;
@@ -126,18 +139,18 @@ private List<DeclaredType> findChainOfInterfaces(Types typeUtils, DeclaredType p
     var matchingInterfaces =
         ((TypeElement) parentInterface.asElement())
             .getInterfaces().stream()
-                .filter(i -> typeUtils.isAssignable(i, interestedClass))
-                .map(i -> (DeclaredType) i)
-                .collect(Collectors.toList());
+            .filter(i -> typeUtils.isAssignable(i, interestedClass))
+            .map(i -> (DeclaredType) i)
+            .collect(Collectors.toList());
     while (matchingInterfaces.size() > 0) {
       result.addAll(matchingInterfaces);
       final var lastFoundInterface = matchingInterfaces.get(matchingInterfaces.size() - 1);
       matchingInterfaces =
           ((TypeElement) lastFoundInterface.asElement())
               .getInterfaces().stream()
-                  .filter(i -> typeUtils.isAssignable(i, interestedClass))
-                  .map(i -> (DeclaredType) i)
-                  .collect(Collectors.toList());
+              .filter(i -> typeUtils.isAssignable(i, interestedClass))
+              .map(i -> (DeclaredType) i)
+              .collect(Collectors.toList());
     }
     return result;
   }