move relation and turn relation parsing out of FlagEncoder (graphhopper#1775)

* move relation handling out of FlagEncoder and made core green

* made all green

* do not remove module permanently

* remove more code in HikeFlagEncoder

* use Helper.toLowerCase

* reduce code for Car4WDFlagEncoder

* minor improvements

* made tests passing in GH core

* all tests pass

* moved code from OSMReader into OSMTurnCostParser

* less clutter in TurnCostParser interface

* minor renaming

* remove method

* fix bug for ways with multiple relations; removed Route.java

* merged master

* clean up

* move turn cost flags creation into new TurnCost class; fixed some TODO NOWs

* Fix merge issue

* deleted TurnCostAccess

* fixed merge conflicts

* renamed TurnCostExtension to TurnCostStorage

* remove TCEntry.flags

* refactor method signature for similarity with TagParser interface

* delay decision into TurnWeighting refactoring

* More add/set turn cost renaming

* Cleanup in tests, fix signature in ShortcutUnpackerTest

* Put back setRandomCostOrRestriction

* Fix test

* include comment regarding u-turn again

* Minor comments, change field name

* get rid of TCEntry

Author: karussell

api/src/main/java/com/graphhopper/util/Helper.java

@@ -84,7 +84,7 @@ public static int countBitValue(int maxTurnCosts) {
             maxTurnCosts >>= 1;
             counter++;
         }
-        return counter++;
+        return counter;
     }
 
     public static void saveProperties(Map<String, String> map, Writer tmpWriter) throws IOException {

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

@@ -42,9 +42,9 @@
 public class Path {
     protected Graph graph;
     protected double distance;
-    protected boolean reverseOrder = true;
     protected long time;
     protected int endNode = -1;
+    private boolean reverseOrder = true;
     private List<String> description;
     private boolean found;
     private int fromNode = -1;

core/src/main/java/com/graphhopper/routing/profiles/DefaultEncodedValueFactory.java

@@ -17,6 +17,7 @@
  */
 package com.graphhopper.routing.profiles;
 
+import com.graphhopper.routing.util.EncodingManager;
 import com.graphhopper.util.Helper;
 
 public class DefaultEncodedValueFactory implements EncodedValueFactory {
@@ -59,6 +60,8 @@ public EncodedValue create(String string) {
             enc = new EnumEncodedValue<>(Toll.KEY, Toll.class);
         } else if (TrackType.KEY.equals(name)) {
             enc = new EnumEncodedValue<>(TrackType.KEY, TrackType.class);
+        } else if (name.endsWith(EncodingManager.getKey("", RouteNetwork.EV_SUFFIX))) {
+            enc = new EnumEncodedValue<>(EncodingManager.getKey(name, RouteNetwork.EV_SUFFIX), RouteNetwork.class);
         } else if (Hazmat.KEY.equals(name)) {
             enc = new EnumEncodedValue<>(Hazmat.KEY, Hazmat.class);
         } else if (HazmatTunnel.KEY.equals(name)) {

core/src/main/java/com/graphhopper/routing/profiles/RouteNetwork.java

@@ -0,0 +1,52 @@
+/*
+ *  Licensed to GraphHopper GmbH under one or more contributor
+ *  license agreements. See the NOTICE file distributed with this work for
+ *  additional information regarding copyright ownership.
+ *
+ *  GraphHopper GmbH licenses this file to you under the Apache License,
+ *  Version 2.0 (the "License"); you may not use this file except in
+ *  compliance with the License. You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package com.graphhopper.routing.profiles;
+
+import com.graphhopper.util.Helper;
+
+public enum RouteNetwork {
+
+    OTHER("other"), INTERNATIONAL("international"), NATIONAL("national"), REGIONAL("regional"),
+    LOCAL("local");
+
+    /**
+     * You need to call EncodingManager.getKey(prefix, EV_SUFFIX) as this EncodedValue can be used for e.g. bike and hike
+     */
+    public static final String EV_SUFFIX = "network";
+
+    private final String name;
+
+    RouteNetwork(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+    public static RouteNetwork find(String name) {
+        if (name == null)
+            return OTHER;
+        try {
+            return RouteNetwork.valueOf(Helper.toUpperCase(name));
+        } catch (IllegalArgumentException ex) {
+            return OTHER;
+        }
+    }
+}

core/src/main/java/com/graphhopper/routing/profiles/TurnCost.java

@@ -0,0 +1,25 @@
+package com.graphhopper.routing.profiles;
+
+import com.graphhopper.storage.IntsRef;
+import com.graphhopper.util.Helper;
+
+import static com.graphhopper.routing.util.EncodingManager.getKey;
+
+public class TurnCost {
+    /**
+     * You need to call EncodingManager.getKey(prefix, EV_SUFFIX) as this EncodedValue can be used for e.g. car and bike
+     */
+    public final static String EV_SUFFIX = "turn_cost";
+
+    /**
+     * This creates an EncodedValue specifically for the turn costs
+     */
+    public static DecimalEncodedValue create(String name, int maxTurnCosts) {
+        int turnBits = Helper.countBitValue(maxTurnCosts);
+        return new UnsignedDecimalEncodedValue(getKey(name, EV_SUFFIX), turnBits, 1, 0, false, true);
+    }
+
+    public static IntsRef createFlags() {
+        return new IntsRef(1);
+    }
+}

core/src/main/java/com/graphhopper/routing/profiles/UnsignedDecimalEncodedValue.java

@@ -24,8 +24,9 @@
  * of bits.
  */
 public final class UnsignedDecimalEncodedValue extends UnsignedIntEncodedValue implements DecimalEncodedValue {
-    private final double factor;
+    protected final double factor;
     private final double defaultValue;
+    private final boolean useMaximumAsInfinity;
 
     public UnsignedDecimalEncodedValue(String name, int bits, double factor, boolean storeTwoDirections) {
         this(name, bits, factor, 0, storeTwoDirections);
@@ -39,9 +40,16 @@ public UnsignedDecimalEncodedValue(String name, int bits, double factor, boolean
      * @param storeTwoDirections true if forward and backward direction of the edge should get two independent values.
      */
     public UnsignedDecimalEncodedValue(String name, int bits, double factor, double defaultValue, boolean storeTwoDirections) {
+        this(name, bits, factor, defaultValue, storeTwoDirections, false);
+    }
+
+    public UnsignedDecimalEncodedValue(String name, int bits, double factor, double defaultValue, boolean storeTwoDirections, boolean useMaximumAsInfinity) {
         super(name, bits, storeTwoDirections);
         this.factor = factor;
         this.defaultValue = defaultValue;
+        this.useMaximumAsInfinity = useMaximumAsInfinity;
+        if (useMaximumAsInfinity && Double.isInfinite(defaultValue))
+            throw new IllegalArgumentException("Default value and maximum value cannot be both infinity");
     }
 
     private int toInt(double val) {
@@ -52,6 +60,10 @@ private int toInt(double val) {
     public final void setDecimal(boolean reverse, IntsRef ints, double value) {
         if (!isInitialized())
             throw new IllegalStateException("Call init before usage for EncodedValue " + toString());
+        if (useMaximumAsInfinity && Double.isInfinite(value)) {
+            super.setInt(reverse, ints, maxValue);
+            return;
+        }
         if (value == defaultValue)
             value = 0;
         if (value > maxValue * factor)
@@ -67,6 +79,8 @@ public final void setDecimal(boolean reverse, IntsRef ints, double value) {
     @Override
     public final double getDecimal(boolean reverse, IntsRef ref) {
         int value = getInt(reverse, ref);
+        if (useMaximumAsInfinity && value == maxValue)
+            return Double.POSITIVE_INFINITY;
         if (value == 0)
             return defaultValue;
         return value * factor;

core/src/main/java/com/graphhopper/routing/querygraph/QueryGraphTurnExt.java

@@ -20,6 +20,7 @@
 
 import com.carrotsearch.hppc.IntArrayList;
 import com.graphhopper.storage.Graph;
+import com.graphhopper.storage.IntsRef;
 import com.graphhopper.storage.TurnCostStorage;
 
 /**
@@ -40,19 +41,19 @@ class QueryGraphTurnExt extends TurnCostStorage {
     }
 
     @Override
-    public long getTurnCostFlags(int edgeFrom, int nodeVia, int edgeTo) {
-        if (isVirtualNode(nodeVia)) {
-            return 0;
-        } else if (isVirtualEdge(edgeFrom) || isVirtualEdge(edgeTo)) {
-            if (isVirtualEdge(edgeFrom)) {
-                edgeFrom = getOriginalEdge(edgeFrom);
+    public IntsRef readFlags(IntsRef tcFlags, int fromEdge, int viaNode, int toEdge) {
+        if (isVirtualNode(viaNode)) {
+            return tcFlags;
+        } else if (isVirtualEdge(fromEdge) || isVirtualEdge(toEdge)) {
+            if (isVirtualEdge(fromEdge)) {
+                fromEdge = getOriginalEdge(fromEdge);
             }
-            if (isVirtualEdge(edgeTo)) {
-                edgeTo = getOriginalEdge(edgeTo);
+            if (isVirtualEdge(toEdge)) {
+                toEdge = getOriginalEdge(toEdge);
             }
-            return mainTurnCostStorage.getTurnCostFlags(edgeFrom, nodeVia, edgeTo);
+            return mainTurnCostStorage.readFlags(tcFlags, fromEdge, viaNode, toEdge);
         } else {
-            return mainTurnCostStorage.getTurnCostFlags(edgeFrom, nodeVia, edgeTo);
+            return mainTurnCostStorage.readFlags(tcFlags, fromEdge, viaNode, toEdge);
         }
     }
 

core/src/main/java/com/graphhopper/routing/util/AbstractFlagEncoder.java

@@ -17,7 +17,10 @@
  */
 package com.graphhopper.routing.util;
 
-import com.graphhopper.reader.*;
+import com.graphhopper.reader.ConditionalTagInspector;
+import com.graphhopper.reader.OSMTurnRelation;
+import com.graphhopper.reader.ReaderNode;
+import com.graphhopper.reader.ReaderWay;
 import com.graphhopper.reader.osm.conditional.ConditionalOSMTagInspector;
 import com.graphhopper.reader.osm.conditional.DateRangeParser;
 import com.graphhopper.routing.profiles.*;
@@ -66,8 +69,6 @@ public abstract class AbstractFlagEncoder implements FlagEncoder {
     /* Edge Flag Encoder fields */
     private long nodeBitMask;
     private long relBitMask;
-    private EncodedValueOld turnCostEncoder;
-    private long turnRestrictionBit;
     private boolean blockByDefault = true;
     private boolean blockFords = true;
     private boolean registered;
@@ -169,24 +170,15 @@ public void createEncodedValues(List<EncodedValue> registerNewEncodedValue, Stri
     }
 
     /**
-     * Defines the bits which are used for relation flags.
-     *
-     * @return incremented shift value pointing behind the last used bit
+     * Analyze properties of a way and create the edge flags. This method is called in the second
+     * parsing step.
      */
-    public int defineRelationBits(int index, int shift) {
-        return shift;
-    }
+    public abstract IntsRef handleWayTags(IntsRef edgeFlags, ReaderWay way, EncodingManager.Access access);
 
-    public boolean acceptsTurnRelation(OSMTurnRelation relation) {
-        return true;
+    public int getMaxTurnCosts() {
+        return maxTurnCosts;
     }
 
-    /**
-     * Analyze the properties of a relation and create the routing flags for the second read step.
-     * In the pre-parsing step this method will be called to determine the useful relation tags.
-     */
-    public abstract long handleRelationTags(long oldRelation, ReaderRelation relation);
-
     /**
      * Decide whether a way is routable for a given mode of travel. This skips some ways before
      * handleWayTags is called.
@@ -195,16 +187,6 @@ public boolean acceptsTurnRelation(OSMTurnRelation relation) {
      */
     public abstract EncodingManager.Access getAccess(ReaderWay way);
 
-    /**
-     * Analyze properties of a way and create the edge flags. This method is called in the second
-     * parsing step.
-     */
-    public abstract IntsRef handleWayTags(IntsRef edgeFlags, ReaderWay way, EncodingManager.Access access, long relationFlags);
-
-    public IntsRef handleWayTags(IntsRef edgeFlags, ReaderWay way, EncodingManager.Access access) {
-        return handleWayTags(edgeFlags, way, access, 0);
-    }
-
     /**
      * Parse tags on nodes. Node tags can add to speed (like traffic_signals) where the value is
      * strict negative or blocks access (like a barrier), then the value is strictly positive. This
@@ -422,15 +404,6 @@ protected double getFerrySpeed(ReaderWay way) {
         }
     }
 
-    void setRelBitMask(int usedBits, int shift) {
-        relBitMask = (1L << usedBits) - 1;
-        relBitMask <<= shift;
-    }
-
-    long getRelBitMask() {
-        return relBitMask;
-    }
-
     void setNodeBitMask(int usedBits, int shift) {
         nodeBitMask = (1L << usedBits) - 1;
         nodeBitMask <<= shift;
@@ -440,89 +413,6 @@ long getNodeBitMask() {
         return nodeBitMask;
     }
 
-    /**
-     * Defines the bits reserved for storing turn restriction and turn cost
-     * <p>
-     *
-     * @param shift bit offset for the first bit used by this encoder
-     * @return incremented shift value pointing behind the last used bit
-     */
-    public int defineTurnBits(int index, int shift) {
-        if (maxTurnCosts == 0)
-            return shift;
-
-            // optimization for turn restrictions only
-        else if (maxTurnCosts == 1) {
-            turnRestrictionBit = 1L << shift;
-            return shift + 1;
-        }
-
-        int turnBits = Helper.countBitValue(maxTurnCosts);
-        turnCostEncoder = new EncodedValueOld("TurnCost", shift, turnBits, 1, 0, maxTurnCosts) {
-            // override to avoid expensive Math.round
-            @Override
-            public final long getValue(long flags) {
-                // find value
-                flags &= mask;
-                flags >>>= shift;
-                return flags;
-            }
-        };
-        return shift + turnBits;
-    }
-
-    @Override
-    public boolean isTurnRestricted(long flags) {
-        if (maxTurnCosts == 0)
-            return false;
-
-        else if (maxTurnCosts == 1)
-            return (flags & turnRestrictionBit) != 0;
-
-        return turnCostEncoder.getValue(flags) == maxTurnCosts;
-    }
-
-    @Override
-    public double getTurnCost(long flags) {
-        if (maxTurnCosts == 0)
-            return 0;
-
-        else if (maxTurnCosts == 1)
-            return ((flags & turnRestrictionBit) == 0) ? 0 : Double.POSITIVE_INFINITY;
-
-        long cost = turnCostEncoder.getValue(flags);
-        if (cost == maxTurnCosts)
-            return Double.POSITIVE_INFINITY;
-
-        return cost;
-    }
-
-    @Override
-    public long getTurnFlags(boolean restricted, double costs) {
-        if (maxTurnCosts == 0)
-            return 0;
-
-        else if (maxTurnCosts == 1) {
-            if (costs != 0)
-                throw new IllegalArgumentException("Only restrictions are supported");
-
-            return restricted ? turnRestrictionBit : 0;
-        }
-
-        if (restricted) {
-            if (costs != 0 || Double.isInfinite(costs))
-                throw new IllegalArgumentException("Restricted turn can only have infinite costs (or use 0)");
-        } else if (costs >= maxTurnCosts)
-            throw new IllegalArgumentException("Cost is too high. Or specify restricted == true");
-
-        if (costs < 0)
-            throw new IllegalArgumentException("Turn costs cannot be negative");
-
-        if (costs >= maxTurnCosts || restricted)
-            costs = maxTurnCosts;
-        return turnCostEncoder.setValue(0L, (int) costs);
-    }
-
     public final DecimalEncodedValue getAverageSpeedEnc() {
         if (avgSpeedEnc == null)
             throw new NullPointerException("FlagEncoder " + toString() + " not yet initialized");