Adds new fail-fast option to hand-crafted matrix client. (graphhopper#1661)

Author: easbar

api/src/main/java/com/graphhopper/util/exceptions/DetailedIllegalArgumentException.java

@@ -24,8 +24,8 @@ public class DetailedIllegalArgumentException extends IllegalArgumentException i
 
     private final Map<String, Object> details;
 
-    public DetailedIllegalArgumentException(String var1, Map<String, Object> details) {
-        super(var1);
+    public DetailedIllegalArgumentException(String message, Map<String, Object> details) {
+        super(message);
         this.details = details;
     }
 

client-hc/src/main/java/com/graphhopper/api/GHMRequest.java

@@ -1,5 +1,6 @@
 package com.graphhopper.api;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.graphhopper.GHRequest;
 import com.graphhopper.util.shapes.GHPoint;
 
@@ -17,8 +18,10 @@ public class GHMRequest extends GHRequest {
     private List<GHPoint> toPoints;
     private List<String> fromPointHints;
     private List<String> toPointHints;
+    private int called = 0;
     boolean identicalLists = true;
     private final Set<String> outArrays = new HashSet<>(5);
+    private boolean failFast = true;
 
     public GHMRequest() {
         this(10);
@@ -146,7 +149,17 @@ public boolean hasPointHints() {
                 this.toPointHints.size() == this.toPoints.size() && !toPoints.isEmpty();
     }
 
-    private int called = 0;
+    /**
+     * @param failFast if false the matrix calculation will be continued even when some points are not connected
+     */
+    @JsonProperty("fail_fast")
+    public void setFailFast(boolean failFast) {
+        this.failFast = failFast;
+    }
+
+    public boolean getFailFast() {
+        return failFast;
+    }
 
     /**
      * This method makes it more likely that hasPointHints returns true as often point hints are added although the

client-hc/src/main/java/com/graphhopper/api/GHMatrixAbstractRequester.java

@@ -20,7 +20,6 @@
  */
 public abstract class GHMatrixAbstractRequester {
 
-    private GraphHopperWeb web = new GraphHopperWeb();
     protected final ObjectMapper objectMapper;
     protected final Set<String> ignoreSet = new HashSet<>(10);
     protected final String serviceUrl;
@@ -101,11 +100,18 @@ public List<Throwable> readUsableEntityError(List<String> outArraysList, JsonNod
         }
     }
 
-    public void fillResponseFromJson(MatrixResponse matrixResponse, String responseAsString) throws IOException {
-        fillResponseFromJson(matrixResponse, objectMapper.reader().readTree(responseAsString));
+    public void fillResponseFromJson(MatrixResponse matrixResponse, String responseAsString, boolean failFast) throws IOException {
+        fillResponseFromJson(matrixResponse, objectMapper.reader().readTree(responseAsString), failFast);
     }
 
-    protected void fillResponseFromJson(MatrixResponse matrixResponse, JsonNode solution) {
+    /**
+     * @param failFast If false weights/distances/times that are null are interpreted as disconnected points and are
+     *                 thus set to their respective maximum values. Furthermore, the indices of the disconnected points
+     *                 are added to {@link MatrixResponse#getDisconnectedPoints()} and the indices of the points that
+     *                 could not be found are added to {@link MatrixResponse#getInvalidFromPoints()} and/or
+     *                 {@link MatrixResponse#getInvalidToPoints()}.
+     */
+    protected void fillResponseFromJson(MatrixResponse matrixResponse, JsonNode solution, boolean failFast) {
         final boolean readWeights = solution.has("weights");
         final boolean readDistances = solution.has("distances");
         final boolean readTimes = solution.has("times");
@@ -155,15 +161,27 @@ protected void fillResponseFromJson(MatrixResponse matrixResponse, JsonNode solu
 
             for (int toIndex = 0; toIndex < toCount; toIndex++) {
                 if (readWeights) {
-                    weights[toIndex] = weightsFromArray.get(toIndex).asDouble();
+                    if (weightsFromArray.get(toIndex).isNull() && !failFast) {
+                        weights[toIndex] = Double.MAX_VALUE;
+                    } else {
+                        weights[toIndex] = weightsFromArray.get(toIndex).asDouble();
+                    }
                 }
 
                 if (readTimes) {
-                    times[toIndex] = timesFromArray.get(toIndex).asLong() * 1000;
+                    if (timesFromArray.get(toIndex).isNull() && !failFast) {
+                        times[toIndex] = Long.MAX_VALUE;
+                    } else {
+                        times[toIndex] = timesFromArray.get(toIndex).asLong() * 1000;
+                    }
                 }
 
                 if (readDistances) {
-                    distances[toIndex] = (int) Math.round(distancesFromArray.get(toIndex).asDouble());
+                    if (distancesFromArray.get(toIndex).isNull() && !failFast) {
+                        distances[toIndex] = Integer.MAX_VALUE;
+                    } else {
+                        distances[toIndex] = (int) Math.round(distancesFromArray.get(toIndex).asDouble());
+                    }
                 }
             }
 
@@ -179,6 +197,43 @@ protected void fillResponseFromJson(MatrixResponse matrixResponse, JsonNode solu
                 matrixResponse.setDistanceRow(fromIndex, distances);
             }
         }
+        if (!failFast && solution.has("hints")) {
+            addProblems(matrixResponse, solution.get("hints"));
+        }
+    }
+
+    private void addProblems(MatrixResponse matrixResponse, JsonNode hints) {
+        for (JsonNode hint : hints) {
+            if (hint.has("point_pairs")) {
+                matrixResponse.setDisconnectedPoints(readDisconnectedPoints(hint.get("point_pairs")));
+            }
+            if (hint.has("invalid_from_points")) {
+                matrixResponse.setInvalidFromPoints(readInvalidPoints(hint.get("invalid_from_points")));
+                matrixResponse.setInvalidToPoints(readInvalidPoints(hint.get("invalid_to_points")));
+            }
+        }
+    }
+
+    private List<MatrixResponse.PointPair> readDisconnectedPoints(JsonNode pointPairsArray) {
+        List<MatrixResponse.PointPair> disconnectedPoints = new ArrayList<>(pointPairsArray.size());
+        for (int i = 0; i < pointPairsArray.size(); i++) {
+            if (pointPairsArray.get(i).size() != 2) {
+                throw new IllegalArgumentException("all point_pairs are expected to contain two elements");
+            }
+            disconnectedPoints.add(new MatrixResponse.PointPair(
+                    pointPairsArray.get(i).get(0).asInt(),
+                    pointPairsArray.get(i).get(1).asInt()
+            ));
+        }
+        return disconnectedPoints;
+    }
+
+    private List<Integer> readInvalidPoints(JsonNode pointsArray) {
+        List<Integer> result = new ArrayList<>(pointsArray.size());
+        for (int i = 0; i < pointsArray.size(); i++) {
+            result.add(pointsArray.get(i).asInt());
+        }
+        return result;
     }
 
     private static int checkArraySizes(String msg, int len, JsonNode... arrays) {

client-hc/src/main/java/com/graphhopper/api/GHMatrixBatchRequester.java

@@ -83,6 +83,7 @@ public MatrixResponse route(GHMRequest ghRequest) {
         requestJson.putArray("out_arrays").addAll(outArrayListJson);
         requestJson.put("vehicle", ghRequest.getVehicle());
         requestJson.put("elevation", hasElevation);
+        requestJson.put("fail_fast", ghRequest.getFailFast());
 
         Map<String, String> hintsMap = ghRequest.getHints().toMap();
         for (String hintKey : hintsMap.keySet()) {
@@ -154,7 +155,7 @@ public MatrixResponse route(GHMRequest ghRequest) {
                     JsonNode solution = getResponseJson.get("solution");
                     matrixResponse.addErrors(readUsableEntityError(outArraysList, solution));
                     if (!matrixResponse.hasErrors())
-                        fillResponseFromJson(matrixResponse, solution);
+                        fillResponseFromJson(matrixResponse, solution, ghRequest.getFailFast());
 
                     break;
                 }

client-hc/src/main/java/com/graphhopper/api/GHMatrixSyncRequester.java

@@ -91,6 +91,7 @@ public MatrixResponse route(GHMRequest ghRequest) {
         if (!Helper.isEmpty(ghRequest.getVehicle())) {
             url += "&vehicle=" + ghRequest.getVehicle();
         }
+        url += "&fail_fast=" + ghRequest.getFailFast();
 
         boolean withTimes = outArraysList.contains("times");
         boolean withDistances = outArraysList.contains("distances");
@@ -109,7 +110,7 @@ public MatrixResponse route(GHMRequest ghRequest) {
             }
 
             if (!matrixResponse.hasErrors())
-                fillResponseFromJson(matrixResponse, getResponseJson);
+                fillResponseFromJson(matrixResponse, getResponseJson, ghRequest.getFailFast());
 
         } catch (IOException ex) {
             throw new RuntimeException(ex);

client-hc/src/main/java/com/graphhopper/api/MatrixResponse.java

@@ -3,6 +3,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * This class defines the response for a M-to-N requests.
@@ -13,6 +14,9 @@ public class MatrixResponse {
 
     private String debugInfo = "";
     private final List<Throwable> errors = new ArrayList<>(4);
+    private final List<PointPair> disconnectedPoints = new ArrayList<>(0);
+    private final List<Integer> invalidFromPoints = new ArrayList<>(0);
+    private final List<Integer> invalidToPoints = new ArrayList<>(0);
     private long[][] times = new long[0][];
     private int[][] distances = new int[0][];
     private double[][] weights = new double[0][];
@@ -45,7 +49,7 @@ public MatrixResponse(int fromCap, int toCap, boolean withTimes, boolean withDis
             throw new IllegalArgumentException("Please specify times, distances or weights that should be calculated by the matrix");
     }
 
-    public void setFromRow(int row, long timeRow[], int distanceRow[], double weightRow[]) {
+    public void setFromRow(int row, long[] timeRow, int[] distanceRow, double[] weightRow) {
         if (times.length > 0) {
             check(timeRow.length, toCount, "to times");
             times[row] = timeRow;
@@ -68,7 +72,7 @@ private void check(int currentLength, int expectedLength, String times) {
                     "Expected " + expectedLength + " was: " + currentLength + ". Matrix: " + fromCount + "x" + toCount);
     }
 
-    public void setTimeRow(int row, long timeRow[]) {
+    public void setTimeRow(int row, long[] timeRow) {
         if (times.length > 0) {
             check(timeRow.length, toCount, "to times");
             times[row] = timeRow;
@@ -77,7 +81,7 @@ public void setTimeRow(int row, long timeRow[]) {
         }
     }
 
-    public void setDistanceRow(int row, int distanceRow[]) {
+    public void setDistanceRow(int row, int[] distanceRow) {
         if (distances.length > 0) {
             check(distanceRow.length, toCount, "to distances");
             distances[row] = distanceRow;
@@ -86,7 +90,7 @@ public void setDistanceRow(int row, int distanceRow[]) {
         }
     }
 
-    public void setWeightRow(int row, double weightRow[]) {
+    public void setWeightRow(int row, double[] weightRow) {
         if (weights.length > 0) {
             check(weightRow.length, toCount, "to weights");
             weights[row] = weightRow;
@@ -95,12 +99,20 @@ public void setWeightRow(int row, double weightRow[]) {
         }
     }
 
+    public boolean isConnected(int from, int to) {
+        if (hasErrors()) {
+            return false;
+        }
+        return getWeight(from, to) < Double.MAX_VALUE;
+    }
+
     /**
-     * Returns the time for the specific entry (from -&gt; to) in milliseconds.
+     * Returns the time for the specific entry (from -&gt; to) in milliseconds or {@link Long#MAX_VALUE} in case
+     * no connection was found (and {@link GHMRequest#setFailFast(boolean)} was set to true).
      */
     public long getTime(int from, int to) {
         if (hasErrors()) {
-            throw new IllegalStateException("Cannot return time (" + from + "," + to + ") if errors occured " + getErrors());
+            throw new IllegalStateException("Cannot return time (" + from + "," + to + ") if errors occurred " + getErrors());
         }
 
         if (from >= times.length) {
@@ -112,7 +124,8 @@ public long getTime(int from, int to) {
     }
 
     /**
-     * Returns the distance for the specific entry (from -&gt; to) in meter.
+     * Returns the distance for the specific entry (from -&gt; to) in meter or {@link Double#MAX_VALUE} in case
+     * no connection was found (and {@link GHMRequest#setFailFast(boolean)} was set to true).
      */
     public double getDistance(int from, int to) {
         if (hasErrors()) {
@@ -124,12 +137,13 @@ public double getDistance(int from, int to) {
         } else if (to >= distances[from].length) {
             throw new IllegalStateException("Cannot get 'to' " + to + " from distances with size " + distances[from].length);
         }
-        return distances[from][to];
+        return distances[from][to] == Integer.MAX_VALUE ? Double.MAX_VALUE : distances[from][to];
     }
 
     /**
-     * Returns the weight for the specific entry (from -&gt; to) in arbitrary units
-     * ('costs').
+     * Returns the weight for the specific entry (from -&gt; to) in arbitrary units ('costs'), or
+     * {@link Double#MAX_VALUE} in case no connection was found (and {@link GHMRequest#setFailFast(boolean)} was set
+     * to true).
      */
     public double getWeight(int from, int to) {
         if (hasErrors()) {
@@ -176,6 +190,44 @@ public MatrixResponse addErrors(Collection<Throwable> errorList) {
         return this;
     }
 
+    /**
+     * @return true if there are invalid or disconnected points (which both do not yield an error in case we do not fail fast).
+     * @see GHMRequest#setFailFast(boolean)
+     */
+    public boolean hasProblems() {
+        return !disconnectedPoints.isEmpty() || !invalidFromPoints.isEmpty() || !invalidToPoints.isEmpty();
+    }
+
+    public MatrixResponse setDisconnectedPoints(List<PointPair> disconnectedPoints) {
+        this.disconnectedPoints.clear();
+        this.disconnectedPoints.addAll(disconnectedPoints);
+        return this;
+    }
+
+    public List<PointPair> getDisconnectedPoints() {
+        return disconnectedPoints;
+    }
+
+    public MatrixResponse setInvalidFromPoints(List<Integer> invalidFromPoints) {
+        this.invalidFromPoints.clear();
+        this.invalidFromPoints.addAll(invalidFromPoints);
+        return this;
+    }
+
+    public MatrixResponse setInvalidToPoints(List<Integer> invalidToPoints) {
+        this.invalidToPoints.clear();
+        this.invalidToPoints.addAll(invalidToPoints);
+        return this;
+    }
+
+    public List<Integer> getInvalidFromPoints() {
+        return invalidFromPoints;
+    }
+
+    public List<Integer> getInvalidToPoints() {
+        return invalidToPoints;
+    }
+
     @Override
     public String toString() {
         String addInfo = "";
@@ -188,6 +240,45 @@ public String toString() {
             addInfo += ", distances: " + distances.length + "x" + distances[0].length;
         }
 
-        return "[" + addInfo + "] errors:" + errors.toString();
+        String result = "[" + addInfo + "] errors:" + errors.toString();
+        if (!disconnectedPoints.isEmpty()) {
+            result += ", disconnectedPoints: " + disconnectedPoints.size();
+        }
+        if (!invalidFromPoints.isEmpty()) {
+            result += ", invalidFromPoints: " + invalidFromPoints.size();
+        }
+        if (!invalidToPoints.isEmpty()) {
+            result += ", invalidToPoints: " + invalidToPoints.size();
+        }
+        return result;
+    }
+
+    public static class PointPair {
+        public final int sourceIndex;
+        public final int targetIndex;
+
+        public PointPair(int sourceIndex, int targetIndex) {
+            this.sourceIndex = sourceIndex;
+            this.targetIndex = targetIndex;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            PointPair pointPair = (PointPair) o;
+            return sourceIndex == pointPair.sourceIndex &&
+                    targetIndex == pointPair.targetIndex;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(sourceIndex, targetIndex);
+        }
+
+        @Override
+        public String toString() {
+            return "[" + sourceIndex + ", " + targetIndex + "]";
+        }
     }
 }