Use std::ranges::subrange instead of boost::iterator_range

include/engine/api/nearest_api.hpp

@@ -136,7 +136,7 @@ class NearestAPI final : public BaseAPI
             forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id);
 
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position));
+                facade.GetOSMNodeIDOfNode(forward_geometry[phantom_node.fwd_segment_position]);
             to_node = static_cast<std::uint64_t>(osm_node_id);
         }
 
@@ -146,14 +146,14 @@ class NearestAPI final : public BaseAPI
             const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
             const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id);
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1));
+                facade.GetOSMNodeIDOfNode(geometry[phantom_node.fwd_segment_position + 1]);
             from_node = static_cast<std::uint64_t>(osm_node_id);
         }
         else if (phantom_node.forward_segment_id.enabled && phantom_node.fwd_segment_position > 0)
         {
             // In the case of one way, rely on forward segment only
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position - 1));
+                facade.GetOSMNodeIDOfNode(forward_geometry[phantom_node.fwd_segment_position - 1]);
             from_node = static_cast<std::uint64_t>(osm_node_id);
         }
 

include/engine/datafacade/datafacade_base.hpp

@@ -29,13 +29,11 @@
 #include "util/typedefs.hpp"
 
 #include "osrm/coordinate.hpp"
-
-#include <boost/range/adaptor/reversed.hpp>
-#include <boost/range/any_range.hpp>
 #include <cstddef>
 
 #include <engine/bearing.hpp>
 #include <optional>
+#include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -50,20 +48,21 @@ class BaseDataFacade
     using RTreeLeaf = extractor::EdgeBasedNodeSegment;
 
     using NodeForwardRange =
-        boost::iterator_range<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
-    using NodeReverseRange = boost::reversed_range<const NodeForwardRange>;
+        std::ranges::subrange<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
+    using NodeReverseRange = std::ranges::reverse_view<NodeForwardRange>;
 
     using WeightForwardRange =
-        boost::iterator_range<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
-    using WeightReverseRange = boost::reversed_range<const WeightForwardRange>;
+        std::ranges::subrange<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
+
+    using WeightReverseRange = std::ranges::reverse_view<WeightForwardRange>;
 
     using DurationForwardRange =
-        boost::iterator_range<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
-    using DurationReverseRange = boost::reversed_range<const DurationForwardRange>;
+        std::ranges::subrange<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
+    using DurationReverseRange = std::ranges::reverse_view<DurationForwardRange>;
 
     using DatasourceForwardRange =
-        boost::iterator_range<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
-    using DatasourceReverseRange = boost::reversed_range<const DatasourceForwardRange>;
+        std::ranges::subrange<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
+    using DatasourceReverseRange = std::ranges::reverse_view<DatasourceForwardRange>;
 
     BaseDataFacade() {}
     virtual ~BaseDataFacade() {}

include/engine/geospatial_query.hpp

@@ -394,7 +394,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             alias_cast<EdgeDuration>(forward_durations[data.fwd_segment_position]);
         EdgeDistance forward_distance =
             to_alias<EdgeDistance>(util::coordinate_calculation::greatCircleDistance(
-                datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position)),
+                datafacade.GetCoordinateOfNode(forward_geometry[data.fwd_segment_position]),
                 point_on_segment));
 
         const auto reverse_weight_offset = alias_cast<EdgeWeight>(
@@ -426,7 +426,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         EdgeDistance reverse_distance =
             to_alias<EdgeDistance>(util::coordinate_calculation::greatCircleDistance(
                 point_on_segment,
-                datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position + 1))));
+                datafacade.GetCoordinateOfNode(forward_geometry[data.fwd_segment_position + 1])));
 
         ratio = std::min(1.0, std::max(0.0, ratio));
         if (data.forward_segment_id.id != SPECIAL_SEGMENTID)

include/engine/guidance/assemble_geometry.hpp

@@ -61,7 +61,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
     const auto source_geometry_id = facade.GetGeometryIndex(source_node_id).id;
     const auto source_geometry = facade.GetUncompressedForwardGeometry(source_geometry_id);
 
-    geometry.node_ids.push_back(source_geometry(source_segment_start_coordinate));
+    geometry.node_ids.push_back(source_geometry[source_segment_start_coordinate]);
 
     auto cumulative_distance = 0.;
     auto current_distance = 0.;
@@ -142,7 +142,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
             LegGeometry::Annotation{current_distance,
                                     duration,
                                     weight,
-                                    forward_datasources(target_node.fwd_segment_position)});
+                                    forward_datasources[target_node.fwd_segment_position]});
     }
     else
     {
@@ -154,7 +154,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
             from_alias<double>(reversed_target ? target_node.reverse_weight
                                                : target_node.forward_weight) /
                 facade.GetWeightMultiplier(),
-            forward_datasources(target_node.fwd_segment_position)});
+            forward_datasources[target_node.fwd_segment_position]});
     }
 
     geometry.segment_offsets.push_back(geometry.locations.size());
@@ -168,7 +168,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
     const auto target_segment_end_coordinate =
         target_node.fwd_segment_position + (reversed_target ? 0 : 1);
     const auto target_geometry = facade.GetUncompressedForwardGeometry(target_geometry_id);
-    geometry.node_ids.push_back(target_geometry(target_segment_end_coordinate));
+    geometry.node_ids.push_back(target_geometry[target_segment_end_coordinate]);
 
     BOOST_ASSERT(geometry.segment_distances.size() == geometry.segment_offsets.size() - 1);
     BOOST_ASSERT(geometry.locations.size() > geometry.segment_distances.size());

include/extractor/node_restriction_map.hpp

@@ -5,8 +5,6 @@
 #include "restriction_graph.hpp"
 #include "util/typedefs.hpp"
 
-#include <boost/range/adaptor/filtered.hpp>
-
 #include <unordered_map>
 #include <utility>
 #include <vector>

include/extractor/segment_data_container.hpp

@@ -7,11 +7,9 @@
 
 #include "storage/shared_memory_ownership.hpp"
 #include "storage/tar_fwd.hpp"
-
-#include <boost/range/adaptor/reversed.hpp>
-#include <boost/range/iterator_range.hpp>
-
 #include <filesystem>
+#include <iostream>
+#include <ranges>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -79,121 +77,121 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = nodes.begin() + index[id];
         const auto end = nodes.begin() + index[id + 1];
 
-        return boost::make_iterator_range(begin, end);
+        return std::ranges::subrange(begin, end);
     }
 
     auto GetReverseGeometry(const DirectionalGeometryID id)
     {
-        return boost::adaptors::reverse(GetForwardGeometry(id));
+        return GetForwardGeometry(id) | std::views::reverse;
     }
 
     auto GetForwardDurations(const DirectionalGeometryID id)
     {
         const auto begin = fwd_durations.begin() + index[id] + 1;
         const auto end = fwd_durations.begin() + index[id + 1];
 
-        return boost::make_iterator_range(begin, end);
+        return std::ranges::subrange(begin, end);
     }
 
     auto GetReverseDurations(const DirectionalGeometryID id)
     {
         const auto begin = rev_durations.begin() + index[id];
         const auto end = rev_durations.begin() + index[id + 1] - 1;
 
-        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
+        return std::ranges::subrange(begin, end) | std::views::reverse;
     }
 
     auto GetForwardWeights(const DirectionalGeometryID id)
     {
         const auto begin = fwd_weights.begin() + index[id] + 1;
         const auto end = fwd_weights.begin() + index[id + 1];
 
-        return boost::make_iterator_range(begin, end);
+        return std::ranges::subrange(begin, end);
     }
 
     auto GetReverseWeights(const DirectionalGeometryID id)
     {
         const auto begin = rev_weights.begin() + index[id];
         const auto end = rev_weights.begin() + index[id + 1] - 1;
 
-        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
+        return std::ranges::subrange(begin, end) | std::views::reverse;
     }
 
     auto GetForwardDatasources(const DirectionalGeometryID id)
     {
         const auto begin = fwd_datasources.begin() + index[id] + 1;
         const auto end = fwd_datasources.begin() + index[id + 1];
 
-        return boost::make_iterator_range(begin, end);
+        return std::ranges::subrange(begin, end);
     }
 
     auto GetReverseDatasources(const DirectionalGeometryID id)
     {
         const auto begin = rev_datasources.begin() + index[id];
         const auto end = rev_datasources.begin() + index[id + 1] - 1;
 
-        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
+        return std::ranges::subrange(begin, end) | std::views::reverse;
     }
 
     auto GetForwardGeometry(const DirectionalGeometryID id) const
     {
         const auto begin = nodes.cbegin() + index[id];
         const auto end = nodes.cbegin() + index[id + 1];
 
-        return boost::make_iterator_range(begin, end);
+        return std::ranges::subrange(begin, end);
     }
 
     auto GetReverseGeometry(const DirectionalGeometryID id) const
     {
-        return boost::adaptors::reverse(GetForwardGeometry(id));
+        return GetForwardGeometry(id) | std::views::reverse;
     }
 
     auto GetForwardDurations(const DirectionalGeometryID id) const
     {
         const auto begin = fwd_durations.cbegin() + index[id] + 1;
         const auto end = fwd_durations.cbegin() + index[id + 1];
 
-        return boost::make_iterator_range(begin, end);
+        return std::ranges::subrange(begin, end);
     }
 
     auto GetReverseDurations(const DirectionalGeometryID id) const
     {
         const auto begin = rev_durations.cbegin() + index[id];
         const auto end = rev_durations.cbegin() + index[id + 1] - 1;
 
-        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
+        return std::ranges::subrange(begin, end) | std::views::reverse;
     }
 
     auto GetForwardWeights(const DirectionalGeometryID id) const
     {
         const auto begin = fwd_weights.cbegin() + index[id] + 1;
         const auto end = fwd_weights.cbegin() + index[id + 1];
 
-        return boost::make_iterator_range(begin, end);
+        return std::ranges::subrange(begin, end);
     }
 
     auto GetReverseWeights(const DirectionalGeometryID id) const
     {
         const auto begin = rev_weights.cbegin() + index[id];
         const auto end = rev_weights.cbegin() + index[id + 1] - 1;
 
-        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
+        return std::ranges::subrange(begin, end) | std::views::reverse;
     }
 
     auto GetForwardDatasources(const DirectionalGeometryID id) const
     {
         const auto begin = fwd_datasources.cbegin() + index[id] + 1;
         const auto end = fwd_datasources.cbegin() + index[id + 1];
 
-        return boost::make_iterator_range(begin, end);
+        return std::ranges::subrange(begin, end);
     }
 
     auto GetReverseDatasources(const DirectionalGeometryID id) const
     {
         const auto begin = rev_datasources.cbegin() + index[id];
         const auto end = rev_datasources.cbegin() + index[id + 1] - 1;
 
-        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
+        return std::ranges::subrange(begin, end) | std::views::reverse;
     }
 
     auto GetNumberOfGeometries() const { return index.size() - 1; }

include/partitioner/cell_storage.hpp

@@ -14,8 +14,6 @@
 
 #include "customizer/cell_metric.hpp"
 
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/range/iterator_range.hpp>
 #include <ranges>
 #include <tbb/parallel_sort.h>
 

include/partitioner/multi_level_partition.hpp

@@ -18,7 +18,7 @@
 #include <numeric>
 #include <vector>
 
-#include <boost/range/adaptor/reversed.hpp>
+#include <ranges>
 
 namespace osrm::partitioner
 {
@@ -281,7 +281,7 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
 
         // top down assign new cell ids
         LevelID level = partitions.size();
-        for (const auto &partition : boost::adaptors::reverse(partitions))
+        for (const auto &partition : std::ranges::reverse_view(partitions))
         {
             BOOST_ASSERT(permutation.size() > 0);
             CellID last_cell_id = partition[permutation.front()];

include/util/packed_vector.hpp

@@ -340,6 +340,8 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         {
         }
 
+        ReferenceT operator[](difference_type n) const { return container->operator[](index + n); }
+
       private:
         void increment() { ++index; }
         void decrement() { --index; }

include/util/vector_view.hpp

@@ -42,6 +42,8 @@ class VectorViewIterator : public boost::iterator_facade<VectorViewIterator<Data
     explicit VectorViewIterator() : m_value(nullptr) {}
     explicit VectorViewIterator(DataT *x) : m_value(x) {}
 
+    reference operator[](difference_type n) const { return m_value[n]; }
+
   private:
     void increment() { ++m_value; }
     void decrement() { --m_value; }

src/engine/guidance/post_processing.cpp

@@ -13,7 +13,6 @@
 
 #include <boost/assert.hpp>
 #include <boost/numeric/conversion/cast.hpp>
-#include <boost/range/iterator_range.hpp>
 
 #include <algorithm>
 #include <cmath>

src/engine/plugins/tile.cpp

@@ -482,9 +482,10 @@ void encodeVectorTile(const DataFacadeBase &facade,
                         reverse_duration_range[reverse_duration_range.size() -
                                                edge.fwd_segment_position - 1];
                     const auto forward_datasource_idx =
-                        forward_datasource_range(edge.fwd_segment_position);
-                    const auto reverse_datasource_idx = reverse_datasource_range(
-                        reverse_datasource_range.size() - edge.fwd_segment_position - 1);
+                        forward_datasource_range[edge.fwd_segment_position];
+                    const auto reverse_datasource_idx =
+                        reverse_datasource_range[reverse_datasource_range.size() -
+                                                 edge.fwd_segment_position - 1];
 
                     const auto is_startpoint = edge.is_startpoint;
 

src/partitioner/bisection_to_partition.cpp

@@ -124,7 +124,7 @@ bisectionToPartition(const std::vector<BisectionID> &node_to_bisection_id,
     std::vector<std::uint32_t> num_cells(max_cell_sizes.size());
 
     int level_idx = max_cell_sizes.size() - 1;
-    for (auto max_cell_size : boost::adaptors::reverse(max_cell_sizes))
+    for (auto max_cell_size : std::ranges::reverse_view(max_cell_sizes))
     {
         BOOST_ASSERT(level_idx >= 0);
         partitionLevel(node_to_bisection_id, max_cell_size, permutation, cells);

src/updater/updater.cpp

@@ -252,11 +252,11 @@ updateSegmentData(const UpdaterConfig &config,
 
                 // In this case we want it oriented from in forward directions
                 auto rev_weights_range =
-                    boost::adaptors::reverse(segment_data.GetReverseWeights(geometry_id));
+                    segment_data.GetReverseWeights(geometry_id) | std::views::reverse;
                 auto rev_durations_range =
-                    boost::adaptors::reverse(segment_data.GetReverseDurations(geometry_id));
+                    segment_data.GetReverseDurations(geometry_id) | std::views::reverse;
                 auto rev_datasources_range =
-                    boost::adaptors::reverse(segment_data.GetReverseDatasources(geometry_id));
+                    segment_data.GetReverseDatasources(geometry_id) | std::views::reverse;
                 bool rev_was_updated = false;
 
                 for (const auto segment_offset :
@@ -337,11 +337,11 @@ updateSegmentData(const UpdaterConfig &config,
             auto new_fwd_durations_range = segment_data.GetForwardDurations(geometry_id);
             auto new_fwd_datasources_range = segment_data.GetForwardDatasources(geometry_id);
             auto new_rev_durations_range =
-                boost::adaptors::reverse(segment_data.GetReverseDurations(geometry_id));
+                segment_data.GetReverseDurations(geometry_id) | std::views::reverse;
             auto new_rev_datasources_range = segment_data.GetReverseDatasources(geometry_id);
             auto old_fwd_durations_range = segment_data_backup->GetForwardDurations(geometry_id);
             auto old_rev_durations_range =
-                boost::adaptors::reverse(segment_data_backup->GetReverseDurations(geometry_id));
+                segment_data_backup->GetReverseDurations(geometry_id) | std::views::reverse;
 
             for (const auto segment_offset :
                  util::irange<std::size_t>(0, new_fwd_durations_range.size()))