Allow specifing a weight for routing that is independent of duration

include/util/fingerprint.hpp

@@ -12,9 +12,8 @@ namespace util
 {
 
 // implements a singleton, i.e. there is one and only one conviguration object
-class FingerPrint
+struct FingerPrint
 {
-  public:
     static FingerPrint GetValid();
 
     bool IsValid() const;
@@ -36,6 +35,7 @@ class FingerPrint
 
 static_assert(sizeof(FingerPrint) == 8, "FingerPrint has unexpected size");
 static_assert(std::is_trivial<FingerPrint>::value, "FingerPrint needs to be trivial.");
+static_assert(std::is_pod<FingerPrint>::value, "FingerPrint needs to be a POD.");
 }
 }
 

include/util/node_based_graph.hpp

@@ -18,14 +18,15 @@ namespace util
 struct NodeBasedEdgeData
 {
     NodeBasedEdgeData()
-        : distance(INVALID_EDGE_WEIGHT), edge_id(SPECIAL_NODEID),
+        : weight(INVALID_EDGE_WEIGHT), duration(INVALID_EDGE_WEIGHT), edge_id(SPECIAL_NODEID),
           name_id(std::numeric_limits<unsigned>::max()), reversed(false), roundabout(false),
           circular(false), travel_mode(TRAVEL_MODE_INACCESSIBLE),
           lane_description_id(INVALID_LANE_DESCRIPTIONID)
     {
     }
 
-    NodeBasedEdgeData(int distance,
+    NodeBasedEdgeData(EdgeWeight weight,
+                      EdgeWeight duration,
                       unsigned edge_id,
                       unsigned name_id,
                       bool reversed,
@@ -34,13 +35,14 @@ struct NodeBasedEdgeData
                       bool startpoint,
                       extractor::TravelMode travel_mode,
                       const LaneDescriptionID lane_description_id)
-        : distance(distance), edge_id(edge_id), name_id(name_id), reversed(reversed),
-          roundabout(roundabout), circular(circular), startpoint(startpoint),
+        : weight(weight), duration(duration), edge_id(edge_id), name_id(name_id),
+          reversed(reversed), roundabout(roundabout), circular(circular), startpoint(startpoint),
           travel_mode(travel_mode), lane_description_id(lane_description_id)
     {
     }
 
-    int distance;
+    EdgeWeight weight;
+    EdgeWeight duration;
     unsigned edge_id;
     unsigned name_id;
     bool reversed : 1;
@@ -78,9 +80,8 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
         input_edge_list,
         [](NodeBasedDynamicGraph::InputEdge &output_edge,
            const extractor::NodeBasedEdge &input_edge) {
-            output_edge.data.distance = static_cast<int>(input_edge.weight);
-            BOOST_ASSERT(output_edge.data.distance > 0);
-
+            output_edge.data.weight = input_edge.weight;
+            output_edge.data.duration = input_edge.duration;
             output_edge.data.roundabout = input_edge.roundabout;
             output_edge.data.circular = input_edge.circular;
             output_edge.data.name_id = input_edge.name_id;
@@ -88,6 +89,9 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
             output_edge.data.startpoint = input_edge.startpoint;
             output_edge.data.road_classification = input_edge.road_classification;
             output_edge.data.lane_description_id = input_edge.lane_description_id;
+
+            BOOST_ASSERT(output_edge.data.weight > 0);
+            BOOST_ASSERT(output_edge.data.duration > 0);
         });
 
     tbb::parallel_sort(edges_list.begin(), edges_list.end());

include/util/typedefs.hpp

@@ -58,6 +58,7 @@ using NodeID = std::uint32_t;
 using EdgeID = std::uint32_t;
 using NameID = std::uint32_t;
 using EdgeWeight = std::int32_t;
+using TurnPenalty = std::int16_t; // turn penalty in 100ms units
 
 using LaneID = std::uint8_t;
 static const LaneID INVALID_LANEID = std::numeric_limits<LaneID>::max();
@@ -83,6 +84,7 @@ static const NameID INVALID_NAMEID = std::numeric_limits<NameID>::max();
 static const NameID EMPTY_NAMEID = 0;
 static const unsigned INVALID_COMPONENTID = 0;
 static const EdgeWeight INVALID_EDGE_WEIGHT = std::numeric_limits<EdgeWeight>::max();
+static const TurnPenalty INVALID_TURN_PENALTY = std::numeric_limits<TurnPenalty>::max();
 
 using DatasourceID = std::uint8_t;