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.

unit_tests/util/static_rtree.cpp

@@ -7,6 +7,9 @@
 #include "util/rectangle.hpp"
 #include "util/exception.hpp"
 
+#include "engine/datafacade/datafacade_base.hpp"
+#include "contractor/query_edge.hpp"
+
 #include <boost/functional/hash.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/test/test_case_template.hpp>
@@ -24,6 +27,7 @@
 #include <unordered_set>
 #include <vector>
 
+
 BOOST_AUTO_TEST_SUITE(static_rtree)
 
 using namespace osrm;
@@ -40,6 +44,83 @@ using TestStaticRTree = StaticRTree<TestData,
                                     TEST_LEAF_NODE_SIZE>;
 using MiniStaticRTree = StaticRTree<TestData, std::vector<FixedPointCoordinate>, false, 2, 3>;
 
+template <class EdgeDataT> class MockDataFacadeT final : public osrm::engine::datafacade::BaseDataFacade<EdgeDataT>
+{
+    private:
+        EdgeDataT foo;
+    public:
+    unsigned GetNumberOfNodes() const { return 0; }
+    unsigned GetNumberOfEdges() const { return 0; }
+    unsigned GetOutDegree(const NodeID /* n */) const { return 0; }
+    NodeID GetTarget(const EdgeID /* e */) const { return SPECIAL_NODEID; }
+    const EdgeDataT &GetEdgeData(const EdgeID /* e */) const { 
+        return foo;
+    }
+    EdgeID BeginEdges(const NodeID /* n */) const { return SPECIAL_EDGEID; }
+    EdgeID EndEdges(const NodeID /* n */) const { return SPECIAL_EDGEID; }
+    osrm::engine::datafacade::EdgeRange GetAdjacentEdgeRange(const NodeID /* node */) const {
+        return irange(static_cast<EdgeID>(0),static_cast<EdgeID>(0));
+    }
+    EdgeID FindEdge(const NodeID /* from */, const NodeID /* to */) const { return SPECIAL_EDGEID; }
+    EdgeID FindEdgeInEitherDirection(const NodeID /* from */, const NodeID /* to */) const { return SPECIAL_EDGEID; }
+    EdgeID
+    FindEdgeIndicateIfReverse(const NodeID /* from */, const NodeID /* to */, bool & /* result */) const { return SPECIAL_EDGEID; }
+    util::FixedPointCoordinate GetCoordinateOfNode(const unsigned /* id */) const {
+        FixedPointCoordinate foo(0,0);
+        return foo;
+    }
+    bool EdgeIsCompressed(const unsigned /* id */) const { return false; }
+    unsigned GetGeometryIndexForEdgeID(const unsigned /* id */) const { return SPECIAL_NODEID; }
+    void GetUncompressedGeometry(const EdgeID /* id */,
+                                         std::vector<NodeID> &/* result_nodes */) const {}
+    void GetUncompressedWeights(const EdgeID /* id */,
+                                         std::vector<EdgeWeight> & /* result_weights */) const {}
+    extractor::TurnInstruction GetTurnInstructionForEdgeID(const unsigned /* id */) const {
+        return osrm::extractor::TurnInstruction::NoTurn;
+    }
+    extractor::TravelMode GetTravelModeForEdgeID(const unsigned /* id */) const 
+    {
+        return TRAVEL_MODE_DEFAULT;
+    }
+    std::vector<typename osrm::engine::datafacade::BaseDataFacade<EdgeDataT>::RTreeLeaf> GetEdgesInBox(const util::FixedPointCoordinate & /* south_west */,
+                                                 const util::FixedPointCoordinate & /*north_east */) {
+        std::vector<typename osrm::engine::datafacade::BaseDataFacade<EdgeDataT>::RTreeLeaf> foo;
+        return foo;
+    }
+    std::vector<osrm::engine::PhantomNodeWithDistance>
+    NearestPhantomNodesInRange(const util::FixedPointCoordinate /* input_coordinate */,
+                               const float /* max_distance */,
+                               const int /* bearing = 0 */,
+                               const int /* bearing_range = 180 */) {
+        std::vector<osrm::engine::PhantomNodeWithDistance> foo;
+        return foo;
+    }
+    std::vector<osrm::engine::PhantomNodeWithDistance>
+    NearestPhantomNodes(const util::FixedPointCoordinate /* input_coordinate */,
+                        const unsigned /* max_results */,
+                        const int /* bearing = 0 */,
+                        const int /* bearing_range = 180 */) {
+        std::vector<osrm::engine::PhantomNodeWithDistance> foo;
+        return foo;
+    }
+    std::pair<osrm::engine::PhantomNode, osrm::engine::PhantomNode> NearestPhantomNodeWithAlternativeFromBigComponent(
+        const util::FixedPointCoordinate /* input_coordinate */,
+        const int /* bearing = 0 */,
+        const int /* bearing_range = 180 */) {
+        std::pair<osrm::engine::PhantomNode, osrm::engine::PhantomNode> foo;
+        return foo;
+    }
+    unsigned GetCheckSum() const { return 0; }
+    bool IsCoreNode(const NodeID /* id */) const { return false; }
+    unsigned GetNameIndexFromEdgeID(const unsigned /* id */) const { return 0; }
+    std::string get_name_for_id(const unsigned /* name_id */) const { return ""; }
+    std::size_t GetCoreSize() const { return 0; }
+    std::string GetTimestamp() const { return ""; }
+
+};
+
+using MockDataFacade = MockDataFacadeT<contractor::QueryEdge::EdgeData>;
+
 // Choosen by a fair W20 dice roll (this value is completely arbitrary)
 constexpr unsigned RANDOM_SEED = 42;
 static const int32_t WORLD_MIN_LAT = -90 * COORDINATE_PRECISION;
@@ -417,7 +498,8 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
     std::string nodes_path;
     build_rtree<GraphFixture, MiniStaticRTree>("test_bearing", &fixture, leaves_path, nodes_path);
     MiniStaticRTree rtree(nodes_path, leaves_path, fixture.coords);
-    engine::GeospatialQuery<MiniStaticRTree> query(rtree, fixture.coords);
+    std::unique_ptr<MockDataFacade> mockfacade_ptr(new MockDataFacade);
+    engine::GeospatialQuery<MiniStaticRTree, MockDataFacade> query(rtree, fixture.coords, *mockfacade_ptr);
 
     FixedPointCoordinate input(5.0 * COORDINATE_PRECISION, 5.1 * COORDINATE_PRECISION);
 
@@ -477,7 +559,8 @@ BOOST_AUTO_TEST_CASE(bbox_search_tests)
     std::string nodes_path;
     build_rtree<GraphFixture, MiniStaticRTree>("test_bbox", &fixture, leaves_path, nodes_path);
     MiniStaticRTree rtree(nodes_path, leaves_path, fixture.coords);
-    engine::GeospatialQuery<MiniStaticRTree> query(rtree, fixture.coords);
+    std::unique_ptr<MockDataFacade> mockfacade_ptr(new MockDataFacade);
+    engine::GeospatialQuery<MiniStaticRTree, MockDataFacade> query(rtree, fixture.coords, *mockfacade_ptr);
 
     {
         RectangleInt2D bbox = {static_cast<uint32_t>(0.5 * COORDINATE_PRECISION),