Merge branch 'master' into sf-ranges

include/customizer/cell_customizer.hpp

@@ -100,9 +100,9 @@ class CellCustomizer
                 distances.front() =
                     inserted ? heap.GetData(destination).distance : INVALID_EDGE_DISTANCE;
 
-                weights.advance_begin(1);
+                weights.advance(1);
-                durations.advance_begin(1);
+                durations.advance(1);
-                distances.advance_begin(1);
+                distances.advance(1);
             }
             BOOST_ASSERT(weights.empty());
             BOOST_ASSERT(durations.empty());

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/base64.hpp

@@ -13,7 +13,6 @@
 #include <boost/archive/iterators/base64_from_binary.hpp>
 #include <boost/archive/iterators/binary_from_base64.hpp>
 #include <boost/archive/iterators/transform_width.hpp>
-#include <boost/range/algorithm/copy.hpp>
 
 namespace osrm
 {

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>;
+        std::ranges::subrange<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
-    using NodeReverseRange = boost::reversed_range<const NodeForwardRange>;
+    using NodeReverseRange = std::ranges::reverse_view<NodeForwardRange>;
 
     using WeightForwardRange =
-        boost::iterator_range<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
+        std::ranges::subrange<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
-    using WeightReverseRange = boost::reversed_range<const WeightForwardRange>;
+
+    using WeightReverseRange = std::ranges::reverse_view<WeightForwardRange>;
 
     using DurationForwardRange =
-        boost::iterator_range<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
+        std::ranges::subrange<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
-    using DurationReverseRange = boost::reversed_range<const DurationForwardRange>;
+    using DurationReverseRange = std::ranges::reverse_view<DurationForwardRange>;
 
     using DatasourceForwardRange =
-        boost::iterator_range<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
+        std::ranges::subrange<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
-    using DatasourceReverseRange = boost::reversed_range<const DatasourceForwardRange>;
+    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/engine/guidance/route_step.hpp

@@ -14,7 +14,7 @@
 #include <string>
 #include <vector>
 
-#include <boost/range/iterator_range.hpp>
+#include <ranges>
 
 namespace osrm::engine::guidance
 {
@@ -220,14 +220,14 @@ inline auto RouteStep::LanesToTheLeft() const
 {
     const auto &description = intersections.front().lane_description;
     LaneID num_lanes_left = NumLanesToTheLeft();
-    return boost::make_iterator_range(description.begin(), description.begin() + num_lanes_left);
+    return std::ranges::subrange(description.begin(), description.begin() + num_lanes_left);
 }
 
 inline auto RouteStep::LanesToTheRight() const
 {
     const auto &description = intersections.front().lane_description;
     LaneID num_lanes_right = NumLanesToTheRight();
-    return boost::make_iterator_range(description.end() - num_lanes_right, description.end());
+    return std::ranges::subrange(description.end() - num_lanes_right, description.end());
 }
 
 } // namespace osrm::engine::guidance

include/extractor/class_data.hpp

@@ -6,6 +6,8 @@
 #include <algorithm>
 #include <cctype>
 #include <cstdint>
+#include <limits>
+#include <string>
 
 namespace osrm::extractor
 {

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>
@@ -26,7 +24,7 @@ template <typename RestrictionFilter> class NodeRestrictionMap
     // Find all restrictions applicable to (from,via,*) turns
     auto Restrictions(NodeID from, NodeID via) const
     {
-        return getRange(from, via) | boost::adaptors::filtered(index_filter);
+        return getRange(from, via) | std::views::filter(index_filter);
     };
 
     // Find all restrictions applicable to (from,via,to) turns
@@ -34,7 +32,7 @@ template <typename RestrictionFilter> class NodeRestrictionMap
     {
         const auto turnFilter = [this, to](const auto &restriction)
         { return index_filter(restriction) && restriction->IsTurnRestricted(to); };
-        return getRange(from, via) | boost::adaptors::filtered(turnFilter);
+        return getRange(from, via) | std::views::filter(turnFilter);
     };
 
   private:

include/extractor/restriction_graph.hpp

@@ -6,7 +6,7 @@
 #include "util/node_based_graph.hpp"
 #include "util/std_hash.hpp"
 #include "util/typedefs.hpp"
-
+#include <ranges>
 #include <unordered_map>
 
 namespace osrm::extractor
@@ -102,9 +102,9 @@ struct RestrictionGraph
     friend restriction_graph_details::transferBuilder;
     friend RestrictionGraph constructRestrictionGraph(const std::vector<TurnRestriction> &);
 
-    using EdgeRange = boost::iterator_range<std::vector<RestrictionEdge>::const_iterator>;
+    using EdgeRange = std::ranges::subrange<std::vector<RestrictionEdge>::const_iterator>;
     using RestrictionRange =
-        boost::iterator_range<std::vector<const TurnRestriction *>::const_iterator>;
+        std::ranges::subrange<std::vector<const TurnRestriction *>::const_iterator>;
     using EdgeKey = std::pair<NodeID, NodeID>;
 
     // Helper functions for iterating over node restrictions and edges

include/extractor/segment_data_container.hpp

@@ -7,11 +7,8 @@
 
 #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 <ranges>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -79,12 +76,12 @@ 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)
@@ -92,7 +89,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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)
@@ -100,7 +97,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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)
@@ -108,7 +105,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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)
@@ -116,7 +113,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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)
@@ -124,7 +121,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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)
@@ -132,7 +129,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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
@@ -140,12 +137,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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
@@ -153,7 +150,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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
@@ -161,7 +158,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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
@@ -169,7 +166,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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
@@ -177,7 +174,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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
@@ -185,7 +182,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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
@@ -193,7 +190,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         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/bisection_graph_view.hpp

@@ -5,7 +5,7 @@
 
 #include <boost/iterator/filter_iterator.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/range/iterator_range.hpp>
+#include <ranges>
 
 #include <cstddef>
 #include <cstdint>
@@ -40,7 +40,7 @@ class BisectionGraphView
     // Iteration over all nodes (direct access into the node)
     ConstNodeIterator Begin() const;
     ConstNodeIterator End() const;
-    auto Nodes() const { return boost::make_iterator_range(begin, end); }
+    auto Nodes() const { return std::ranges::subrange(begin, end); }
 
     // Re-Construct the ID of a node from a reference
     NodeID GetID(const NodeT &node) const;

include/partitioner/cell_storage.hpp

@@ -14,9 +14,7 @@
 
 #include "customizer/cell_metric.hpp"
 
-#include <boost/iterator/iterator_facade.hpp>
+#include <ranges>
-#include <boost/range/iterator_range.hpp>
-
 #include <tbb/parallel_sort.h>
 
 #include <algorithm>
@@ -128,19 +126,19 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
             friend class ::boost::iterator_core_access;
             ValuePtrT current;
-            const std::size_t stride;
+            std::size_t stride;
         };
 
         template <typename ValuePtr> auto GetOutRange(const ValuePtr ptr, const NodeID node) const
         {
             auto iter = std::find(source_boundary, source_boundary + num_source_nodes, node);
             if (iter == source_boundary + num_source_nodes)
-                return boost::make_iterator_range(ptr, ptr);
+                return std::ranges::subrange(ptr, ptr);
 
             auto row = std::distance(source_boundary, iter);
             auto begin = ptr + num_destination_nodes * row;
             auto end = begin + num_destination_nodes;
-            return boost::make_iterator_range(begin, end);
+            return std::ranges::subrange(begin, end);
         }
 
         template <typename ValuePtr> auto GetInRange(const ValuePtr ptr, const NodeID node) const
@@ -148,14 +146,14 @@ template <storage::Ownership Ownership> class CellStorageImpl
             auto iter =
                 std::find(destination_boundary, destination_boundary + num_destination_nodes, node);
             if (iter == destination_boundary + num_destination_nodes)
-                return boost::make_iterator_range(ColumnIterator<ValuePtr>{},
+                return std::ranges::subrange(ColumnIterator<ValuePtr>{},
-                                                  ColumnIterator<ValuePtr>{});
+                                             ColumnIterator<ValuePtr>{});
 
             auto column = std::distance(destination_boundary, iter);
             auto begin = ColumnIterator<ValuePtr>{ptr + column, num_destination_nodes};
             auto end = ColumnIterator<ValuePtr>{
                 ptr + column + num_source_nodes * num_destination_nodes, num_destination_nodes};
-            return boost::make_iterator_range(begin, end);
+            return std::ranges::subrange(begin, end);
         }
 
       public:
@@ -173,13 +171,13 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
         auto GetSourceNodes() const
         {
-            return boost::make_iterator_range(source_boundary, source_boundary + num_source_nodes);
+            return std::ranges::subrange(source_boundary, source_boundary + num_source_nodes);
         }
 
         auto GetDestinationNodes() const
         {
-            return boost::make_iterator_range(destination_boundary,
+            return std::ranges::subrange(destination_boundary,
-                                              destination_boundary + num_destination_nodes);
+                                         destination_boundary + num_destination_nodes);
         }
 
         CellImpl(const CellData &data,

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/partitioner/partition_graph.hpp

@@ -8,8 +8,7 @@
 #include <vector>
 
 #include "util/typedefs.hpp"
-#include <boost/range/iterator_range.hpp>
+#include <ranges>
-
 namespace osrm::partitioner
 {
 
@@ -84,26 +83,26 @@ template <typename NodeEntryT, typename EdgeEntryT> class RemappableGraph
 
     auto Edges(const NodeID nid)
     {
-        return boost::make_iterator_range(edges.begin() + nodes[nid].edges_begin,
+        return std::ranges::subrange(edges.begin() + nodes[nid].edges_begin,
-                                          edges.begin() + nodes[nid].edges_end);
+                                     edges.begin() + nodes[nid].edges_end);
     }
 
     auto Edges(const NodeID nid) const
     {
-        return boost::make_iterator_range(edges.begin() + nodes[nid].edges_begin,
+        return std::ranges::subrange(edges.begin() + nodes[nid].edges_begin,
-                                          edges.begin() + nodes[nid].edges_end);
+                                     edges.begin() + nodes[nid].edges_end);
     }
 
     auto Edges(const NodeT &node)
     {
-        return boost::make_iterator_range(edges.begin() + node.edges_begin,
+        return std::ranges::subrange(edges.begin() + node.edges_begin,
-                                          edges.begin() + node.edges_end);
+                                     edges.begin() + node.edges_end);
     }
 
     auto Edges(const NodeT &node) const
     {
-        return boost::make_iterator_range(edges.begin() + node.edges_begin,
+        return std::ranges::subrange(edges.begin() + node.edges_begin,
-                                          edges.begin() + node.edges_end);
+                                     edges.begin() + node.edges_end);
     }
 
     auto BeginEdges(const NodeID nid) const { return edges.begin() + nodes[nid].edges_begin; }
@@ -118,8 +117,8 @@ template <typename NodeEntryT, typename EdgeEntryT> class RemappableGraph
     EdgeID EndEdgeID(const NodeID nid) const { return nodes[nid].edges_end; }
 
     // iterate over all nodes
-    auto Nodes() { return boost::make_iterator_range(nodes.begin(), nodes.end()); }
+    auto Nodes() { return std::ranges::subrange(nodes.begin(), nodes.end()); }
-    auto Nodes() const { return boost::make_iterator_range(nodes.begin(), nodes.end()); }
+    auto Nodes() const { return std::ranges::subrange(nodes.begin(), nodes.end()); }
 
     NodeID GetID(const NodeT &node) const
     {

include/util/bit_range.hpp

@@ -4,7 +4,7 @@
 #include "util/msb.hpp"
 #include <bit>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/range/iterator_range.hpp>
+#include <ranges>
 
 namespace osrm::util
 {
@@ -58,7 +58,7 @@ class BitIterator : public boost::iterator_facade<BitIterator<DataT>,
 // Returns range over all 1 bits of value
 template <typename T> auto makeBitRange(const T value)
 {
-    return boost::make_iterator_range(BitIterator<T>{value}, BitIterator<T>{});
+    return std::ranges::subrange(BitIterator<T>{value}, BitIterator<T>{});
 }
 } // namespace osrm::util
 

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);
+                        forward_datasource_range[edge.fwd_segment_position];
-                    const auto reverse_datasource_idx = reverse_datasource_range(
+                    const auto reverse_datasource_idx =
-                        reverse_datasource_range.size() - edge.fwd_segment_position - 1);
+                        reverse_datasource_range[reverse_datasource_range.size() -
+                                                 edge.fwd_segment_position - 1];
 
                     const auto is_startpoint = edge.is_startpoint;
 

src/engine/routing_algorithms/many_to_many_ch.cpp

@@ -2,7 +2,7 @@
 #include "engine/routing_algorithms/routing_base_ch.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/range/iterator_range_core.hpp>
+#include <ranges>
 
 #include <limits>
 #include <memory>
@@ -106,7 +106,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                                                search_space_with_buckets.end(),
                                                heapNode.node,
                                                NodeBucket::Compare());
-    for (const auto &current_bucket : boost::make_iterator_range(bucket_list))
+    for (const auto &current_bucket : std::ranges::subrange(bucket_list.first, bucket_list.second))
     {
         // Get target id from bucket entry
         const auto column_index = current_bucket.column_index;

src/engine/routing_algorithms/many_to_many_mld.cpp

@@ -2,7 +2,7 @@
 #include "engine/routing_algorithms/routing_base_mld.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/range/iterator_range_core.hpp>
+#include <ranges>
 
 #include <limits>
 #include <memory>
@@ -148,8 +148,8 @@ void relaxOutgoingEdges(
                     }
                 }
                 ++destination;
-                shortcut_durations.advance_begin(1);
+                shortcut_durations.advance(1);
-                shortcut_distances.advance_begin(1);
+                shortcut_distances.advance(1);
             }
             BOOST_ASSERT(shortcut_durations.empty());
             BOOST_ASSERT(shortcut_distances.empty());
@@ -169,8 +169,8 @@ void relaxOutgoingEdges(
                 if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
                     const auto to_weight = heapNode.weight + shortcut_weight;
-                    const auto to_duration = heapNode.data.duration + shortcut_durations.front();
+                    const auto to_duration = heapNode.data.duration + *shortcut_durations.begin();
-                    const auto to_distance = heapNode.data.distance + shortcut_distances.front();
+                    const auto to_distance = heapNode.data.distance + *shortcut_distances.begin();
                     const auto toHeapNode = query_heap.GetHeapNodeIfWasInserted(to);
                     if (!toHeapNode)
                     {
@@ -189,8 +189,8 @@ void relaxOutgoingEdges(
                     }
                 }
                 ++source;
-                shortcut_durations.advance_begin(1);
+                shortcut_durations.advance(1);
-                shortcut_distances.advance_begin(1);
+                shortcut_distances.advance(1);
             }
             BOOST_ASSERT(shortcut_durations.empty());
             BOOST_ASSERT(shortcut_distances.empty());
@@ -426,7 +426,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                                                search_space_with_buckets.end(),
                                                heapNode.node,
                                                NodeBucket::Compare());
-    for (const auto &current_bucket : boost::make_iterator_range(bucket_list))
+    for (const auto &current_bucket : std::ranges::subrange(bucket_list.first, bucket_list.second))
     {
         // Get target id from bucket entry
         const auto column_idx = current_bucket.column_index;

src/extractor/edge_based_graph_factory.cpp

@@ -968,11 +968,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                 buffer->continuous_data.push_back(edge_with_data);
 
                                 // get conditional restrictions that apply to this turn
-                                const auto &restrictions =
+                                auto restrictions = conditional_node_restriction_map.Restrictions(
-                                    conditional_node_restriction_map.Restrictions(
+                                    incoming_edge.node, outgoing_edge.node, outgoing_edge_target);
-                                        incoming_edge.node,
-                                        outgoing_edge.node,
-                                        outgoing_edge_target);
                                 for (const auto &restriction : restrictions)
                                 {
                                     buffer->conditionals.push_back(

src/extractor/intersection/intersection_analysis.cpp

@@ -424,13 +424,11 @@ double findEdgeLength(const IntersectionEdgeGeometries &geometries, const EdgeID
 }
 
 template <typename RestrictionsRange>
-bool isTurnRestricted(const RestrictionsRange &restrictions, const NodeID to)
+bool isTurnRestricted(RestrictionsRange restrictions, const NodeID to)
 {
     // Check if any of the restrictions would prevent a turn to 'to'
-    return std::any_of(restrictions.begin(),
+    return std::ranges::any_of(
-                       restrictions.end(),
+        restrictions, [&to](const auto &restriction) { return restriction->IsTurnRestricted(to); });
-                       [&to](const auto &restriction)
-                       { return restriction->IsTurnRestricted(to); });
 }
 
 bool isTurnAllowed(const util::NodeBasedDynamicGraph &graph,

src/extractor/restriction_graph.cpp

@@ -5,8 +5,6 @@
 #include "util/timing_util.hpp"
 #include <util/for_each_pair.hpp>
 
-#include <boost/range/algorithm/copy.hpp>
-
 namespace osrm::extractor
 {
 
@@ -276,16 +274,16 @@ RestrictionGraph constructRestrictionGraph(const std::vector<TurnRestriction> &t
 RestrictionGraph::RestrictionRange RestrictionGraph::GetRestrictions(RestrictionID id) const
 {
     const auto &node = nodes[id];
-    return boost::make_iterator_range(restrictions.begin() + node.restrictions_begin_idx,
+    return std::ranges::subrange(restrictions.begin() + node.restrictions_begin_idx,
-                                      restrictions.begin() + node.restrictions_begin_idx +
+                                 restrictions.begin() + node.restrictions_begin_idx +
-                                          node.num_restrictions);
+                                     node.num_restrictions);
 }
 
 RestrictionGraph::EdgeRange RestrictionGraph::GetEdges(RestrictionID id) const
 {
     const auto &node = nodes[id];
-    return boost::make_iterator_range(edges.begin() + node.edges_begin_idx,
+    return std::ranges::subrange(edges.begin() + node.edges_begin_idx,
-                                      edges.begin() + node.edges_begin_idx + node.num_edges);
+                                 edges.begin() + node.edges_begin_idx + node.num_edges);
 }
 
 } // namespace osrm::extractor

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()))

unit_tests/engine/offline_facade.cpp

@@ -4,6 +4,7 @@
 #include "util/integer_range.hpp"
 
 #include <boost/test/unit_test.hpp>
+#include <ranges>
 
 namespace osrm::engine
 {
@@ -71,20 +72,17 @@ struct ExternalCellStorage
     {
         auto GetOutWeight(NodeID /*node*/) const
         {
-            return boost::make_iterator_range((EdgeWeight *)0, (EdgeWeight *)0);
+            return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0);
         }
 
         auto GetInWeight(NodeID /*node*/) const
         {
-            return boost::make_iterator_range((EdgeWeight *)0, (EdgeWeight *)0);
+            return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0);
         }
 
-        auto GetSourceNodes() const { return boost::make_iterator_range((NodeID *)0, (NodeID *)0); }
+        auto GetSourceNodes() const { return std::ranges::subrange((NodeID *)0, (NodeID *)0); }
 
-        auto GetDestinationNodes() const
+        auto GetDestinationNodes() const { return std::ranges::subrange((NodeID *)0, (NodeID *)0); }
-        {
-            return boost::make_iterator_range((NodeID *)0, (NodeID *)0);
-        }
     };
 
     using Cell = CellImpl;

unit_tests/mocks/mock_datafacade.hpp

@@ -54,7 +54,7 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     {
         static NodeID data[] = {0, 1, 2, 3};
         static extractor::SegmentDataView::SegmentNodeVector nodes(data, 4);
-        return boost::make_iterator_range(nodes.cbegin(), nodes.cend());
+        return std::ranges::subrange(nodes.cbegin(), nodes.cend());
     }
     NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const override
     {

unit_tests/util/packed_vector.cpp

@@ -3,14 +3,11 @@
 
 #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/unit_test.hpp>
-
 #include <algorithm>
+#include <boost/test/unit_test.hpp>
 #include <numeric>
 #include <random>
+#include <ranges>
 
 BOOST_AUTO_TEST_SUITE(packed_vector_test)
 
@@ -84,22 +81,22 @@ BOOST_AUTO_TEST_CASE(packed_vector_iterator_test)
     }
     BOOST_CHECK_EQUAL(vec_idx, packed_vec.size());
 
-    auto range = boost::make_iterator_range(packed_vec.cbegin(), packed_vec.cend());
+    auto range = std::ranges::subrange(packed_vec.cbegin(), packed_vec.cend());
     BOOST_CHECK_EQUAL(range.size(), packed_vec.size());
     for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
     {
         BOOST_CHECK_EQUAL(packed_vec[idx], range[idx]);
     }
 
-    auto reverse_range = boost::adaptors::reverse(
+    auto reverse_range =
-        boost::make_iterator_range(packed_vec.cbegin(), packed_vec.cend()));
+        std::ranges::subrange(packed_vec.cbegin(), packed_vec.cend()) | std::views::reverse;
     BOOST_CHECK_EQUAL(reverse_range.size(), packed_vec.size());
     for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
     {
         BOOST_CHECK_EQUAL(packed_vec[packed_vec.size() - 1 - idx], reverse_range[idx]);
     }
 
-    auto mut_range = boost::make_iterator_range(packed_vec.begin(), packed_vec.end());
+    auto mut_range = std::ranges::subrange(packed_vec.begin(), packed_vec.end());
     BOOST_CHECK_EQUAL(range.size(), packed_vec.size());
     for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
     {
@@ -107,7 +104,7 @@ BOOST_AUTO_TEST_CASE(packed_vector_iterator_test)
     }
 
     auto mut_reverse_range =
-        boost::adaptors::reverse(boost::make_iterator_range(packed_vec.begin(), packed_vec.end()));
+        std::ranges::subrange(packed_vec.begin(), packed_vec.end()) | std::views::reverse;
     BOOST_CHECK_EQUAL(reverse_range.size(), packed_vec.size());
     for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
     {
@@ -205,73 +202,4 @@ 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 WeightsAnyRange = 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(), SegmentWeight{0});
-
-    auto forward = boost::make_iterator_range(vector.begin() + 1, vector.begin() + 6);
-    auto forward_any = WeightsAnyRange(forward.begin(), forward.end());
-
-    CHECK_EQUAL_RANGE(forward,
-                      SegmentWeight{1},
-                      SegmentWeight{2},
-                      SegmentWeight{3},
-                      SegmentWeight{4},
-                      SegmentWeight{5});
-    CHECK_EQUAL_RANGE(forward_any,
-                      SegmentWeight{1},
-                      SegmentWeight{2},
-                      SegmentWeight{3},
-                      SegmentWeight{4},
-                      SegmentWeight{5});
-
-    auto reverse = boost::adaptors::reverse(forward);
-    auto reverse_any = WeightsAnyRange(reverse);
-    CHECK_EQUAL_RANGE(reverse,
-                      SegmentWeight{5},
-                      SegmentWeight{4},
-                      SegmentWeight{3},
-                      SegmentWeight{2},
-                      SegmentWeight{1});
-    CHECK_EQUAL_RANGE(reverse_any,
-                      SegmentWeight{5},
-                      SegmentWeight{4},
-                      SegmentWeight{3},
-                      SegmentWeight{2},
-                      SegmentWeight{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 WeightsAnyRange = 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 = WeightsAnyRange(forward.begin(), forward.end());
-
-    CHECK_EQUAL_RANGE(forward, SegmentWeight{1}, SegmentWeight{2}, SegmentWeight{3});
-    CHECK_EQUAL_RANGE(forward_any, SegmentWeight{1}, SegmentWeight{2}, SegmentWeight{3});
-
-    auto reverse = boost::adaptors::reverse(forward);
-    auto reverse_any = WeightsAnyRange(reverse);
-
-    CHECK_EQUAL_RANGE(reverse, SegmentWeight{3}, SegmentWeight{2}, SegmentWeight{1});
-    CHECK_EQUAL_RANGE(reverse_any, SegmentWeight{3}, SegmentWeight{2}, SegmentWeight{1});
-}
-
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/util/vector_view.cpp

@@ -1,8 +1,6 @@
 #include "util/vector_view.hpp"
 #include "util/typedefs.hpp"
 
-#include <boost/range/adaptor/reversed.hpp>
-#include <boost/range/iterator_range.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <algorithm>