feat: add matrix benchmark enums

Author: Hendrik Leuschner

ors-benchmark/src/main/java/org/heigit/ors/benchmark/BenchmarkEnums.java

@@ -73,4 +73,48 @@ public String getValue() {
         }
     }
 
+    /**
+     * Enum representing different matrix modes for benchmarking.
+     * getRequestParams() provides the parameters to trigger each matrix algorithm.
+     */
+    public enum MatrixModes {
+        ALGO_DIJKSTRA_MATRIX,
+        ALGO_CORE_MATRIX,
+        ALGO_RPHAST_MATRIX;
+
+        public static MatrixModes fromString(String value) {
+            return switch (value.toLowerCase()) {
+                case "algodijkstra" -> ALGO_DIJKSTRA_MATRIX;
+                case "algocore" -> ALGO_CORE_MATRIX;
+                case "algorphast" -> ALGO_RPHAST_MATRIX;
+                default -> throw new IllegalArgumentException("Invalid directions mode: " + value);
+            };
+        }
+
+        public List<String> getProfiles() {
+            return switch (this) {
+                case ALGO_DIJKSTRA_MATRIX, ALGO_CORE_MATRIX, ALGO_RPHAST_MATRIX -> List.of("driving-car", "driving-hgv", "cycling-regular", "foot-walking");
+            };
+        }
+        /**
+         * Returns the request parameters for the matrix algorithm.
+         * These parameters are used to trigger the specific matrix algorithm.
+         * This is not great as we have to maintain this in multiple places,
+         * at the moment this is the only way to trigger the algorithms.
+         * What would be better is to have a common interface for the algorithms,
+         * but that would require a larger refactor of the codebase.
+         * @return a map of request parameters
+         */
+        public Map<String, Object> getRequestParams() {
+            return switch (this) {
+                case ALGO_RPHAST_MATRIX -> Map.of(PREFERENCE, RECOMMENDED);
+                case ALGO_CORE_MATRIX -> Map.of(PREFERENCE,
+                        RECOMMENDED, "options", Map.of("dynamic_speeds", "true"));
+                case ALGO_DIJKSTRA_MATRIX -> Map.of(PREFERENCE,
+                        RECOMMENDED, "options", List.of(Map.of("dynamic_speeds", "false"), Map.of("avoid_features", List.of("ferries"))));
+
+            };
+        }
+    }
+
 }

ors-benchmark/src/test/java/org/heigit/ors/benchmark/BenchmarkEnumsTest.java

@@ -52,4 +52,42 @@ void testRangeTypeGetValue() {
         assertEquals("time", BenchmarkEnums.RangeType.TIME.getValue());
         assertEquals("distance", BenchmarkEnums.RangeType.DISTANCE.getValue());
     }
+
+    @Test
+    void testMatrixModesFromString() {
+        assertEquals(BenchmarkEnums.MatrixModes.ALGO_DIJKSTRA_MATRIX, BenchmarkEnums.MatrixModes.fromString("algodijkstra"));
+        assertEquals(BenchmarkEnums.MatrixModes.ALGO_CORE_MATRIX, BenchmarkEnums.MatrixModes.fromString("algocore"));
+        assertEquals(BenchmarkEnums.MatrixModes.ALGO_RPHAST_MATRIX, BenchmarkEnums.MatrixModes.fromString("algorphast"));
+
+        Throwable exception = assertThrows(IllegalArgumentException.class, () -> BenchmarkEnums.MatrixModes.fromString("invalid"));
+        assertTrue(exception instanceof IllegalArgumentException);
+    }
+
+    @Test
+    void testMatrixModesGetDefaultProfiles() {
+        List<String> dijkstraProfiles = BenchmarkEnums.MatrixModes.ALGO_DIJKSTRA_MATRIX.getProfiles();
+        assertTrue(dijkstraProfiles.contains("driving-car"));
+        assertTrue(dijkstraProfiles.contains("foot-walking"));
+        assertEquals(4, dijkstraProfiles.size());
+
+        List<String> coreProfiles = BenchmarkEnums.MatrixModes.ALGO_CORE_MATRIX.getProfiles();
+        assertTrue(coreProfiles.contains("driving-car"));
+        assertTrue(coreProfiles.contains("foot-walking"));
+        assertEquals(4, coreProfiles.size());
+    }
+
+    @Test
+    void testMatrixModesGetRequestParams() {
+        Map<String, Object> rphastParams = BenchmarkEnums.MatrixModes.ALGO_RPHAST_MATRIX.getRequestParams();
+        assertEquals("recommended", rphastParams.get("preference"));
+        assertEquals(1, rphastParams.size());
+
+        Map<String, Object> coreParams = BenchmarkEnums.MatrixModes.ALGO_CORE_MATRIX.getRequestParams();
+        assertEquals("recommended", coreParams.get("preference"));
+        assertTrue(coreParams.get("options") instanceof Map);
+
+        Map<String, Object> dijkstraParams = BenchmarkEnums.MatrixModes.ALGO_DIJKSTRA_MATRIX.getRequestParams();
+        assertEquals("recommended", dijkstraParams.get("preference"));
+        assertTrue(dijkstraParams.get("options") instanceof List);
+    }
 }