Use ranges in datafacade instead of vectors

Range type must use immutable references due to a
regression in `boost::any_range`.
References:
https://svn.boost.org/trac10/ticket/10493
https://stackoverflow.com/questions/42427395/boostany-range-with-optimization-level-o2-causes-crash/42427662

unit_tests/engine/offline_facade.cpp

@@ -156,15 +156,9 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
 
     GeometryID GetGeometryIndex(const NodeID /*id*/) const override { return GeometryID{0, false}; }
 
-    std::vector<NodeID> GetUncompressedForwardGeometry(const EdgeID /*id*/) const override
-    {
-        return {};
-    }
+    NodesIDRangeT GetUncompressedForwardGeometry(const EdgeID /*id*/) const override { return {}; }
 
-    std::vector<NodeID> GetUncompressedReverseGeometry(const EdgeID /*id*/) const override
-    {
-        return {};
-    }
+    NodesIDRangeT GetUncompressedReverseGeometry(const EdgeID /*id*/) const override { return {}; }
 
     TurnPenalty GetWeightPenaltyForEdgeID(const unsigned /*id*/) const override
     {
@@ -176,32 +170,26 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
         return INVALID_TURN_PENALTY;
     }
 
-    std::vector<EdgeWeight> GetUncompressedForwardWeights(const EdgeID /*id*/) const override
+    WeightsRangeT GetUncompressedForwardWeights(const EdgeID /*id*/) const override { return {}; }
+
+    WeightsRangeT GetUncompressedReverseWeights(const EdgeID /*id*/) const override { return {}; }
+
+    DurationsRangeT GetUncompressedForwardDurations(const EdgeID /*geomID*/) const override
     {
         return {};
     }
 
-    std::vector<EdgeWeight> GetUncompressedReverseWeights(const EdgeID /*id*/) const override
+    DurationsRangeT GetUncompressedReverseDurations(const EdgeID /*geomID*/) const override
     {
         return {};
     }
 
-    std::vector<EdgeWeight> GetUncompressedForwardDurations(const EdgeID /*geomID*/) const override
+    DatasourceIDRangeT GetUncompressedForwardDatasources(const EdgeID /*id*/) const override
     {
         return {};
     }
 
-    std::vector<EdgeWeight> GetUncompressedReverseDurations(const EdgeID /*geomID*/) const override
-    {
-        return {};
-    }
-
-    std::vector<DatasourceID> GetUncompressedForwardDatasources(const EdgeID /*id*/) const override
-    {
-        return {};
-    }
-
-    std::vector<DatasourceID> GetUncompressedReverseDatasources(const EdgeID /*id*/) const override
+    DatasourceIDRangeT GetUncompressedReverseDatasources(const EdgeID /*id*/) const override
     {
         return {};
     }
@@ -438,4 +426,21 @@ BOOST_AUTO_TEST_CASE(shortest_path)
     BOOST_CHECK_EQUAL(route.shortest_path_weight, INVALID_EDGE_WEIGHT);
 }
 
+BOOST_AUTO_TEST_CASE(facade_uncompressed_methods)
+{
+    using Algorithm = osrm::engine::routing_algorithms::offline::Algorithm;
+
+    osrm::engine::SearchEngineData<Algorithm> heaps;
+    osrm::engine::datafacade::ContiguousInternalMemoryDataFacade<Algorithm> facade;
+
+    BOOST_CHECK_EQUAL(facade.GetUncompressedForwardGeometry(0).size(), 0);
+    BOOST_CHECK_EQUAL(facade.GetUncompressedReverseGeometry(0).size(), 0);
+    BOOST_CHECK_EQUAL(facade.GetUncompressedForwardWeights(0).size(), 0);
+    BOOST_CHECK_EQUAL(facade.GetUncompressedReverseWeights(0).size(), 0);
+    BOOST_CHECK_EQUAL(facade.GetUncompressedForwardDurations(0).size(), 0);
+    BOOST_CHECK_EQUAL(facade.GetUncompressedReverseDurations(0).size(), 0);
+    BOOST_CHECK_EQUAL(facade.GetUncompressedForwardDatasources(0).size(), 0);
+    BOOST_CHECK_EQUAL(facade.GetUncompressedReverseDatasources(0).size(), 0);
+}
+
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/mocks/mock_datafacade.hpp

@@ -54,38 +54,39 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     {
         return 0;
     }
-    std::vector<NodeID> GetUncompressedForwardGeometry(const EdgeID /* id */) const override
+    NodesIDRangeT GetUncompressedForwardGeometry(const EdgeID /* id */) const override
     {
         return {};
     }
-    std::vector<NodeID> GetUncompressedReverseGeometry(const EdgeID /* id */) const override
+    NodesIDRangeT GetUncompressedReverseGeometry(const EdgeID /* id */) const override
     {
         return {};
     }
-    std::vector<EdgeWeight> GetUncompressedForwardWeights(const EdgeID /* id */) const override
+    WeightsRangeT GetUncompressedForwardWeights(const EdgeID /* id */) const override
     {
-        std::vector<EdgeWeight> result_weights;
-        result_weights.resize(1);
-        result_weights[0] = 1;
+        static const std::vector<SegmentWeight> result_weights{1, 2, 3};
         return result_weights;
     }
-    std::vector<EdgeWeight> GetUncompressedReverseWeights(const EdgeID id) const override
+    WeightsRangeT GetUncompressedReverseWeights(const EdgeID id) const override
     {
         return GetUncompressedForwardWeights(id);
     }
-    std::vector<EdgeWeight> GetUncompressedForwardDurations(const EdgeID id) const override
+
+    DurationsRangeT GetUncompressedForwardDurations(const EdgeID /*id*/) const override
     {
-        return GetUncompressedForwardWeights(id);
+        static const std::vector<SegmentDuration> data{1, 2, 3};
+        return data;
     }
-    std::vector<EdgeWeight> GetUncompressedReverseDurations(const EdgeID id) const override
+    DurationsRangeT GetUncompressedReverseDurations(const EdgeID /*id*/) const override
     {
-        return GetUncompressedForwardWeights(id);
+        static const std::vector<SegmentDuration> data{1, 2, 3};
+        return data;
     }
-    std::vector<DatasourceID> GetUncompressedForwardDatasources(const EdgeID /*id*/) const override
+    DatasourceIDRangeT GetUncompressedForwardDatasources(const EdgeID /*id*/) const override
     {
         return {};
     }
-    std::vector<DatasourceID> GetUncompressedReverseDatasources(const EdgeID /*id*/) const override
+    DatasourceIDRangeT GetUncompressedReverseDatasources(const EdgeID /*id*/) const override
     {
         return {};
     }

unit_tests/util/packed_vector.cpp

@@ -1,7 +1,10 @@
 #include "util/packed_vector.hpp"
 #include "util/typedefs.hpp"
 
+#include "common/range_tools.hpp"
+
 #include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/any_range.hpp>
 #include <boost/range/iterator_range.hpp>
 #include <boost/test/test_case_template.hpp>
 #include <boost/test/unit_test.hpp>
@@ -203,4 +206,50 @@ BOOST_AUTO_TEST_CASE(packed_vector_33bit_continious)
     }
 }
 
+BOOST_AUTO_TEST_CASE(packed_weights_container_with_type_erasure)
+{
+    using Vector = PackedVector<SegmentWeight, SEGMENT_WEIGHT_BITS>;
+    using WeightsRangeT = boost::any_range<SegmentWeight,
+                                           boost::random_access_traversal_tag,
+                                           const typename Vector::internal_reference,
+                                           std::ptrdiff_t>;
+
+    PackedVector<SegmentWeight, SEGMENT_WEIGHT_BITS> vector(7);
+
+    std::iota(vector.begin(), vector.end(), 0);
+
+    auto forward = boost::make_iterator_range(vector.begin() + 1, vector.begin() + 6);
+    auto forward_any = WeightsRangeT(forward.begin(), forward.end());
+    CHECK_EQUAL_RANGE(forward, 1, 2, 3, 4, 5);
+    CHECK_EQUAL_RANGE(forward_any, 1, 2, 3, 4, 5);
+
+    auto reverse = boost::adaptors::reverse(forward);
+    auto reverse_any = WeightsRangeT(reverse);
+    CHECK_EQUAL_RANGE(reverse, 5, 4, 3, 2, 1);
+    CHECK_EQUAL_RANGE(reverse_any, 5, 4, 3, 2, 1);
+}
+
+BOOST_AUTO_TEST_CASE(packed_weights_view_with_type_erasure)
+{
+    using View = PackedVectorView<SegmentWeight, SEGMENT_WEIGHT_BITS>;
+    using PackedDataWord = std::uint64_t; // PackedVectorView<>::WordT
+    using WeightsRangeT = boost::any_range<SegmentWeight,
+                                           boost::random_access_traversal_tag,
+                                           const typename View::internal_reference,
+                                           std::ptrdiff_t>;
+
+    PackedDataWord data[] = {0x200000400000, 0xc, 0};
+    View view(vector_view<PackedDataWord>(data, 3), 7);
+
+    auto forward = boost::make_iterator_range(view.begin() + 1, view.begin() + 4);
+    auto forward_any = WeightsRangeT(forward.begin(), forward.end());
+    CHECK_EQUAL_RANGE(forward, 1, 2, 3);
+    CHECK_EQUAL_RANGE(forward_any, 1, 2, 3);
+
+    auto reverse = boost::adaptors::reverse(forward);
+    auto reverse_any = WeightsRangeT(reverse);
+    CHECK_EQUAL_RANGE(reverse, 3, 2, 1);
+    CHECK_EQUAL_RANGE(reverse_any, 3, 2, 1);
+}
+
 BOOST_AUTO_TEST_SUITE_END()