tidying up inappropriate inheritance

Author: lassewesth

progress-tracking/src/main/java/org/neo4j/gds/core/utils/progress/tasks/LoggingLeafTaskVisitor.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.core.utils.progress.tasks;
+
+import org.neo4j.gds.core.utils.progress.ProgressLogger;
+
+@SuppressWarnings("ClassCanBeRecord")
+final class LoggingLeafTaskVisitor implements TaskVisitor {
+    private final ProgressLogger progressLogger;
+
+    LoggingLeafTaskVisitor(ProgressLogger progressLogger) {
+        this.progressLogger = progressLogger;
+    }
+
+    @Override
+    public void visitLeafTask(LeafTask leafTask) {
+        progressLogger.logFinishPercentage();
+    }
+}

progress-tracking/src/main/java/org/neo4j/gds/core/utils/progress/tasks/TaskProgressLogger.java

@@ -25,22 +25,33 @@
 import org.neo4j.gds.core.utils.progress.JobId;
 import org.neo4j.gds.core.utils.progress.ProgressLogger;
 
-import static org.neo4j.gds.utils.StringFormatting.formatWithLocale;
+import java.util.function.Supplier;
 
-public class TaskProgressLogger extends BatchingProgressLogger {
+import static org.neo4j.gds.utils.StringFormatting.formatWithLocale;
 
+@SuppressWarnings("ClassCanBeRecord")
+public final class TaskProgressLogger implements ProgressLogger {
+    private final BatchingProgressLogger batchingProgressLogger;
     private final Task baseTask;
     private final TaskVisitor loggingLeafTaskVisitor;
 
-    TaskProgressLogger(LoggerForProgressTracking log, JobId jobId, Task baseTask, Concurrency concurrency) {
-        super(log, jobId, baseTask, concurrency);
-        this.baseTask = baseTask;
-        this.loggingLeafTaskVisitor = new LoggingLeafTaskVisitor(this);
+    static TaskProgressLogger create(LoggerForProgressTracking log, JobId jobId, Task baseTask, Concurrency concurrency) {
+        var batchingProgressLogger = new BatchingProgressLogger(log, jobId, baseTask, concurrency);
+        var loggingLeafTaskVisitor = new LoggingLeafTaskVisitor(batchingProgressLogger);
+
+        return new TaskProgressLogger(batchingProgressLogger, baseTask, loggingLeafTaskVisitor);
+    }
+
+    static TaskProgressLogger create(LoggerForProgressTracking log, JobId jobId, Task baseTask, Concurrency concurrency, TaskVisitor leafTaskVisitor) {
+        var batchingProgressLogger = new BatchingProgressLogger(log, jobId, baseTask, concurrency);
+
+        return new TaskProgressLogger(batchingProgressLogger, baseTask, leafTaskVisitor);
     }
-    TaskProgressLogger(LoggerForProgressTracking log, JobId jobId, Task baseTask, Concurrency concurrency, TaskVisitor leafTaskVisitor) {
-        super(log, jobId, baseTask, concurrency);
+
+    private TaskProgressLogger(BatchingProgressLogger batchingProgressLogger, Task baseTask, TaskVisitor loggingLeafTaskVisitor) {
+        this.batchingProgressLogger = batchingProgressLogger;
         this.baseTask = baseTask;
-        this.loggingLeafTaskVisitor = leafTaskVisitor;
+        this.loggingLeafTaskVisitor = loggingLeafTaskVisitor;
     }
 
     void logBeginSubTask(Task task, Task parentTask) {
@@ -104,20 +115,13 @@ private String unboundedIterationsTaskName(
 
     private String taskDescription(Task task, Task parentTask) {
         String taskName;
-        if (parentTask instanceof IterativeTask) {
-            var iterativeParentTask = (IterativeTask) parentTask;
+        if (parentTask instanceof IterativeTask iterativeParentTask) {
             var iterativeTaskMode = iterativeParentTask.mode();
-            switch (iterativeTaskMode) {
-                case DYNAMIC:
-                case FIXED:
-                    taskName = boundedIterationsTaskName(iterativeParentTask, task);
-                    break;
-                case OPEN:
-                    taskName = unboundedIterationsTaskName(iterativeParentTask, task);
-                    break;
-                default:
-                    throw new UnsupportedOperationException(formatWithLocale("Enum value %s is not supported", iterativeTaskMode));
-            }
+
+            taskName = switch (iterativeTaskMode) {
+                case DYNAMIC, FIXED -> boundedIterationsTaskName(iterativeParentTask, task);
+                case OPEN -> unboundedIterationsTaskName(iterativeParentTask, task);
+            };
         } else {
             taskName = taskDescription(task);
         }
@@ -134,17 +138,58 @@ private void log100OnLeafTaskFinish(Task task) {
         task.visit(loggingLeafTaskVisitor);
     }
 
-    private static final class LoggingLeafTaskVisitor implements TaskVisitor {
+    @Override
+    public String getTask() {
+        return batchingProgressLogger.getTask();
+    }
 
-        private final ProgressLogger progressLogger;
+    @Override
+    public void setTask(String task) {
+        batchingProgressLogger.setTask(task);
+    }
 
-        private LoggingLeafTaskVisitor(ProgressLogger progressLogger) {
-            this.progressLogger = progressLogger;
-        }
+    @Override
+    public void logProgress(Supplier<String> msgFactory) {
+        batchingProgressLogger.logProgress(msgFactory);
+    }
 
-        @Override
-        public void visitLeafTask(LeafTask leafTask) {
-            progressLogger.logFinishPercentage();
-        }
+    @Override
+    public void logProgress(long progress, Supplier<String> msgFactory) {
+        batchingProgressLogger.logProgress(progress, msgFactory);
+    }
+
+    @Override
+    public void logMessage(Supplier<String> msg) {
+        batchingProgressLogger.logMessage(msg);
+    }
+
+    @Override
+    public void logFinishPercentage() {
+        batchingProgressLogger.logFinishPercentage();
+    }
+
+    @Override
+    public void logDebug(Supplier<String> msg) {
+        batchingProgressLogger.logDebug(msg);
+    }
+
+    @Override
+    public void logWarning(String msg) {
+        batchingProgressLogger.logWarning(msg);
+    }
+
+    @Override
+    public void logError(String msg) {
+        batchingProgressLogger.logError(msg);
+    }
+
+    @Override
+    public long reset(long newTaskVolume) {
+        return batchingProgressLogger.reset(newTaskVolume);
+    }
+
+    @Override
+    public void release() {
+        batchingProgressLogger.release();
     }
 }

progress-tracking/src/main/java/org/neo4j/gds/core/utils/progress/tasks/TaskProgressTracker.java

@@ -68,7 +68,7 @@ public TaskProgressTracker(
         TaskRegistryFactory taskRegistryFactory,
         UserLogRegistryFactory userLogRegistryFactory
     ) {
-        this(baseTask, jobId, taskRegistryFactory, new TaskProgressLogger(log, jobId, baseTask, concurrency), userLogRegistryFactory);
+        this(baseTask, jobId, taskRegistryFactory, TaskProgressLogger.create(log, jobId, baseTask, concurrency), userLogRegistryFactory);
     }
 
     public TaskProgressTracker(

progress-tracking/src/main/java/org/neo4j/gds/core/utils/progress/tasks/TaskTreeProgressTracker.java

@@ -38,7 +38,7 @@ public TaskTreeProgressTracker(
             baseTask,
             jobId,
             taskRegistryFactory,
-            new TaskProgressLogger(
+            TaskProgressLogger.create(
                 log,
                 jobId,
                 baseTask,

progress-tracking/src/test/java/org/neo4j/gds/core/utils/progress/tasks/TaskProgressLoggerTest.java

@@ -28,18 +28,21 @@
 import static org.assertj.core.api.Assertions.assertThatNoException;
 
 class TaskProgressLoggerTest {
-
     @Test
-    void shouldNotEliminateParentTaskIfCommonPreffix(){
-
+    void shouldNotEliminateParentTaskIfCommonPrefix() {
         var taskA = Tasks.leaf("A");
         var taskAB = Tasks.task("A B", List.of(taskA));
         var task = Tasks.task("T", List.of(taskA));
 
-        var logger =new TaskProgressLogger(LoggerForProgressTracking.noOpLog(), new JobId(),task,new Concurrency(1));
+        var logger = TaskProgressLogger.create(
+            LoggerForProgressTracking.noOpLog(),
+            new JobId(),
+            task,
+            new Concurrency(1)
+        );
 
         assertThatNoException().isThrownBy(
-            ()-> {
+            () -> {
                 logger.startSubTask("T");
                 logger.startSubTask("A B");
                 logger.startSubTask("A ");
@@ -48,7 +51,5 @@ void shouldNotEliminateParentTaskIfCommonPreffix(){
                 logger.finishSubTask("T");
             }
         );
-
     }
-
 }