Switching from Function to Consumer

Author: jglick

src/main/java/org/jenkinsci/plugins/workflow/steps/StepExecution.java

@@ -1,5 +1,6 @@
 package org.jenkinsci.plugins.workflow.steps;
 
+import com.google.common.base.Function;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.io.Serializable;
@@ -9,12 +10,12 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
-import java.util.function.Function;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import edu.umd.cs.findbugs.annotations.CheckForNull;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import jakarta.inject.Inject;
+import java.util.function.Consumer;
 import jenkins.model.queue.AsynchronousExecution;
 import jenkins.util.Timer;
 
@@ -168,51 +169,48 @@ public boolean blocksRestart() {
     }
 
     /**
-     * Apply the given function to all the active running {@link StepExecution}s in the system.
+     * Apply the given action to all the active running {@link StepExecution}s in the system.
      *
      * @return
-     *      Future object that signals when the function application is complete.
+     *      Future object that signals when the calls are complete.
      * @see StepExecutionIterator
      */
-    public static ListenableFuture<?> applyAll(Function<StepExecution,Void> f) {
+    public static ListenableFuture<?> acceptAll(Consumer<StepExecution> c) {
         List<ListenableFuture<?>> futures = new ArrayList<>();
-        for (StepExecutionIterator i : StepExecutionIterator.all())
-            futures.add(i.apply(f));
+        for (StepExecutionIterator i : StepExecutionIterator.all()) {
+            futures.add(i.accept(c));
+        }
         return Futures.allAsList(futures);
     }
 
     /**
-     * @deprecated use {@link #applyAll(Function)}
+     * @deprecated use {@link #acceptAll(Consumer)}
      */
     @Deprecated
-    public static ListenableFuture<?> applyAll(com.google.common.base.Function<StepExecution, Void> f) {
-        return applyAll(fromGuava(f));
+    public static ListenableFuture<?> applyAll(Function<StepExecution, Void> f) {
+        return acceptAll(fromGuava(f));
     }
 
     /**
      * Applies only to the specific subtypes.
      */
-    public static <T extends StepExecution> ListenableFuture<?> applyAll(final Class<T> type, final Function<T,Void> f) {
-        return applyAll(new Function<StepExecution, Void>() {
-            @Override
-            public Void apply(StepExecution e) {
-                if (type.isInstance(e))
-                    f.apply(type.cast(e));
-                return null;
+    public static <T extends StepExecution> ListenableFuture<?> acceptAll(Class<T> type, Consumer<T> c) {
+        return acceptAll(e -> {
+            if (type.isInstance(e)) {
+                c.accept(type.cast(e));
             }
         });
     }
 
     /**
-     * @deprecated use {@link #applyAll(Class, Function)}
+     * @deprecated use {@link #acceptAll(Class, Consumer)}
      */
     @Deprecated
-    public static <T extends StepExecution> ListenableFuture<?> applyAll(
-            final Class<T> type, final com.google.common.base.Function<T, Void> f) {
-        return applyAll(type, fromGuava(f));
+    public static <T extends StepExecution> ListenableFuture<?> applyAll(Class<T> type, Function<T, Void> f) {
+        return acceptAll(type, fromGuava(f));
     }
 
-    private static <T, R> Function<T, R> fromGuava(com.google.common.base.Function<T, R> func) {
+    private static <T> Consumer<T> fromGuava(Function<T, Void> func) {
         return func::apply;
     }
 

src/main/java/org/jenkinsci/plugins/workflow/steps/StepExecutionIterator.java

@@ -1,19 +1,20 @@
 package org.jenkinsci.plugins.workflow.steps;
 
+import com.google.common.base.Function;
 import com.google.common.util.concurrent.ListenableFuture;
 import hudson.ExtensionList;
 import hudson.ExtensionPoint;
 import hudson.Util;
-import java.util.function.Function;
+import java.util.function.Consumer;
 
 /**
  * Enumerates active running {@link StepExecution}s in the system.
- * @see StepExecution#applyAll(Class, Function)
+ * @see StepExecution#acceptAll(Class, Consumer)
  * @author Kohsuke Kawaguchi
  */
 public abstract class StepExecutionIterator implements ExtensionPoint {
     /**
-     * Finds all the ongoing {@link StepExecution} and apply the function.
+     * Finds all the ongoing {@link StepExecution} and apply the action.
      *
      * The control flow is inverted because a major use case (workflow) loads
      * {@link StepExecution}s asynchronously (for example when workflow run
@@ -22,30 +23,27 @@ public abstract class StepExecutionIterator implements ExtensionPoint {
      * @return
      *      {@link ListenableFuture} to signal the completion of the application.
      */
-    public /* abstract */ ListenableFuture<?> apply(Function<StepExecution, Void> f) {
-        return Util.ifOverridden(
-                () -> apply(toGuava(f)),
-                StepExecutionIterator.class,
-                getClass(),
-                "apply",
-                com.google.common.base.Function.class);
+    public /* abstract */ ListenableFuture<?> accept(Consumer<StepExecution> f) {
+        return Util.ifOverridden(() -> apply(toGuava(f)), StepExecutionIterator.class, getClass(), "apply", Function.class);
     }
 
     /**
-     * @deprecated use {@link #apply(Function)}
+     * @deprecated use {@link #accept}
      */
     @Deprecated
-    public /* abstract */ ListenableFuture<?> apply(com.google.common.base.Function<StepExecution, Void> f) {
-        return Util.ifOverridden(
-                () -> apply(fromGuava(f)), StepExecutionIterator.class, getClass(), "apply", Function.class);
+    public /* abstract */ ListenableFuture<?> apply(Function<StepExecution, Void> f) {
+        return Util.ifOverridden(() -> accept(fromGuava(f)), StepExecutionIterator.class, getClass(), "accept", Consumer.class);
     }
 
-    private static <T, R> Function<T, R> fromGuava(com.google.common.base.Function<T, R> func) {
+    private static <T> Consumer<T> fromGuava(Function<T, Void> func) {
         return func::apply;
     }
 
-    private static <T, R> com.google.common.base.Function<T, R> toGuava(Function<T, R> func) {
-        return func::apply;
+    private static <T> Function<T, Void> toGuava(Consumer<T> consumer) {
+        return v -> {
+            consumer.accept(v);
+            return null;
+        };
     }
 
     public static ExtensionList<StepExecutionIterator> all() {