format code

Author: Soroosh Sarabadani

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

@@ -47,16 +47,15 @@ public AccumulativeMappingWriter loadExistingMappings() {
     return this;
   }
 
-  /**
-   * Add a new mapping
-   */
+  /** 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})
+   * Generates or overrise the resource file with the given path
+   * ({@linkAccumulativeMappingWriter#resourcePath})
    */
   public void flush() {
     PrintWriter printWriter = null;

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

@@ -15,9 +15,7 @@
 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.
- */
+/** This class can resolve a type parameter in the given index to the actual type defined. */
 class TypeParameterResolver {
 
   private final DeclaredType interestedClass;
@@ -30,12 +28,12 @@ public TypeParameterResolver(DeclaredType interestedClass, int interestedTypeArg
   }
 
   /**
-   * @param typeUtils    Type utilities, During the annotation processing processingEnv.getTypeUtils()
-   *                     can be passed.
+   * @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.
+   *     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
+   *     otherwise it returns null
    */
   public TypeMirror resolve(Types typeUtils, DeclaredType declaredType) {
     final var chain = findChain(typeUtils, declaredType);
@@ -89,7 +87,7 @@ 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
+    // 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);
@@ -139,18 +137,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;
   }