routing algo: minor simplification

Author: karussell

core/src/main/java/com/graphhopper/routing/AStarBidirection.java

@@ -85,7 +85,7 @@ protected SPTEntry createStartEntry(int node, double weight, boolean reverse) {
     }
 
     @Override
-    protected SPTEntry createEntry(EdgeIteratorState edge, int incEdge, double weight, SPTEntry parent, boolean reverse) {
+    protected SPTEntry createEntry(EdgeIteratorState edge, double weight, SPTEntry parent, boolean reverse) {
         int neighborNode = edge.getAdjNode();
         double heapWeight = weight + weightApprox.approximate(neighborNode, reverse);
         AStarEntry entry = new AStarEntry(edge.getEdge(), neighborNode, heapWeight, weight);
@@ -94,7 +94,7 @@ protected SPTEntry createEntry(EdgeIteratorState edge, int incEdge, double weigh
     }
 
     @Override
-    protected void updateEntry(SPTEntry entry, EdgeIteratorState edge, int edgeId, double weight, SPTEntry parent, boolean reverse) {
+    protected void updateEntry(SPTEntry entry, EdgeIteratorState edge, double weight, SPTEntry parent, boolean reverse) {
         entry.edge = edge.getEdge();
         entry.weight = weight + weightApprox.approximate(edge.getAdjNode(), reverse);
         ((AStarEntry) entry).weightOfVisitedPath = weight;

core/src/main/java/com/graphhopper/routing/AbstractBidirAlgo.java

@@ -20,6 +20,7 @@
 import com.carrotsearch.hppc.IntObjectMap;
 import com.graphhopper.coll.GHIntObjectHashMap;
 import com.graphhopper.routing.util.TraversalMode;
+import com.graphhopper.util.EdgeIterator;
 
 import java.util.Collections;
 import java.util.List;
@@ -121,7 +122,7 @@ protected void postInit(int from, int to) {
         if (!traversalMode.isEdgeBased()) {
             if (updateBestPath) {
                 bestWeightMapOther = bestWeightMapFrom;
-                updateBestPath(Double.POSITIVE_INFINITY, currFrom, -1, to, true);
+                updateBestPath(Double.POSITIVE_INFINITY, currFrom, EdgeIterator.NO_EDGE, to, true);
             }
         } else if (from == to && fromOutEdge == ANY_EDGE && toInEdge == ANY_EDGE) {
             // special handling if start and end are the same and no directions are restricted
@@ -169,7 +170,7 @@ protected boolean finished() {
 
     abstract boolean fillEdgesTo();
 
-    protected void updateBestPath(double edgeWeight, SPTEntry entry, int origEdgeId, int traversalId, boolean reverse) {
+    protected void updateBestPath(double edgeWeight, SPTEntry entry, int origEdgeIdForCH, int traversalId, boolean reverse) {
         assert traversalMode.isEdgeBased() != Double.isInfinite(edgeWeight);
         SPTEntry entryOther = bestWeightMapOther.get(traversalId);
         if (entryOther == null)

core/src/main/java/com/graphhopper/routing/AbstractNonCHBidirAlgo.java

@@ -71,14 +71,11 @@ public AbstractNonCHBidirAlgo(Graph graph, Weighting weighting, TraversalMode tM
      * expansion.
      *
      * @param edge    the edge that is currently processed for the expansion
-     * @param incEdge the id of the edge that is incoming to the node the edge is pointed at. usually this is the same as
-     *                edge.getEdge(), but for edge-based CH and in case edge is a shortcut incEdge is the original edge
-     *                that is incoming to the node
      * @param weight  the weight the shortest path three entry should carry
      * @param parent  the parent entry of in the shortest path tree
      * @param reverse true if we are currently looking at the backward search, false otherwise
      */
-    protected abstract SPTEntry createEntry(EdgeIteratorState edge, int incEdge, double weight, SPTEntry parent, boolean reverse);
+    protected abstract SPTEntry createEntry(EdgeIteratorState edge, double weight, SPTEntry parent, boolean reverse);
 
     protected BidirPathExtractor createPathExtractor(Graph graph, Weighting weighting) {
         return new BidirPathExtractor(graph, weighting);
@@ -174,16 +171,15 @@ private void fillEdges(SPTEntry currEdge, PriorityQueue<SPTEntry> prioQueue, Int
             if (Double.isInfinite(weight)) {
                 continue;
             }
-            final int origEdgeId = getOrigEdgeId(iter, reverse);
-            final int traversalId = getTraversalId(iter, origEdgeId, reverse);
+            final int traversalId = traversalMode.createTraversalId(iter, reverse);
             SPTEntry entry = bestWeightMap.get(traversalId);
             if (entry == null) {
-                entry = createEntry(iter, origEdgeId, weight, currEdge, reverse);
+                entry = createEntry(iter, weight, currEdge, reverse);
                 bestWeightMap.put(traversalId, entry);
                 prioQueue.add(entry);
             } else if (entry.getWeightOfVisitedPath() > weight) {
                 prioQueue.remove(entry);
-                updateEntry(entry, iter, origEdgeId, weight, currEdge, reverse);
+                updateEntry(entry, iter, weight, currEdge, reverse);
                 prioQueue.add(entry);
             } else
                 continue;
@@ -193,12 +189,12 @@ private void fillEdges(SPTEntry currEdge, PriorityQueue<SPTEntry> prioQueue, Int
                 double edgeWeight = traversalMode.isEdgeBased() ? weighting.calcEdgeWeight(iter, reverse) : Double.POSITIVE_INFINITY;
                 // todo: performance - if bestWeightMapOther.get(traversalId) == null, updateBestPath will exit early and we might
                 // have calculated the edgeWeight unnecessarily
-                updateBestPath(edgeWeight, entry, origEdgeId, traversalId, reverse);
+                updateBestPath(edgeWeight, entry, EdgeIterator.NO_EDGE, traversalId, reverse);
             }
         }
     }
 
-    protected void updateEntry(SPTEntry entry, EdgeIteratorState edge, int edgeId, double weight, SPTEntry parent, boolean reverse) {
+    protected void updateEntry(SPTEntry entry, EdgeIteratorState edge, double weight, SPTEntry parent, boolean reverse) {
         entry.edge = edge.getEdge();
         entry.weight = weight;
         entry.parent = parent;
@@ -208,14 +204,6 @@ protected boolean accept(EdgeIteratorState edge, SPTEntry currEdge, boolean reve
         return accept(edge, getIncomingEdge(currEdge));
     }
 
-    protected int getOrigEdgeId(EdgeIteratorState edge, boolean reverse) {
-        return edge.getEdge();
-    }
-
-    protected int getTraversalId(EdgeIteratorState edge, int origEdgeId, boolean reverse) {
-        return traversalMode.createTraversalId(edge, reverse);
-    }
-
     protected double calcWeight(EdgeIteratorState iter, SPTEntry currEdge, boolean reverse) {
         // todo: for #1835 move access flag checks into weighting
         final boolean access = reverse ? inEdgeFilter.accept(iter) : outEdgeFilter.accept(iter);

core/src/main/java/com/graphhopper/routing/DijkstraBidirectionRef.java

@@ -42,7 +42,7 @@ protected SPTEntry createStartEntry(int node, double weight, boolean reverse) {
     }
 
     @Override
-    protected SPTEntry createEntry(EdgeIteratorState edge, int incEdge, double weight, SPTEntry parent, boolean reverse) {
+    protected SPTEntry createEntry(EdgeIteratorState edge, double weight, SPTEntry parent, boolean reverse) {
         SPTEntry entry = new SPTEntry(edge.getEdge(), edge.getAdjNode(), weight);
         entry.parent = parent;
         return entry;