Added the possibility to set one additional value for both edges and

nodes. By default no additional values will be stored and current graphs
are still valid. Any implementation of ExtendedStorage can be put into
GraphHopperStorage, which take care of any additional storages, which
depends on nodes or edges ( e.g. turn cost tables) by reading/writing
those additional values. An example implementation can be found in
TurnCostStorage.

This will be mandandatory to implement support of turn restrictions
later.

Author: Karl Hübner

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

@@ -24,12 +24,14 @@
 import com.graphhopper.util.*;
 import com.graphhopper.util.shapes.BBox;
 import com.graphhopper.util.shapes.GHPoint;
+
 import gnu.trove.list.array.TIntArrayList;
 import gnu.trove.map.TIntObjectMap;
 import gnu.trove.map.hash.TIntObjectHashMap;
 import gnu.trove.procedure.TIntProcedure;
 import gnu.trove.procedure.TObjectProcedure;
 import gnu.trove.set.hash.TIntHashSet;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -69,8 +71,9 @@ public QueryGraph( Graph graph )
     }
 
     /**
-     * For all specified query results calculate snapped point and set closest node and edge to a
-     * virtual one if necessary. Additionally the wayIndex can change if an edge is swapped.
+     * For all specified query results calculate snapped point and set closest
+     * node and edge to a virtual one if necessary. Additionally the wayIndex
+     * can change if an edge is swapped.
      */
     public void lookup( List<QueryResult> resList )
     {
@@ -281,6 +284,12 @@ public double getLongitude( int nodeId )
         return mainGraph.getLongitude(nodeId);
     }
 
+    @Override
+    public int getAdditionalNodeField( int nodeId )
+    {
+        return mainGraph.getAdditionalNodeField(nodeId);
+    }
+
     @Override
     public BBox getBounds()
     {
@@ -448,6 +457,12 @@ public void setNode( int node, double lat, double lon )
         throw exc();
     }
 
+    @Override
+    public void setAdditionalNodeField( int nodeId, int additionalValue )
+    {
+        exc();
+    }
+
     @Override
     public EdgeIteratorState edge( int a, int b )
     {
@@ -587,6 +602,18 @@ public String toString()
         {
             return edges.toString();
         }
+
+        @Override
+        public int getAdditionalField()
+        {
+            return edges.get(current).getAdditionalField();
+        }
+
+        @Override
+        public EdgeIteratorState setAdditionalField( int value )
+        {
+            return edges.get(current).setAdditionalField(value);
+        }
     }
 
     /**
@@ -712,6 +739,12 @@ public boolean isShortcut()
             return false;
         }
 
+        @Override
+        public int getAdditionalField()
+        {
+            throw new UnsupportedOperationException("Not supported.");
+        }
+
         @Override
         public int getSkippedEdge1()
         {
@@ -741,5 +774,11 @@ public EdgeIteratorState detach()
         {
             throw new UnsupportedOperationException("Not supported.");
         }
+
+        @Override
+        public EdgeIteratorState setAdditionalField( int value )
+        {
+            throw new UnsupportedOperationException("Not supported.");
+        }
     }
 }

core/src/main/java/com/graphhopper/storage/ExtendedStorage.java

@@ -0,0 +1,155 @@
+package com.graphhopper.storage;
+
+/**
+ * You need custom storages, like turn cost tables, or osmid tables for your
+ * graph? Implement this interface now and put it in any graph storage you want.
+ * It's that easy!
+ */
+public interface ExtendedStorage
+{
+
+    /**
+     * @return true, if and only if, if an additional field at the graphs node
+     *         storage is required
+     */
+    boolean isRequireNodeField();
+
+    /**
+     * @return true, if and only if, if an additional field at the graphs edge
+     *         storage is required
+     */
+    boolean isRequireEdgeField();
+    
+    /**
+     * @return the default field value which will be set for default when creating nodes 
+     */
+    int getDefaultNodeFieldValue();
+    
+    /**
+     * @return the default field value which will be set for default when creating edges 
+     */
+    int getDefaultEdgeFieldValue();
+
+    /**
+     * initializes the extended storage by giving the graph storage
+     */
+    void init( GraphStorage graph );
+
+    /**
+     * creates all additional data storages
+     */
+    void create( long initSize );
+
+    /**
+     * loads from existing data storages
+     */
+    boolean loadExisting();
+
+    /**
+     * sets the segment size in all additional data storages
+     */
+    void setSegmentSize( int bytes );
+
+    /**
+     * flushes all additional data storages
+     */
+    void flush();
+
+    /**
+     * closes all additional data storages
+     */
+    void close();
+
+    /**
+     * returns the sum of all additional data storages capacity
+     */
+    long getCapacity();
+
+    /**
+     * creates a copy of this extended storage
+     */
+    ExtendedStorage copyTo( ExtendedStorage extStorage );
+
+    /**
+     * default implementation defines no additional fields or any logic. there's like nothing
+     * , like the default behavior.
+     */
+    public class NoExtendedStorage implements ExtendedStorage
+    {
+
+        @Override
+        public boolean isRequireNodeField()
+        {
+            return false;
+        }
+
+        @Override
+        public boolean isRequireEdgeField()
+        {
+            return false;
+        }
+
+        @Override
+        public int getDefaultNodeFieldValue()
+        {
+            return 0;
+        }
+
+        @Override
+        public int getDefaultEdgeFieldValue()
+        {
+            return 0;
+        }
+        
+        @Override
+        public void init( GraphStorage grap )
+        {
+            // noop
+        }
+
+        @Override
+        public void create( long initSize )
+        {
+            // noop
+        }
+
+        @Override
+        public boolean loadExisting()
+        {
+            // noop
+            return true;
+        }
+
+        @Override
+        public void setSegmentSize( int bytes )
+        {
+            // noop
+        }
+
+        @Override
+        public void flush()
+        {
+            // noop
+        }
+
+        @Override
+        public void close()
+        {
+            // noop
+        }
+
+        @Override
+        public long getCapacity()
+        {
+            return 0;
+        }
+
+        @Override
+        public ExtendedStorage copyTo( ExtendedStorage extStorage )
+        {
+            // noop
+            return extStorage;
+        }
+
+    }
+}

core/src/main/java/com/graphhopper/storage/Graph.java

@@ -52,6 +52,18 @@ public interface Graph
      */
     double getLongitude( int nodeId );
 
+    /**
+     * @return the additional value at the specified node index
+     * @throws AssertionError if, and only if, the extendedStorage does not require an additional node field 
+     */
+	int getAdditionalNodeField(int nodeId);
+
+	/**
+	 * Sets the additional value at the specified node index
+	 * @throws AssertionError if, and only if, the extendedStorage does not require an additional node field
+	 */
+	void setAdditionalNodeField(int nodeId, int additionalValue);
+
     /**
      * Returns the implicit bounds of this graph calculated from the lat,lon input of setNode
      */