Next to FlagEncoders for edge properties, TurnCostEncoders are now held

by the EncodingManager. A TurnCostEncoder encodes and decodes turn
restrictions/turn costs of several vehicle types into an integer flag,
like FlagEncoders do. For CAR, BIKE a DefaultTurnCostEncoder has been
declared, which stores turn restrictions only (yet). For FOOT a
NoTurnRestrictionEncoder has been defined, which encodes whether
restrictions nor costs. To define which TurnCostEncoders should be used,
the EncodingManager accepts a second list of turnCostEncoders, which can
be defined the same way as edgeFlagEncoders are defined. 

However, those TurnCostEncoders are not beeing used anywhere in the
code. This is just preparation for turn restriction support, which will
be introduces step by step.

Author: Karl Hübner

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

@@ -0,0 +1,68 @@
+package com.graphhopper.routing.util;
+
+/**
+ * Very simple turn cost encoder, which stores the turn restriction in the first bit,
+ * and the turn costs (in seconds) in x additional bits (0..2^x-1)
+ * 
+ * @author karl.huebner
+ */
+public abstract class AbstractTurnCostEncoder implements TurnCostEncoder
+{
+    private final int maxCostsBits;
+    private final int costsMask;
+
+    protected int restrictionBit;
+    protected int costShift;
+
+    public AbstractTurnCostEncoder( int maxCostsBits )
+    {
+        this.maxCostsBits = maxCostsBits;
+
+        int mask = 0;
+        for (int i = 0; i < this.maxCostsBits; i++)
+        {
+            mask |= (1 << i);
+        }
+        this.costsMask = mask;
+
+        defineBits(0, 0);
+    }
+
+    @Override
+    public int defineBits( int index, int shift )
+    {
+        restrictionBit = 1 << shift;
+        costShift = shift + 1;
+        return shift + maxCostsBits + 1;
+    }
+
+    @Override
+    public boolean isRestricted( int flag )
+    {
+        return (flag & restrictionBit) != 0;
+    }
+
+    @Override
+    public int getCosts( int flag )
+    {
+        int result = (flag >> costShift) & costsMask;
+        if (result >= Math.pow(2, maxCostsBits) || result < 0)
+        {
+            throw new IllegalStateException("Wrong encoding of turn costs");
+        }
+        return result;
+    }
+
+    @Override
+    public int flags( boolean restricted, int costs )
+    {
+        costs = Math.min(costs, (int) (Math.pow(2, maxCostsBits) - 1));
+        int encode = costs << costShift;
+        if (restricted)
+        {
+            encode |= restrictionBit;
+        }
+        return encode;
+    }
+
+}

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

@@ -0,0 +1,42 @@
+package com.graphhopper.routing.util;
+
+/**
+ * Default implementation of {@link AbstractTurnCostEncoder} which 
+ * does not encode any costs yet, but only restrictions in one bit.
+ * Therefore, each turn cost encoder requires only 1 bit storage size
+ * at the moment.
+ * 
+ * @author karl.huebner
+ */
+public class DefaultTurnCostEncoder extends AbstractTurnCostEncoder
+{
+    /**
+     * no costs, but only restrictions will be encoded
+     */
+    public DefaultTurnCostEncoder()
+    {
+        this(0); //we don't need costs yet
+    }
+
+    /**
+     * Next to restrictions, turn costs will be encoded as well
+     * 
+     * @param maxCosts the maximum costs to be encoded by this encoder, everything above this costs will be encoded as maxCosts
+     */
+    public DefaultTurnCostEncoder( int maxCosts )
+    {
+        super(determineRequiredBits(maxCosts)); //determine the number of bits required to store maxCosts
+    }
+
+    private static int determineRequiredBits( int number )
+    {
+        int bits = 0;
+        while (number > 0)
+        {
+            number = number >> 1;
+            bits++;
+        }
+        return bits;
+    }
+
+}