Implement push-back stats facade

Co-authored-by: Ioannis Panagiotas <ioannis.panagiotas@neo4j.com>

Author: AlfredClemedtson

procedures/pushback-procedures-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/PushbackPathFindingProcedureFacade.java

@@ -271,7 +271,7 @@ public Stream<MaxFlowStreamResult> maxFlowStream(String graphName, Map<String, O
 
     @Override
     public Stream<MaxFlowStatsResult> maxFlowStats(String graphName, Map<String, Object> configuration) {
-        return Stream.empty(); //todo
+        return statsProcedureFacade.maxFlow(graphName, configuration);
     }
 
     @Override

procedures/pushback-procedures-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/stats/MaxFlowStatsResultTransformer.java

@@ -0,0 +1,49 @@
+/*
+ * 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.procedures.algorithms.pathfinding.stats;
+
+import org.neo4j.gds.maxflow.FlowResult;
+import org.neo4j.gds.procedures.algorithms.pathfinding.MaxFlowStatsResult;
+import org.neo4j.gds.result.TimedAlgorithmResult;
+import org.neo4j.gds.results.ResultTransformer;
+
+import java.util.Map;
+import java.util.stream.Stream;
+
+class MaxFlowStatsResultTransformer implements ResultTransformer<TimedAlgorithmResult<FlowResult>, Stream<MaxFlowStatsResult>> {
+
+    private final Map<String, Object> configuration;
+
+    MaxFlowStatsResultTransformer(Map<String, Object> configuration) {
+        this.configuration = configuration;
+    }
+
+    @Override
+    public Stream<MaxFlowStatsResult> apply(TimedAlgorithmResult<FlowResult> algorithmResult) {
+        var spanningTree = algorithmResult.result();
+        var statsResult = new MaxFlowStatsResult(
+            0,
+            algorithmResult.computeMillis(),
+            spanningTree.totalFlow(),
+            configuration
+        );
+        return Stream.of(statsResult);
+    }
+}

procedures/pushback-procedures-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/stats/MaxFlowStatsResultTransformerBuilder.java

@@ -0,0 +1,43 @@
+/*
+ * 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.procedures.algorithms.pathfinding.stats;
+
+import org.neo4j.gds.core.loading.GraphResources;
+import org.neo4j.gds.maxflow.FlowResult;
+import org.neo4j.gds.maxflow.MaxFlowStatsConfig;
+import org.neo4j.gds.procedures.algorithms.pathfinding.MaxFlowStatsResult;
+import org.neo4j.gds.result.TimedAlgorithmResult;
+import org.neo4j.gds.results.ResultTransformerBuilder;
+
+import java.util.stream.Stream;
+
+class MaxFlowStatsResultTransformerBuilder implements ResultTransformerBuilder<TimedAlgorithmResult<FlowResult>, Stream<MaxFlowStatsResult>> {
+
+    private final MaxFlowStatsConfig config;
+
+    MaxFlowStatsResultTransformerBuilder(MaxFlowStatsConfig config) {
+        this.config = config;
+    }
+
+    @Override
+    public MaxFlowStatsResultTransformer build(GraphResources graphResources) {
+        return new MaxFlowStatsResultTransformer(config.toMap());
+    }
+}

procedures/pushback-procedures-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/stats/PushbackPathFindingStatsProcedureFacade.java

@@ -20,13 +20,15 @@
 package org.neo4j.gds.procedures.algorithms.pathfinding.stats;
 
 import org.neo4j.gds.api.GraphName;
+import org.neo4j.gds.maxflow.MaxFlowStatsConfig;
 import org.neo4j.gds.pathfinding.PathFindingComputeBusinessFacade;
 import org.neo4j.gds.paths.bellmanford.AllShortestPathsBellmanFordStatsConfig;
 import org.neo4j.gds.paths.delta.config.AllShortestPathsDeltaStatsConfig;
 import org.neo4j.gds.paths.traverse.BfsStatsConfig;
 import org.neo4j.gds.pcst.PCSTStatsConfig;
 import org.neo4j.gds.procedures.algorithms.configuration.UserSpecificConfigurationParser;
 import org.neo4j.gds.procedures.algorithms.pathfinding.BellmanFordStatsResult;
+import org.neo4j.gds.procedures.algorithms.pathfinding.MaxFlowStatsResult;
 import org.neo4j.gds.procedures.algorithms.pathfinding.PrizeCollectingSteinerTreeStatsResult;
 import org.neo4j.gds.procedures.algorithms.pathfinding.SpanningTreeStatsResult;
 import org.neo4j.gds.procedures.algorithms.pathfinding.SteinerStatsResult;
@@ -109,6 +111,23 @@ public Stream<StandardStatsResult> deltaStepping(
         ).join();
     }
 
+    public Stream<MaxFlowStatsResult> maxFlow(String graphName, Map<String, Object> configuration) {
+        var config = configurationParser.parseConfiguration(
+            configuration,
+            MaxFlowStatsConfig::of
+        );
+
+        return businessFacade.maxFlow(
+            GraphName.parse(graphName),
+            config.toGraphParameters(),
+            config.relationshipWeightProperty(),
+            config.toParameters(),
+            config.jobId(),
+            config.logProgress(),
+            new MaxFlowStatsResultTransformerBuilder(config)
+        ).join();
+    }
+
     public Stream<PrizeCollectingSteinerTreeStatsResult> prizeCollectingSteinerTree(
         String graphName,
         Map<String, Object> configuration

procedures/pushback-procedures-facade/src/test/java/org/neo4j/gds/procedures/algorithms/pathfinding/PushbackPathFindingProcedureFacadeTest.java

@@ -172,6 +172,13 @@ void deltaSteppingStats() {
             verifyNoInteractions(mutateFacadeMock, streamFacadeMock, writeFacadeMock);
         }
 
+        @Test
+        void maxFlowStats() {
+            facade.maxFlowStats(graphName, config);
+            verify(statsFacadeMock).maxFlow(graphName, config);
+            verifyNoInteractions(mutateFacadeMock, streamFacadeMock, writeFacadeMock);
+        }
+
         @Test
         void prizeCollectingSteinerTreeStats() {
             facade.prizeCollectingSteinerTreeStats(graphName, config);

procedures/pushback-procedures-facade/src/test/java/org/neo4j/gds/procedures/algorithms/pathfinding/stats/MaxFlowStatsResultTransformerTest.java

@@ -0,0 +1,66 @@
+/*
+ * 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.procedures.algorithms.pathfinding.stats;
+
+import org.junit.jupiter.api.Test;
+import org.neo4j.gds.api.Graph;
+import org.neo4j.gds.maxflow.FlowResult;
+import org.neo4j.gds.result.TimedAlgorithmResult;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class MaxFlowStatsResultTransformerTest {
+    @Test
+    void shouldReturnEmptyStreamOnEmptyResult() {
+        var configuration = Map.<String, Object>of("foo", "bar");
+        var graphMock = mock(Graph.class);
+        when(graphMock.nodeCount()).thenReturn(0L);
+
+        var transformer = new MaxFlowStatsResultTransformer(configuration);
+
+        var statsResult = transformer.apply(TimedAlgorithmResult.empty(FlowResult.EMPTY)).findFirst().orElseThrow();
+        assertThat(statsResult.preProcessingMillis()).isZero();
+        assertThat(statsResult.computeMillis()).isZero();
+        assertThat(statsResult.totalFlow()).isZero();
+        assertThat(statsResult.configuration()).isEqualTo(configuration);
+    }
+
+    @Test
+    void shouldTransformNonEmptyResult() {
+        var configuration = Map.<String, Object>of("foo", "bar");
+        var graphMock = mock(Graph.class);
+        when(graphMock.toOriginalNodeId(anyLong())).thenAnswer(invocation -> invocation.getArgument(0));
+
+        var transformer = new MaxFlowStatsResultTransformer(configuration);
+
+        var flowResult = new FlowResult(null, 4D);
+
+        var statsResult = transformer.apply(new TimedAlgorithmResult<>(flowResult, 1L)).findFirst().orElseThrow();
+        assertThat(statsResult.preProcessingMillis()).isZero();
+        assertThat(statsResult.computeMillis()).isEqualTo(1L);
+        assertThat(statsResult.totalFlow()).isEqualTo(4D);
+        assertThat(statsResult.configuration()).isEqualTo(configuration);
+    }
+}