Apply minor refactoring

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

Author: vnickolov

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

@@ -27,9 +27,7 @@
 import org.neo4j.gds.results.ResultTransformer;
 import org.neo4j.graphdb.RelationshipType;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static org.neo4j.gds.utils.StringFormatting.formatWithLocale;
@@ -77,16 +75,19 @@ private BellmanFordStreamResult mapRoute(
         boolean negativeCycle,
         PathFactoryFacade pathFactoryFacade
     ) {
-        var nodeIds = pathResult.nodeIds();
-        for (int i = 0; i < nodeIds.length; i++) {
-            nodeIds[i] = idMap.toOriginalNodeId(nodeIds[i]);
-        }
         var relationshipType = RelationshipType.withName(formatWithLocale(
             RELATIONSHIP_TYPE_TEMPLATE,
             pathResult.index()
         ));
 
-        var costs = pathResult.costs();
+        var nodeIds = Arrays.stream(pathResult.nodeIds())
+            .map(idMap::toOriginalNodeId)
+            .boxed()
+            .toList();
+
+        var costs = Arrays.stream(pathResult.costs())
+            .boxed()
+            .toList();
 
         var path = pathFactoryFacade.createPath(
             nodeIds,
@@ -100,9 +101,8 @@ private BellmanFordStreamResult mapRoute(
             idMap.toOriginalNodeId(pathResult.sourceNode()),
             idMap.toOriginalNodeId(pathResult.targetNode()),
             pathResult.totalCost(),
-            // 😿
-            Arrays.stream(nodeIds).boxed().collect(Collectors.toCollection(() -> new ArrayList<>(nodeIds.length))),
-            Arrays.stream(costs).boxed().collect(Collectors.toCollection(() -> new ArrayList<>(costs.length))),
+            nodeIds,
+            costs,
             path,
             negativeCycle
         );

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

@@ -26,9 +26,7 @@
 import org.neo4j.gds.results.ResultTransformer;
 import org.neo4j.graphdb.RelationshipType;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static org.neo4j.gds.utils.StringFormatting.formatWithLocale;
@@ -55,24 +53,25 @@ public PathFindingStreamResultTransformer(
     @Override
     public Stream<PathFindingStreamResult> apply(PathFindingResult pathFindingResult) {
 
-        var resultStream = pathFindingResult.mapPaths(pathResult -> mapPath(pathResult,graph,pathFactoryFacade));
+        var resultStream = pathFindingResult.mapPaths(pathResult -> mapPath(pathResult, graph, pathFactoryFacade));
 
         closeableResourceRegistry.register(resultStream);
 
         return resultStream;
     }
 
-    PathFindingStreamResult mapPath(PathResult pathResult, Graph graph, PathFactoryFacade pathFactoryFacade){
-        var nodeIds = pathResult.nodeIds();
-        var costs = pathResult.costs();
+    private PathFindingStreamResult mapPath(PathResult pathResult, Graph graph, PathFactoryFacade pathFactoryFacade) {
+        var nodeIds = Arrays.stream(pathResult.nodeIds())
+            .map(graph::toOriginalNodeId)
+            .boxed()
+            .toList();
+        var costs = Arrays.stream(pathResult.costs())
+            .boxed()
+            .toList();
         var pathIndex = pathResult.index();
 
         var relationshipType = RelationshipType.withName(formatWithLocale(RELATIONSHIP_TYPE_TEMPLATE, pathIndex));
 
-        // convert internal ids to Neo ids
-        for (int i = 0; i < nodeIds.length; i++) {
-            nodeIds[i] = graph.toOriginalNodeId(nodeIds[i]);
-        }
         var path = pathFactoryFacade.createPath(
             nodeIds,
             costs,
@@ -85,13 +84,8 @@ PathFindingStreamResult mapPath(PathResult pathResult, Graph graph, PathFactoryF
             graph.toOriginalNodeId(pathResult.sourceNode()),
             graph.toOriginalNodeId(pathResult.targetNode()),
             pathResult.totalCost(),
-            // 😿
-            Arrays.stream(nodeIds)
-                .boxed()
-                .collect(Collectors.toCollection(() -> new ArrayList<>(nodeIds.length))),
-            Arrays.stream(costs)
-                .boxed()
-                .collect(Collectors.toCollection(() -> new ArrayList<>(costs.length))),
+            nodeIds,
+            costs,
             path
         );
     }

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

@@ -29,9 +29,9 @@
 import java.util.List;
 import java.util.stream.Stream;
 
-public class RandomWalkStreamResultTransformer implements ResultTransformer<Stream<long[]>, Stream<RandomWalkStreamResult>>{
+public class RandomWalkStreamResultTransformer implements ResultTransformer<Stream<long[]>, Stream<RandomWalkStreamResult>> {
 
-    private final static String RELATIONSHIP_TYPE_NAME = "NEXT";
+    private static final String RELATIONSHIP_TYPE_NAME = "NEXT";
     private final Graph graph;
     private final CloseableResourceRegistry closeableResourceRegistry;
     private final PathFactoryFacade pathFactoryFacade;

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

@@ -19,32 +19,27 @@
  */
 package org.neo4j.gds.procedures.algorithms.pathfinding;
 
-import org.neo4j.gds.api.CloseableResourceRegistry;
 import org.neo4j.gds.api.Graph;
 import org.neo4j.gds.collections.ha.HugeLongArray;
 import org.neo4j.gds.results.ResultTransformer;
 import org.neo4j.graphdb.RelationshipType;
 
 import java.util.Arrays;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class TraversalStreamResultTransformer implements ResultTransformer<HugeLongArray, Stream<TraversalStreamResult>> {
 
-    private static String RELATIONSHIP_TYPE = "NEXT";
+    private static final String RELATIONSHIP_TYPE = "NEXT";
     private final Graph graph;
-    private final CloseableResourceRegistry closeableResourceRegistry;
     private final PathFactoryFacade pathFactoryFacade;
     private final long sourceNodeId;
 
     public TraversalStreamResultTransformer(
         Graph graph,
-        CloseableResourceRegistry closeableResourceRegistry,
         PathFactoryFacade pathFactoryFacade,
         long sourceNodeId
     ) {
         this.graph = graph;
-        this.closeableResourceRegistry = closeableResourceRegistry;
         this.pathFactoryFacade = pathFactoryFacade;
         this.sourceNodeId = sourceNodeId;
     }
@@ -53,11 +48,10 @@ public TraversalStreamResultTransformer(
     @Override
     public Stream<TraversalStreamResult> apply(HugeLongArray nodes) {
         var nodesArray = nodes.toArray();
-        var nodeList = Arrays
-            .stream(nodesArray)
-            .boxed()
+        var nodeList = Arrays.stream(nodesArray)
             .map(graph::toOriginalNodeId)
-            .collect(Collectors.toList());
+            .boxed()
+            .toList();
 
         var  path = pathFactoryFacade.createPath(
             nodeList,
@@ -66,9 +60,9 @@ public Stream<TraversalStreamResult> apply(HugeLongArray nodes) {
 
         return Stream.of(
             new TraversalStreamResult(
-            sourceNodeId, // should be node[0]
-            nodeList,
-            path
+                sourceNodeId, // should be node[0]
+                nodeList,
+                path
             )
         );
     }

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

@@ -56,7 +56,6 @@ public TraversalStreamResultTransformer build(Graph graph, GraphStore graphStore
         );
         return new TraversalStreamResultTransformer(
             graph,
-            closeableResourceRegistry,
             pathFactoryFacade,
             sourceNode
         );

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

@@ -60,16 +60,16 @@ void shouldTransformNonEmptyResultWithDistances() {
         );
 
         var topoSort = mock(TopologicalSortResult.class);
-        var  array = HugeAtomicDoubleArray.of(2,ParallelDoublePageCreator.of(new Concurrency(1),  v->  3.0*(1-v)));
+        var array = HugeAtomicDoubleArray.of(4, ParallelDoublePageCreator.of(new Concurrency(1), v -> v + 1.0));
         when(topoSort.maxSourceDistances()).thenReturn(Optional.of(array));
-        when(topoSort.sortedNodes()).thenReturn(HugeLongArray.of(3,0));
+        when(topoSort.sortedNodes()).thenReturn(HugeLongArray.of(3, 0));
         when(graphMock.toOriginalNodeId(anyLong())).thenAnswer(invocation -> invocation.getArgument(0));
 
         var streamResult = transformer.apply(topoSort).toList();
 
         assertThat(streamResult).hasSize(2);
-        assertThat(streamResult.getFirst()).isEqualTo(new TopologicalSortStreamResult(3,10.0));
-        assertThat(streamResult.getLast()).isEqualTo(new TopologicalSortStreamResult(0,7.0));
+        assertThat(streamResult.getFirst()).isEqualTo(new TopologicalSortStreamResult(3, 4.0));
+        assertThat(streamResult.getLast()).isEqualTo(new TopologicalSortStreamResult(0, 1.0));
 
     }
 
@@ -84,14 +84,14 @@ void shouldTransformNonEmptyResultWithoutDistances() {
         var topoSort = mock(TopologicalSortResult.class);
 
 
-        when(topoSort.sortedNodes()).thenReturn(HugeLongArray.of(3,0));
+        when(topoSort.sortedNodes()).thenReturn(HugeLongArray.of(3, 0));
         when(graphMock.toOriginalNodeId(anyLong())).thenAnswer(invocation -> invocation.getArgument(0));
 
         var streamResult = transformer.apply(topoSort).toList();
 
         assertThat(streamResult).hasSize(2);
-        assertThat(streamResult.getFirst()).isEqualTo(new TopologicalSortStreamResult(3,null));
-        assertThat(streamResult.getLast()).isEqualTo(new TopologicalSortStreamResult(0,null));
+        assertThat(streamResult.getFirst()).isEqualTo(new TopologicalSortStreamResult(3, null));
+        assertThat(streamResult.getLast()).isEqualTo(new TopologicalSortStreamResult(0, null));
 
     }
 

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

@@ -20,7 +20,6 @@
 package org.neo4j.gds.procedures.algorithms.pathfinding;
 
 import org.junit.jupiter.api.Test;
-import org.neo4j.gds.api.CloseableResourceRegistry;
 import org.neo4j.gds.api.Graph;
 import org.neo4j.gds.collections.ha.HugeLongArray;
 import org.neo4j.graphdb.Path;
@@ -37,25 +36,25 @@ class TraversalStreamResultTransformerTest {
     @Test
     void shouldTransformNonEmptyResult() {
         var graphMock = mock(Graph.class);
-        var closeableResourceRegistryMock = mock(CloseableResourceRegistry.class);
         var pathFactoryFacadeMock = mock(PathFactoryFacade.class);
 
         var transformer = new TraversalStreamResultTransformer(
             graphMock,
-            closeableResourceRegistryMock,
             pathFactoryFacadeMock,
             10
         );
 
-        when(graphMock.toOriginalNodeId(anyLong())).thenAnswer(invocation -> invocation.getArgument(0));
+        when(graphMock.toOriginalNodeId(anyLong()))
+            // don't return the same original id as the input
+            .thenAnswer(invocation -> ((long) invocation.getArgument(0)) + 19L);
         when(pathFactoryFacadeMock.createPath(any(long[].class), any(double[].class), any(), anyString()))
             .thenReturn(mock(Path.class));
 
         var streamResult = transformer.apply(HugeLongArray.of(3,2,1,0)).toList();
 
         assertThat(streamResult).hasSize(1);
         var result = streamResult.getFirst();
-        assertThat(result.nodeIds()).containsExactly(3L,2L,1L,0L);
+        assertThat(result.nodeIds()).containsExactly(22L, 21L, 20L, 19L);
         assertThat(result.sourceNode()).isEqualTo(10);
     }