Make forward/reverse weight/offset calculated at query time,

rather than being cached in the StaticRTree.  This means we
can freely apply traffic data and not have stale values lying
around.  It reduces the size of the RTree on disk, at the expense
of some additional data in RAM.

include/extractor/compressed_edge_container.hpp

@@ -16,8 +16,13 @@ namespace extractor
 class CompressedEdgeContainer
 {
   public:
-    using CompressedNode = std::pair<NodeID, EdgeWeight>;
-    using EdgeBucket = std::vector<CompressedNode>;
+    struct CompressedEdge
+    {
+    public:
+        NodeID node_id;  // refers to an internal node-based-node
+        EdgeWeight weight;  // the weight of the edge leading to this node
+    };
+    using EdgeBucket = std::vector<CompressedEdge>;
 
     CompressedEdgeContainer();
     void CompressEdge(const EdgeID surviving_edge_id,
@@ -27,6 +32,10 @@ class CompressedEdgeContainer
                       const EdgeWeight weight1,
                       const EdgeWeight weight2);
 
+    void AddUncompressedEdge(const EdgeID edgei_id, 
+                             const NodeID target_node,
+                             const EdgeWeight weight);
+
     bool HasEntryForID(const EdgeID edge_id) const;
     void PrintStatistics() const;
     void SerializeInternalVector(const std::string &path) const;

include/extractor/edge_based_graph_factory.hpp

@@ -43,7 +43,7 @@ class EdgeBasedGraphFactory
     EdgeBasedGraphFactory &operator=(const EdgeBasedGraphFactory &) = delete;
 
     explicit EdgeBasedGraphFactory(std::shared_ptr<util::NodeBasedDynamicGraph> node_based_graph,
-                                   const CompressedEdgeContainer &compressed_edge_container,
+                                   CompressedEdgeContainer &compressed_edge_container,
                                    const std::unordered_set<NodeID> &barrier_nodes,
                                    const std::unordered_set<NodeID> &traffic_lights,
                                    std::shared_ptr<const RestrictionMap> restriction_map,
@@ -99,7 +99,7 @@ class EdgeBasedGraphFactory
 
     const std::unordered_set<NodeID> &m_barrier_nodes;
     const std::unordered_set<NodeID> &m_traffic_lights;
-    const CompressedEdgeContainer &m_compressed_edge_container;
+    CompressedEdgeContainer &m_compressed_edge_container;
 
     SpeedProfileProperties speed_profile;
 

include/extractor/edge_based_node.hpp

@@ -22,8 +22,8 @@ struct EdgeBasedNode
     EdgeBasedNode()
         : forward_edge_based_node_id(SPECIAL_NODEID), reverse_edge_based_node_id(SPECIAL_NODEID),
           u(SPECIAL_NODEID), v(SPECIAL_NODEID), name_id(0),
-          forward_weight(INVALID_EDGE_WEIGHT >> 1), reverse_weight(INVALID_EDGE_WEIGHT >> 1),
-          forward_offset(0), reverse_offset(0), packed_geometry_id(SPECIAL_EDGEID),
+          forward_packed_geometry_id(SPECIAL_EDGEID),
+          reverse_packed_geometry_id(SPECIAL_EDGEID),
           component{INVALID_COMPONENTID, false},
           fwd_segment_position(std::numeric_limits<unsigned short>::max()),
           forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
@@ -36,11 +36,8 @@ struct EdgeBasedNode
                            NodeID u,
                            NodeID v,
                            unsigned name_id,
-                           int forward_weight,
-                           int reverse_weight,
-                           int forward_offset,
-                           int reverse_offset,
-                           unsigned packed_geometry_id,
+                           unsigned forward_weight_or_packed_geometry_id_,
+                           unsigned reverse_weight_or_packed_geometry_id_,
                            bool is_tiny_component,
                            unsigned component_id,
                            unsigned short fwd_segment_position,
@@ -48,9 +45,9 @@ struct EdgeBasedNode
                            TravelMode backward_travel_mode)
         : forward_edge_based_node_id(forward_edge_based_node_id),
           reverse_edge_based_node_id(reverse_edge_based_node_id), u(u), v(v), name_id(name_id),
-          forward_weight(forward_weight), reverse_weight(reverse_weight),
-          forward_offset(forward_offset), reverse_offset(reverse_offset),
-          packed_geometry_id(packed_geometry_id), component{component_id, is_tiny_component},
+          forward_packed_geometry_id(forward_weight_or_packed_geometry_id_),
+          reverse_packed_geometry_id(reverse_weight_or_packed_geometry_id_),
+          component{component_id, is_tiny_component},
           fwd_segment_position(fwd_segment_position), forward_travel_mode(forward_travel_mode),
           backward_travel_mode(backward_travel_mode)
     {
@@ -68,18 +65,14 @@ struct EdgeBasedNode
         return centroid;
     }
 
-    bool IsCompressed() const { return packed_geometry_id != SPECIAL_EDGEID; }
-
     NodeID forward_edge_based_node_id; // needed for edge-expanded graph
     NodeID reverse_edge_based_node_id; // needed for edge-expanded graph
     NodeID u;                          // indices into the coordinates array
     NodeID v;                          // indices into the coordinates array
     unsigned name_id;                  // id of the edge name
-    int forward_weight;                // weight of the edge
-    int reverse_weight;                // weight in the other direction (may be different)
-    int forward_offset;          // prefix sum of the weight up the edge TODO: short must suffice
-    int reverse_offset;          // prefix sum of the weight from the edge TODO: short must suffice
-    unsigned packed_geometry_id; // if set, then the edge represents a packed geometry
+
+    unsigned forward_packed_geometry_id;
+    unsigned reverse_packed_geometry_id;
     struct
     {
         unsigned id : 31;