Get rid of boost::optional leftovers (#6977)

.clang-tidy

@@ -17,6 +17,7 @@ Checks: >
     -bugprone-incorrect-enable-if,
     -bugprone-switch-missing-default-case,
     -bugprone-empty-catch,
+    -bugprone-unchecked-optional-access,
     -clang-analyzer-*,
     -clang-diagnostic-deprecated-declarations,
     -clang-diagnostic-constant-conversion,

CHANGELOG.md

@@ -24,6 +24,7 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
+      - CHANGED: Get rid of boost::optional leftovers. [#6977](https://github.com/Project-OSRM/osrm-backend/pull/6977)
       - CHANGED: Use Link Time Optimisation whenever possible. [#6967](https://github.com/Project-OSRM/osrm-backend/pull/6967)
       - CHANGED: Use struct instead of tuple to define UnpackedPath. [#6974](https://github.com/Project-OSRM/osrm-backend/pull/6974)
       - CHANGED: Micro performance optimisation in map matching. [#6976](https://github.com/Project-OSRM/osrm-backend/pull/6976)

include/engine/api/base_parameters.hpp

@@ -33,7 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "engine/hint.hpp"
 #include "util/coordinate.hpp"
 
-#include <boost/optional.hpp>
+#include <optional>
 
 #include <algorithm>
 #include <vector>
@@ -74,12 +74,12 @@ struct BaseParameters
     };
 
     std::vector<util::Coordinate> coordinates;
-    std::vector<boost::optional<Hint>> hints;
+    std::vector<std::optional<Hint>> hints;
-    std::vector<boost::optional<double>> radiuses;
+    std::vector<std::optional<double>> radiuses;
-    std::vector<boost::optional<Bearing>> bearings;
+    std::vector<std::optional<Bearing>> bearings;
-    std::vector<boost::optional<Approach>> approaches;
+    std::vector<std::optional<Approach>> approaches;
     std::vector<std::string> exclude;
-    boost::optional<OutputFormatType> format = OutputFormatType::JSON;
+    std::optional<OutputFormatType> format = OutputFormatType::JSON;
 
     // Adds hints to response which can be included in subsequent requests, see `hints` above.
     bool generate_hints = true;
@@ -90,10 +90,10 @@ struct BaseParameters
     SnappingType snapping = SnappingType::Default;
 
     BaseParameters(std::vector<util::Coordinate> coordinates_ = {},
-                   std::vector<boost::optional<Hint>> hints_ = {},
+                   std::vector<std::optional<Hint>> hints_ = {},
-                   std::vector<boost::optional<double>> radiuses_ = {},
+                   std::vector<std::optional<double>> radiuses_ = {},
-                   std::vector<boost::optional<Bearing>> bearings_ = {},
+                   std::vector<std::optional<Bearing>> bearings_ = {},
-                   std::vector<boost::optional<Approach>> approaches_ = {},
+                   std::vector<std::optional<Approach>> approaches_ = {},
                    bool generate_hints_ = true,
                    std::vector<std::string> exclude = {},
                    const SnappingType snapping_ = SnappingType::Default)
@@ -112,7 +112,7 @@ struct BaseParameters
                (approaches.empty() || approaches.size() == coordinates.size()) &&
                std::all_of(bearings.begin(),
                            bearings.end(),
-                           [](const boost::optional<Bearing> &bearing_and_range)
+                           [](const std::optional<Bearing> &bearing_and_range)
                            {
                                if (bearing_and_range)
                                {

include/engine/api/json_factory.hpp

@@ -12,7 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"
 
-#include <boost/optional.hpp>
+#include <optional>
 
 #include <algorithm>
 #include <iterator>
@@ -90,7 +90,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo
 
 util::json::Object makeRoute(const guidance::Route &route,
                              util::json::Array legs,
-                             boost::optional<util::json::Value> geometry,
+                             std::optional<util::json::Value> geometry,
                              const char *weight_name);
 
 // Creates a Waypoint without Hint, see the Hint overload below

include/engine/api/nearest_api.hpp

@@ -45,7 +45,7 @@ class NearestAPI final : public BaseAPI
                       flatbuffers::FlatBufferBuilder &fb_result) const
     {
         auto data_timestamp = facade.GetTimestamp();
-        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
+        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
         if (!data_timestamp.empty())
         {
             data_version_string = fb_result.CreateString(data_timestamp);

include/engine/api/route_api.hpp

@@ -184,10 +184,10 @@ class RouteAPI : public BaseAPI
         return builder.CreateVectorOfStructs(coordinates);
     }
 
-    boost::optional<util::json::Value>
+    std::optional<util::json::Value>
-    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
+    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
     {
-        boost::optional<util::json::Value> json_geometry;
+        std::optional<util::json::Value> json_geometry;
         if (annotations)
         {
             auto begin = annotations->begin();
@@ -720,8 +720,7 @@ class RouteAPI : public BaseAPI
         std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
 
         auto route = guidance::assembleRoute(legs);
-        boost::optional<util::json::Value> json_overview =
+        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));
-            MakeGeometry(MakeOverview(leg_geometries));
 
         std::vector<util::json::Value> step_geometries;
         const auto total_step_count =
@@ -997,10 +996,10 @@ class RouteAPI : public BaseAPI
         return result;
     }
 
-    boost::optional<std::vector<Coordinate>>
+    std::optional<std::vector<Coordinate>>
     MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
     {
-        boost::optional<std::vector<Coordinate>> overview;
+        std::optional<std::vector<Coordinate>> overview;
         if (parameters.overview != RouteParameters::OverviewType::False)
         {
             const auto use_simplification =

include/engine/api/route_parameters.hpp

@@ -82,7 +82,7 @@ struct RouteParameters : public BaseParameters
                     const bool alternatives_,
                     const GeometriesType geometries_,
                     const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                     Args &&...args_)
         // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one
         // below.
@@ -100,7 +100,7 @@ struct RouteParameters : public BaseParameters
                     const bool annotations_,
                     const GeometriesType geometries_,
                     const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                     Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
@@ -118,7 +118,7 @@ struct RouteParameters : public BaseParameters
                     const AnnotationsType annotations_,
                     const GeometriesType geometries_,
                     const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                     Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u},
@@ -135,7 +135,7 @@ struct RouteParameters : public BaseParameters
                     const bool annotations_,
                     const GeometriesType geometries_,
                     const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
                     const Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
@@ -153,7 +153,7 @@ struct RouteParameters : public BaseParameters
                     const AnnotationsType annotations_,
                     const GeometriesType geometries_,
                     const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
                     Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
@@ -172,7 +172,7 @@ struct RouteParameters : public BaseParameters
     AnnotationsType annotations_type = AnnotationsType::None;
     GeometriesType geometries = GeometriesType::Polyline;
     OverviewType overview = OverviewType::Simplified;
-    boost::optional<bool> continue_straight;
+    std::optional<bool> continue_straight;
     std::vector<std::size_t> waypoints;
 
     bool IsValid() const

include/engine/api/trip_parameters.hpp

@@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "engine/api/route_parameters.hpp"
 
-#include <boost/optional.hpp>
+#include <optional>
 #include <vector>
 
 namespace osrm::engine::api

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -369,7 +369,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                                const double max_distance,
-                               const boost::optional<Bearing> bearing,
+                               const std::optional<Bearing> bearing,
                                const Approach approach,
                                const bool use_all_edges) const override final
     {
@@ -382,20 +382,20 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate input_coordinate,
                         const size_t max_results,
-                        const boost::optional<double> max_distance,
+                        const std::optional<double> max_distance,
-                        const boost::optional<Bearing> bearing,
+                        const std::optional<Bearing> bearing,
                         const Approach approach) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
         return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, max_results, max_distance, bearing, boost::none);
+            input_coordinate, approach, max_results, max_distance, bearing, std::nullopt);
     }
 
     PhantomCandidateAlternatives
     NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const boost::optional<double> max_distance,
+                                                     const std::optional<double> max_distance,
-                                                     const boost::optional<Bearing> bearing,
+                                                     const std::optional<Bearing> bearing,
                                                      const Approach approach,
                                                      const bool use_all_edges) const override final
     {

include/engine/datafacade/datafacade_base.hpp

@@ -35,6 +35,7 @@
 #include <cstddef>
 
 #include <engine/bearing.hpp>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -126,21 +127,21 @@ class BaseDataFacade
     virtual std::vector<PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                                const double max_distance,
-                               const boost::optional<Bearing> bearing,
+                               const std::optional<Bearing> bearing,
                                const Approach approach,
                                const bool use_all_edges) const = 0;
 
     virtual std::vector<PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate input_coordinate,
                         const size_t max_results,
-                        const boost::optional<double> max_distance,
+                        const std::optional<double> max_distance,
-                        const boost::optional<Bearing> bearing,
+                        const std::optional<Bearing> bearing,
                         const Approach approach) const = 0;
 
     virtual PhantomCandidateAlternatives
     NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const boost::optional<double> max_distance,
+                                                     const std::optional<double> max_distance,
-                                                     const boost::optional<Bearing> bearing,
+                                                     const std::optional<Bearing> bearing,
                                                      const Approach approach,
                                                      const bool use_all_edges) const = 0;
 

include/engine/engine_config.hpp

@@ -79,7 +79,7 @@ struct EngineConfig final
     int max_locations_map_matching = -1;
     double max_radius_map_matching = -1.0;
     int max_results_nearest = -1;
-    boost::optional<double> default_radius = -1.0;
+    double default_radius = -1.0;
     int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
     bool use_shared_memory = true;
     std::filesystem::path memory_file;

include/engine/geospatial_query.hpp

@@ -12,7 +12,7 @@
 
 #include "osrm/coordinate.hpp"
 
-#include <boost/optional.hpp>
+#include <optional>
 
 #include <algorithm>
 #include <cmath>
@@ -53,8 +53,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     NearestPhantomNodes(const util::Coordinate input_coordinate,
                         const Approach approach,
                         const double max_distance,
-                        const boost::optional<Bearing> bearing_with_range,
+                        const std::optional<Bearing> bearing_with_range,
-                        const boost::optional<bool> use_all_edges) const
+                        const std::optional<bool> use_all_edges) const
     {
         auto results = rtree.SearchInRange(
             input_coordinate,
@@ -85,9 +85,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     NearestPhantomNodes(const util::Coordinate input_coordinate,
                         const Approach approach,
                         const size_t max_results,
-                        const boost::optional<double> max_distance,
+                        const std::optional<double> max_distance,
-                        const boost::optional<Bearing> bearing_with_range,
+                        const std::optional<Bearing> bearing_with_range,
-                        const boost::optional<bool> use_all_edges) const
+                        const std::optional<bool> use_all_edges) const
     {
         auto results = rtree.Nearest(
             input_coordinate,
@@ -121,9 +121,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
         const util::Coordinate input_coordinate,
         const Approach approach,
-        const boost::optional<double> max_distance,
+        const std::optional<double> max_distance,
-        const boost::optional<Bearing> bearing_with_range,
+        const std::optional<Bearing> bearing_with_range,
-        const boost::optional<bool> use_all_edges) const
+        const std::optional<bool> use_all_edges) const
     {
         bool has_nearest = false;
         bool has_big_component = false;

include/engine/guidance/assemble_steps.hpp

@@ -17,9 +17,9 @@
 #include "util/guidance/turn_lanes.hpp"
 #include "util/typedefs.hpp"
 
-#include <boost/optional.hpp>
 #include <cstddef>
 #include <guidance/turn_bearing.hpp>
+#include <optional>
 #include <vector>
 
 namespace osrm::engine::guidance

include/engine/guidance/route_leg.hpp

@@ -3,7 +3,7 @@
 
 #include "engine/guidance/route_step.hpp"
 
-#include <boost/optional.hpp>
+#include <optional>
 
 #include <string>
 #include <vector>

include/engine/internal_route_result.hpp

@@ -15,7 +15,7 @@
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"
 
-#include <boost/optional.hpp>
+#include <optional>
 #include <vector>
 
 namespace osrm::engine
@@ -42,7 +42,7 @@ struct PathData
     // Source of the speed value on this road segment
     DatasourceID datasource_id;
     // If segment precedes a turn, ID of the turn itself
-    boost::optional<EdgeID> turn_edge;
+    std::optional<EdgeID> turn_edge;
 };
 
 struct InternalRouteResult

include/engine/plugins/match.hpp

@@ -22,7 +22,7 @@ class MatchPlugin : public BasePlugin
 
     MatchPlugin(const int max_locations_map_matching,
                 const double max_radius_map_matching,
-                const boost::optional<double> default_radius)
+                const std::optional<double> default_radius)
         : BasePlugin(default_radius), max_locations_map_matching(max_locations_map_matching),
           max_radius_map_matching(max_radius_map_matching)
     {

include/engine/plugins/nearest.hpp

@@ -13,7 +13,7 @@ namespace osrm::engine::plugins
 class NearestPlugin final : public BasePlugin
 {
   public:
-    explicit NearestPlugin(const int max_results, const boost::optional<double> default_radius);
+    explicit NearestPlugin(const int max_results, const std::optional<double> default_radius);
 
     Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::NearestParameters &params,

include/engine/plugins/plugin_base.hpp

@@ -29,7 +29,7 @@ class BasePlugin
   protected:
     BasePlugin() = default;
 
-    BasePlugin(const boost::optional<double> default_radius_) : default_radius(default_radius_) {}
+    BasePlugin(const std::optional<double> default_radius_) : default_radius(default_radius_) {}
 
     bool CheckAllCoordinates(const std::vector<util::Coordinate> &coordinates) const
     {
@@ -200,8 +200,8 @@ class BasePlugin
             phantom_nodes[i] = facade.NearestPhantomNodesInRange(
                 parameters.coordinates[i],
                 radiuses[i],
-                use_bearings ? parameters.bearings[i] : boost::none,
+                use_bearings ? parameters.bearings[i] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                            : engine::Approach::UNRESTRICTED,
                 use_all_edges);
         }
@@ -242,8 +242,8 @@ class BasePlugin
                 parameters.coordinates[i],
                 number_of_results,
                 use_radiuses ? parameters.radiuses[i] : default_radius,
-                use_bearings ? parameters.bearings[i] : boost::none,
+                use_bearings ? parameters.bearings[i] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                            : engine::Approach::UNRESTRICTED);
 
             // we didn't find a fitting node, return error
@@ -284,8 +284,8 @@ class BasePlugin
             alternatives[i] = facade.NearestCandidatesWithAlternativeFromBigComponent(
                 parameters.coordinates[i],
                 use_radiuses ? parameters.radiuses[i] : default_radius,
-                use_bearings ? parameters.bearings[i] : boost::none,
+                use_bearings ? parameters.bearings[i] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                            : engine::Approach::UNRESTRICTED,
                 use_all_edges);
 
@@ -325,7 +325,7 @@ class BasePlugin
                std::to_string(missing_index);
     }
 
-    const boost::optional<double> default_radius;
+    const std::optional<double> default_radius;
 };
 } // namespace osrm::engine::plugins
 

include/engine/plugins/table.hpp

@@ -15,7 +15,7 @@ class TablePlugin final : public BasePlugin
 {
   public:
     explicit TablePlugin(const int max_locations_distance_table,
-                         const boost::optional<double> default_radius);
+                         const std::optional<double> default_radius);
 
     Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::TableParameters &params,

include/engine/plugins/trip.hpp

@@ -32,7 +32,7 @@ class TripPlugin final : public BasePlugin
                                      const bool roundtrip) const;
 
   public:
-    explicit TripPlugin(const int max_locations_trip_, boost::optional<double> default_radius)
+    explicit TripPlugin(const int max_locations_trip_, std::optional<double> default_radius)
         : BasePlugin(default_radius), max_locations_trip(max_locations_trip_)
     {
     }

include/engine/plugins/viaroute.hpp

@@ -27,7 +27,7 @@ class ViaRoutePlugin final : public BasePlugin
   public:
     explicit ViaRoutePlugin(int max_locations_viaroute,
                             int max_alternatives,
-                            boost::optional<double> default_radius);
+                            std::optional<double> default_radius);
 
     Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::RouteParameters &route_parameters,

include/engine/routing_algorithms.hpp

@@ -25,7 +25,7 @@ class RoutingAlgorithmsInterface
 
     virtual InternalRouteResult
     ShortestPathSearch(const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                       const boost::optional<bool> continue_straight_at_waypoint) const = 0;
+                       const std::optional<bool> continue_straight_at_waypoint) const = 0;
 
     virtual InternalRouteResult
     DirectShortestPathSearch(const PhantomEndpointCandidates &endpoint_candidates) const = 0;
@@ -40,7 +40,7 @@ class RoutingAlgorithmsInterface
     MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                 const std::vector<util::Coordinate> &trace_coordinates,
                 const std::vector<unsigned> &trace_timestamps,
-                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const std::vector<std::optional<double>> &trace_gps_precision,
                 const bool allow_splitting) const = 0;
 
     virtual std::vector<routing_algorithms::TurnData>
@@ -78,7 +78,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
 
     InternalRouteResult ShortestPathSearch(
         const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-        const boost::optional<bool> continue_straight_at_waypoint) const final override;
+        const std::optional<bool> continue_straight_at_waypoint) const final override;
 
     InternalRouteResult DirectShortestPathSearch(
         const PhantomEndpointCandidates &endpoint_candidates) const final override;
@@ -93,7 +93,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
     MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                 const std::vector<util::Coordinate> &trace_coordinates,
                 const std::vector<unsigned> &trace_timestamps,
-                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const std::vector<std::optional<double>> &trace_gps_precision,
                 const bool allow_splitting) const final override;
 
     std::vector<routing_algorithms::TurnData>
@@ -160,7 +160,7 @@ InternalManyRoutesResult RoutingAlgorithms<Algorithm>::AlternativePathSearch(
 template <typename Algorithm>
 InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
     const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-    const boost::optional<bool> continue_straight_at_waypoint) const
+    const std::optional<bool> continue_straight_at_waypoint) const
 {
     return routing_algorithms::shortestPathSearch(
         heaps, *facade, waypoint_candidates, continue_straight_at_waypoint);
@@ -178,7 +178,7 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatc
     const routing_algorithms::CandidateLists &candidates_list,
     const std::vector<util::Coordinate> &trace_coordinates,
     const std::vector<unsigned> &trace_timestamps,
-    const std::vector<boost::optional<double>> &trace_gps_precision,
+    const std::vector<std::optional<double>> &trace_gps_precision,
     const bool allow_splitting) const
 {
     return routing_algorithms::mapMatching(heaps,

include/engine/routing_algorithms/map_matching.hpp

@@ -24,7 +24,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                             const CandidateLists &candidates_list,
                             const std::vector<util::Coordinate> &trace_coordinates,
                             const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<boost::optional<double>> &trace_gps_precision,
+                            const std::vector<std::optional<double>> &trace_gps_precision,
                             const bool allow_splitting);
 
 } // namespace osrm::engine::routing_algorithms

include/engine/routing_algorithms/routing_base.hpp

@@ -258,7 +258,7 @@ void annotatePath(const FacadeT &facade,
                                              alias_cast<EdgeDuration>(duration_vector[segment_idx]),
                                              {0},
                                              datasource_vector[segment_idx],
-                                             boost::none});
+                                             std::nullopt});
         }
         BOOST_ASSERT(!unpacked_path.empty());
 
@@ -315,7 +315,7 @@ void annotatePath(const FacadeT &facade,
                      alias_cast<EdgeDuration>(duration_vector[segment_idx]),
                      {0},
                      datasource_vector[segment_idx],
-                     boost::none});
+                     std::nullopt});
     }
 
     if (!unpacked_path.empty())

include/engine/routing_algorithms/shortest_path.hpp

@@ -14,7 +14,7 @@ InternalRouteResult
 shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                    const DataFacade<Algorithm> &facade,
                    const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+                   const std::optional<bool> continue_straight_at_waypoint);
 
 } // namespace osrm::engine::routing_algorithms
 

include/engine/routing_algorithms/shortest_path_impl.hpp

@@ -4,7 +4,7 @@
 #include "engine/routing_algorithms/shortest_path.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
+#include <optional>
 
 namespace osrm::engine::routing_algorithms
 {
@@ -339,10 +339,10 @@ struct leg_connections
 {
     // X_to_Y = i can be read as
     // sources[i].X is the source of the shortest leg path to target.Y
-    boost::optional<size_t> forward_to_forward;
+    std::optional<size_t> forward_to_forward;
-    boost::optional<size_t> reverse_to_forward;
+    std::optional<size_t> reverse_to_forward;
-    boost::optional<size_t> forward_to_reverse;
+    std::optional<size_t> forward_to_reverse;
-    boost::optional<size_t> reverse_to_reverse;
+    std::optional<size_t> reverse_to_reverse;
 };
 
 // Identify which of the source candidates segments is being used for paths to the
@@ -771,7 +771,7 @@ InternalRouteResult
 shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                    const DataFacade<Algorithm> &facade,
                    const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint)
+                   const std::optional<bool> continue_straight_at_waypoint)
 {
     const bool allow_uturn_at_waypoint =
         !(continue_straight_at_waypoint ? *continue_straight_at_waypoint

include/nodejs/node_osrm_support.hpp

@@ -21,7 +21,7 @@
 #include <napi.h>
 
 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
+#include <optional>
 
 #include <algorithm>
 #include <iterator>
@@ -395,11 +395,11 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
     return engine_config;
 }
 
-inline boost::optional<std::vector<osrm::Coordinate>>
+inline std::optional<std::vector<osrm::Coordinate>>
 parseCoordinateArray(const Napi::Array &coordinates_array)
 {
     Napi::HandleScope scope(coordinates_array.Env());
-    boost::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
+    std::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
     std::vector<osrm::Coordinate> temp_coordinates;
 
     for (uint32_t i = 0; i < coordinates_array.Length(); ++i)
@@ -450,7 +450,7 @@ parseCoordinateArray(const Napi::Array &coordinates_array)
                                       osrm::util::FloatLatitude{std::move(lat)});
     }
 
-    resulting_coordinates = boost::make_optional(std::move(temp_coordinates));
+    resulting_coordinates = std::make_optional(std::move(temp_coordinates));
     return resulting_coordinates;
 }
 
@@ -1023,7 +1023,7 @@ inline bool parseCommonParameters(const Napi::Object &obj, ParamType &params)
 
 inline PluginParameters argumentsToPluginParameters(
     const Napi::CallbackInfo &args,
-    const boost::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
+    const std::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
 {
     if (args.Length() < 3 || !args[1].IsObject())
     {

include/server/api/base_parameters_grammar.hpp

@@ -7,9 +7,9 @@
 #include "engine/hint.hpp"
 #include "engine/polyline_compressor.hpp"
 
-#include <boost/optional.hpp>
 #include <boost/phoenix.hpp>
 #include <boost/spirit/include/qi.hpp>
+#include <optional>
 
 #include <limits>
 #include <string>
@@ -88,7 +88,7 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
             }
             else
             {
-                base_parameters.hints.emplace_back(boost::none);
+                base_parameters.hints.emplace_back(std::nullopt);
             }
         };
 
@@ -96,13 +96,24 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
             [](engine::api::BaseParameters &base_parameters,
                boost::optional<boost::fusion::vector2<short, short>> bearing_range)
         {
-            boost::optional<engine::Bearing> bearing;
+            std::optional<engine::Bearing> bearing;
             if (bearing_range)
             {
                 bearing = engine::Bearing{boost::fusion::at_c<0>(*bearing_range),
                                           boost::fusion::at_c<1>(*bearing_range)};
             }
-            base_parameters.bearings.push_back(std::move(bearing));
+            base_parameters.bearings.push_back(bearing);
+        };
+
+        const auto add_approach = [](engine::api::BaseParameters &base_parameters,
+                                     boost::optional<osrm::engine::Approach> approach) {
+            base_parameters.approaches.push_back(approach ? std::make_optional(*approach)
+                                                          : std::nullopt);
+        };
+
+        const auto add_radius = [](engine::api::BaseParameters &base_parameters,
+                                   boost::optional<double> radius) {
+            base_parameters.radiuses.push_back(radius ? std::make_optional(*radius) : std::nullopt);
         };
 
         polyline_chars = qi::char_("a-zA-Z0-9_.--[]{}@?|\\%~`^");
@@ -144,9 +155,9 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
             ((location_rule % ';') | polyline_rule |
              polyline6_rule)[ph::bind(&engine::api::BaseParameters::coordinates, qi::_r1) = qi::_1];
 
-        radiuses_rule = qi::lit("radiuses=") >
+        radiuses_rule =
-                        (-(qi::double_ | unlimited_rule) %
+            qi::lit("radiuses=") >
-                         ';')[ph::bind(&engine::api::BaseParameters::radiuses, qi::_r1) = qi::_1];
+            (-(qi::double_ | unlimited_rule))[ph::bind(add_radius, qi::_r1, qi::_1)] % ';';
 
         hints_rule =
             qi::lit("hints=") >
@@ -170,8 +181,7 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
             "curb", engine::Approach::CURB)("opposite", engine::Approach::OPPOSITE);
 
         approach_rule = qi::lit("approaches=") >
-                        (-approach_type %
+                        (-approach_type)[ph::bind(add_approach, qi::_r1, qi::_1)] % ';';
-                         ';')[ph::bind(&engine::api::BaseParameters::approaches, qi::_r1) = qi::_1];
 
         snapping_type.add("default", engine::api::BaseParameters::SnappingType::Default)(
             "any", engine::api::BaseParameters::SnappingType::Any);

include/server/api/parameters_parser.hpp

@@ -26,13 +26,13 @@ using is_parameter_t =
 // Starts parsing and iter and modifies it until iter == end or parsing failed
 template <typename ParameterT,
           typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0>
-boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
+std::optional<ParameterT> parseParameters(std::string::iterator &iter,
-                                            const std::string::iterator end);
+                                          const std::string::iterator end);
 
 // Copy on purpose because we need mutability
 template <typename ParameterT,
           typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0>
-boost::optional<ParameterT> parseParameters(std::string options_string)
+std::optional<ParameterT> parseParameters(std::string options_string)
 {
     auto first = options_string.begin();
     const auto last = options_string.end();

include/server/api/url_parser.hpp

@@ -3,7 +3,7 @@
 
 #include "server/api/parsed_url.hpp"
 
-#include <boost/optional.hpp>
+#include <optional>
 
 #include <string>
 
@@ -11,9 +11,9 @@ namespace osrm::server::api
 {
 
 // Starts parsing and iter and modifies it until iter == end or parsing failed
-boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end);
+std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end);
 
-inline boost::optional<ParsedURL> parseURL(std::string url_string)
+inline std::optional<ParsedURL> parseURL(std::string url_string)
 {
     auto iter = url_string.begin();
     return parseURL(iter, url_string.end());

src/benchmarks/bench.cpp

@@ -360,8 +360,8 @@ void runRouteBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati
 
                       if (benchmark.radius)
                       {
-                          params.radiuses = std::vector<boost::optional<double>>(
+                          params.radiuses = std::vector<std::optional<double>>(
-                              params.coordinates.size(), boost::make_optional(*benchmark.radius));
+                              params.coordinates.size(), std::make_optional(*benchmark.radius));
                       }
 
                       engine::api::ResultT result = json::Object();

src/benchmarks/route.cpp

@@ -66,8 +66,8 @@ try
 
         if (benchmark.radius)
         {
-            params.radiuses = std::vector<boost::optional<double>>(
+            params.radiuses = std::vector<std::optional<double>>(
-                params.coordinates.size(), boost::make_optional(*benchmark.radius));
+                params.coordinates.size(), std::make_optional(*benchmark.radius));
         }
 
         TIMER_START(routes);

src/engine/api/json_factory.cpp

@@ -11,7 +11,7 @@
 #include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
+#include <optional>
 
 #include <algorithm>
 #include <iterator>
@@ -215,7 +215,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo
 
 util::json::Object makeRoute(const guidance::Route &route,
                              util::json::Array legs,
-                             boost::optional<util::json::Value> geometry,
+                             std::optional<util::json::Value> geometry,
                              const char *weight_name)
 {
     util::json::Object json_route;

src/engine/engine_config.cpp

@@ -12,15 +12,13 @@ bool EngineConfig::IsValid() const
     const auto unlimited_or_more_than = [](const auto v, const auto limit)
     { return v == -1 || v > limit; };
 
-    const bool limits_valid =
+    const bool limits_valid = unlimited_or_more_than(max_locations_distance_table, 2) &&
-        unlimited_or_more_than(max_locations_distance_table, 2) &&
+                              unlimited_or_more_than(max_locations_map_matching, 2) &&
-        unlimited_or_more_than(max_locations_map_matching, 2) &&
+                              unlimited_or_more_than(max_radius_map_matching, 0) &&
-        unlimited_or_more_than(max_radius_map_matching, 0) &&
+                              unlimited_or_more_than(max_locations_trip, 2) &&
-        unlimited_or_more_than(max_locations_trip, 2) &&
+                              unlimited_or_more_than(max_locations_viaroute, 2) &&
-        unlimited_or_more_than(max_locations_viaroute, 2) &&
+                              unlimited_or_more_than(max_results_nearest, 0) &&
-        unlimited_or_more_than(max_results_nearest, 0) &&
+                              unlimited_or_more_than(default_radius, 0) && max_alternatives >= 0;
-        (!default_radius.has_value() || unlimited_or_more_than(*default_radius, 0)) &&
-        max_alternatives >= 0;
 
     return ((use_shared_memory && all_path_are_empty) || (use_mmap && storage_config.IsValid()) ||
             storage_config.IsValid()) &&

src/engine/plugins/match.cpp

@@ -194,7 +194,7 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
             tidied.parameters.radiuses.begin(),
             tidied.parameters.radiuses.end(),
             search_radiuses.begin(),
-            [default_radius = this->default_radius](const boost::optional<double> &maybe_radius)
+            [default_radius = this->default_radius](const std::optional<double> &maybe_radius)
             {
                 if (maybe_radius)
                 {

src/engine/plugins/nearest.cpp

@@ -10,7 +10,7 @@
 namespace osrm::engine::plugins
 {
 
-NearestPlugin::NearestPlugin(const int max_results_, const boost::optional<double> default_radius_)
+NearestPlugin::NearestPlugin(const int max_results_, const std::optional<double> default_radius_)
     : BasePlugin(default_radius_), max_results{max_results_}
 {
 }

src/engine/plugins/table.cpp

@@ -15,7 +15,7 @@ namespace osrm::engine::plugins
 {
 
 TablePlugin::TablePlugin(const int max_locations_distance_table,
-                         const boost::optional<double> default_radius)
+                         const std::optional<double> default_radius)
     : BasePlugin(default_radius), max_locations_distance_table(max_locations_distance_table)
 {
 }

src/engine/plugins/viaroute.cpp

@@ -17,7 +17,7 @@ namespace osrm::engine::plugins
 
 ViaRoutePlugin::ViaRoutePlugin(int max_locations_viaroute,
                                int max_alternatives,
-                               boost::optional<double> default_radius)
+                               std::optional<double> default_radius)
     : BasePlugin(default_radius), max_locations_viaroute(max_locations_viaroute),
       max_alternatives(max_alternatives)
 {

src/engine/routing_algorithms/map_matching.cpp

@@ -70,7 +70,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                             const CandidateLists &candidates_list,
                             const std::vector<util::Coordinate> &trace_coordinates,
                             const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<boost::optional<double>> &trace_gps_precision,
+                            const std::vector<std::optional<double>> &trace_gps_precision,
                             const bool allow_splitting)
 {
     map_matching::MatchingConfidence confidence;
@@ -437,24 +437,22 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
 }
 
 // CH
-template SubMatchingList
+template SubMatchingList mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
-mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
+                                     const DataFacade<ch::Algorithm> &facade,
-            const DataFacade<ch::Algorithm> &facade,
+                                     const CandidateLists &candidates_list,
-            const CandidateLists &candidates_list,
+                                     const std::vector<util::Coordinate> &trace_coordinates,
-            const std::vector<util::Coordinate> &trace_coordinates,
+                                     const std::vector<unsigned> &trace_timestamps,
-            const std::vector<unsigned> &trace_timestamps,
+                                     const std::vector<std::optional<double>> &trace_gps_precision,
-            const std::vector<boost::optional<double>> &trace_gps_precision,
+                                     const bool allow_splitting);
-            const bool allow_splitting);
 
 // MLD
-template SubMatchingList
+template SubMatchingList mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
-mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
+                                     const DataFacade<mld::Algorithm> &facade,
-            const DataFacade<mld::Algorithm> &facade,
+                                     const CandidateLists &candidates_list,
-            const CandidateLists &candidates_list,
+                                     const std::vector<util::Coordinate> &trace_coordinates,
-            const std::vector<util::Coordinate> &trace_coordinates,
+                                     const std::vector<unsigned> &trace_timestamps,
-            const std::vector<unsigned> &trace_timestamps,
+                                     const std::vector<std::optional<double>> &trace_gps_precision,
-            const std::vector<boost::optional<double>> &trace_gps_precision,
+                                     const bool allow_splitting);
-            const bool allow_splitting);
 
 } // namespace osrm::engine::routing_algorithms
 

src/engine/routing_algorithms/shortest_path.cpp

@@ -9,12 +9,12 @@ template InternalRouteResult
 shortestPathSearch(SearchEngineData<ch::Algorithm> &engine_working_data,
                    const DataFacade<ch::Algorithm> &facade,
                    const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+                   const std::optional<bool> continue_straight_at_waypoint);
 
 template InternalRouteResult
 shortestPathSearch(SearchEngineData<mld::Algorithm> &engine_working_data,
                    const DataFacade<mld::Algorithm> &facade,
                    const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+                   const std::optional<bool> continue_straight_at_waypoint);
 
 } // namespace osrm::engine::routing_algorithms

src/server/api/parameters_parser.cpp

@@ -28,8 +28,8 @@ template <typename ParameterT,
           typename GrammarT,
           typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0,
           typename std::enable_if<detail::is_grammar_t<GrammarT>::value, int>::type = 0>
-boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
+std::optional<ParameterT> parseParameters(std::string::iterator &iter,
-                                            const std::string::iterator end)
+                                          const std::string::iterator end)
 {
     using It = std::decay<decltype(iter)>::type;
 
@@ -56,52 +56,52 @@ boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
         // as normal parser error
     }
 
-    return boost::none;
+    return std::nullopt;
 }
 } // namespace detail
 
 template <>
-boost::optional<engine::api::RouteParameters> parseParameters(std::string::iterator &iter,
+std::optional<engine::api::RouteParameters> parseParameters(std::string::iterator &iter,
-                                                              const std::string::iterator end)
+                                                            const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::RouteParameters, RouteParametersGrammar<>>(iter,
                                                                                            end);
 }
 
 template <>
-boost::optional<engine::api::TableParameters> parseParameters(std::string::iterator &iter,
+std::optional<engine::api::TableParameters> parseParameters(std::string::iterator &iter,
-                                                              const std::string::iterator end)
+                                                            const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::TableParameters, TableParametersGrammar<>>(iter,
                                                                                            end);
 }
 
 template <>
-boost::optional<engine::api::NearestParameters> parseParameters(std::string::iterator &iter,
+std::optional<engine::api::NearestParameters> parseParameters(std::string::iterator &iter,
-                                                                const std::string::iterator end)
+                                                              const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::NearestParameters, NearestParametersGrammar<>>(iter,
                                                                                                end);
 }
 
 template <>
-boost::optional<engine::api::TripParameters> parseParameters(std::string::iterator &iter,
+std::optional<engine::api::TripParameters> parseParameters(std::string::iterator &iter,
-                                                             const std::string::iterator end)
+                                                           const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::TripParameters, TripParametersGrammar<>>(iter, end);
 }
 
 template <>
-boost::optional<engine::api::MatchParameters> parseParameters(std::string::iterator &iter,
+std::optional<engine::api::MatchParameters> parseParameters(std::string::iterator &iter,
-                                                              const std::string::iterator end)
+                                                            const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::MatchParameters, MatchParametersGrammar<>>(iter,
                                                                                            end);
 }
 
 template <>
-boost::optional<engine::api::TileParameters> parseParameters(std::string::iterator &iter,
+std::optional<engine::api::TileParameters> parseParameters(std::string::iterator &iter,
-                                                             const std::string::iterator end)
+                                                           const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::TileParameters, TileParametersGrammar<>>(iter, end);
 }

src/server/api/url_parser.cpp

@@ -65,7 +65,7 @@ struct URLParser final : qi::grammar<Iterator, Into>
 namespace osrm::server::api
 {
 
-boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end)
+std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end)
 {
     using It = std::decay<decltype(iter)>::type;
 
@@ -77,7 +77,7 @@ boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::stri
         const auto ok = boost::spirit::qi::parse(iter, end, parser(boost::phoenix::val(iter)), out);
 
         if (ok && iter == end)
-            return boost::make_optional(out);
+            return std::make_optional(out);
     }
     catch (const qi::expectation_failure<It> &failure)
     {
@@ -86,7 +86,7 @@ boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::stri
         iter = failure.first;
     }
 
-    return boost::none;
+    return std::nullopt;
 }
 
 } // namespace osrm::server::api

src/tools/routed.cpp

@@ -186,7 +186,7 @@ inline unsigned generateServerProgramOptions(const int argc,
          value<double>(&config.max_radius_map_matching)->default_value(-1.0),
          "Max. radius size supported in map matching query. Default: unlimited.") //
         ("default-radius",
-         value<boost::optional<double>>(&config.default_radius)->default_value(-1.0),
+         value<double>(&config.default_radius)->default_value(-1.0),
          "Default radius size for queries. Default: unlimited.");
 
     // hidden options, will be allowed on command line, but will not be shown to the user

unit_tests/engine/collapse_internal_route_result.cpp

@@ -19,8 +19,8 @@ BOOST_AUTO_TEST_CASE(unchanged_collapse_route_result)
     PhantomNode target;
     source.forward_segment_id = {1, true};
     target.forward_segment_id = {6, true};
-    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, boost::none};
+    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, std::nullopt};
-    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, boost::none};
+    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, std::nullopt};
     InternalRouteResult one_leg_result;
     one_leg_result.unpacked_path_segments = {{pathy, kathy}};
     one_leg_result.leg_endpoints = {PhantomEndpoints{source, target}};
@@ -39,9 +39,9 @@ BOOST_AUTO_TEST_CASE(two_legs_to_one_leg)
 {
     // from_edge_based_node, turn_via_node, weight_until_turn, weight_of_turn,
     // duration_until_turn, duration_of_turn, datasource_id, turn_edge
-    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, boost::none};
+    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, std::nullopt};
-    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, boost::none};
+    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, std::nullopt};
-    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, boost::none};
+    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, std::nullopt};
     PhantomNode node_1;
     PhantomNode node_2;
     PhantomNode node_3;
@@ -74,11 +74,11 @@ BOOST_AUTO_TEST_CASE(two_legs_to_one_leg)
 
 BOOST_AUTO_TEST_CASE(three_legs_to_two_legs)
 {
-    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, boost::none};
+    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, std::nullopt};
-    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, boost::none};
+    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, std::nullopt};
-    PathData qathy{0, 5, {1}, {2}, {3}, {4}, 1, boost::none};
+    PathData qathy{0, 5, {1}, {2}, {3}, {4}, 1, std::nullopt};
-    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, boost::none};
+    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, std::nullopt};
-    PathData mathy{0, 4, {8}, {9}, {13}, {4}, 2, boost::none};
+    PathData mathy{0, 4, {8}, {9}, {13}, {4}, 2, std::nullopt};
     PhantomNode node_1;
     PhantomNode node_2;
     PhantomNode node_3;
@@ -131,9 +131,9 @@ BOOST_AUTO_TEST_CASE(three_legs_to_two_legs)
 
 BOOST_AUTO_TEST_CASE(two_legs_to_two_legs)
 {
-    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, boost::none};
+    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, std::nullopt};
-    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, boost::none};
+    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, std::nullopt};
-    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, boost::none};
+    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, std::nullopt};
     PhantomNode node_1;
     PhantomNode node_2;
     PhantomNode node_3;

unit_tests/engine/offline_facade.cpp

@@ -219,7 +219,7 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate /*input_coordinate*/,
                                const double /*max_distance*/,
-                               const boost::optional<engine::Bearing> /*bearing*/,
+                               const std::optional<engine::Bearing> /*bearing*/,
                                const engine::Approach /*approach*/,
                                const bool /*use_all_edges*/) const override
     {
@@ -229,8 +229,8 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate /*input_coordinate*/,
                         const size_t /*max_results*/,
-                        const boost::optional<double> /*max_distance*/,
+                        const std::optional<double> /*max_distance*/,
-                        const boost::optional<engine::Bearing> /*bearing*/,
+                        const std::optional<engine::Bearing> /*bearing*/,
                         const engine::Approach /*approach*/) const override
     {
         return {};
@@ -238,8 +238,8 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
 
     engine::PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
         const util::Coordinate /*input_coordinate*/,
-        const boost::optional<double> /*max_distance*/,
+        const std::optional<double> /*max_distance*/,
-        const boost::optional<engine::Bearing> /*bearing*/,
+        const std::optional<engine::Bearing> /*bearing*/,
         const engine::Approach /*approach*/,
         const bool /*use_all_edges*/) const override
     {

unit_tests/library/table.cpp

@@ -271,8 +271,8 @@ void test_table_no_segment_for_some_coordinates(bool use_json_only_api)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
     // resembles query option: `&radiuses=0;`
-    params.radiuses.push_back(boost::make_optional(0.));
+    params.radiuses.push_back(std::make_optional(0.));
-    params.radiuses.push_back(boost::none);
+    params.radiuses.push_back(std::nullopt);
 
     json::Object json_result;
     const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);

unit_tests/mocks/mock_datafacade.hpp

@@ -107,7 +107,7 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate /*input_coordinate*/,
                                const double /*max_distance*/,
-                               const boost::optional<engine::Bearing> /*bearing*/,
+                               const std::optional<engine::Bearing> /*bearing*/,
                                const engine::Approach /*approach*/,
                                const bool /*use_all_edges*/) const override
     {
@@ -117,8 +117,8 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate /*input_coordinate*/,
                         const size_t /*max_results*/,
-                        const boost::optional<double> /*max_distance*/,
+                        const std::optional<double> /*max_distance*/,
-                        const boost::optional<engine::Bearing> /*bearing*/,
+                        const std::optional<engine::Bearing> /*bearing*/,
                         const engine::Approach /*approach*/) const override
     {
         return {};
@@ -126,8 +126,8 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
 
     engine::PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
         const util::Coordinate /*input_coordinate*/,
-        const boost::optional<double> /*max_distance*/,
+        const std::optional<double> /*max_distance*/,
-        const boost::optional<engine::Bearing> /*bearing*/,
+        const std::optional<engine::Bearing> /*bearing*/,
         const engine::Approach /*approach*/,
         const bool /*use_all_edges*/) const override
     {

unit_tests/server/parameters_parser.cpp

@@ -32,6 +32,11 @@
                                           (R2)[i]->segment_hints.end());                           \
         }                                                                                          \
     }
+// TODO: we should be able to somehow make Boost.Test to print std::optional types
+BOOST_TEST_DONT_PRINT_LOG_VALUE(std::optional<double>)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(std::optional<osrm::engine::Approach>)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(std::optional<osrm::engine::Bearing>)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(std::optional<bool>)
 
 BOOST_AUTO_TEST_SUITE(api_parameters_parser)
 
@@ -216,7 +221,7 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     phantom_1.input_location = coords_1[0];
     engine::PhantomNode phantom_2;
     phantom_2.input_location = coords_1[1];
-    std::vector<boost::optional<engine::Hint>> hints_4 = {
+    std::vector<std::optional<engine::Hint>> hints_4 = {
         engine::Hint{{engine::SegmentHint{phantom_1, 0x1337}}},
         engine::Hint{{engine::SegmentHint{phantom_2, 0x1337}}}};
     RouteParameters reference_4{false,
@@ -224,11 +229,11 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                 false,
                                 RouteParameters::GeometriesType::Polyline,
                                 RouteParameters::OverviewType::Simplified,
-                                boost::optional<bool>{},
+                                std::optional<bool>{},
                                 coords_1,
                                 hints_4,
-                                std::vector<boost::optional<double>>{},
+                                std::vector<std::optional<double>>{},
-                                std::vector<boost::optional<engine::Bearing>>{}};
+                                std::vector<std::optional<engine::Bearing>>{}};
     auto result_4 = parseParameters<RouteParameters>(
         "1,2;3,4?steps=false&hints=" + hints_4[0]->ToBase64() + ";" + hints_4[1]->ToBase64());
     BOOST_CHECK(result_4);
@@ -244,8 +249,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     CHECK_EQUAL_RANGE(reference_4.coordinates, result_4->coordinates);
     CHECK_EQUAL_RANGE_OF_HINTS(reference_4.hints, result_4->hints);
 
-    std::vector<boost::optional<engine::Bearing>> bearings_4 = {
+    std::vector<std::optional<engine::Bearing>> bearings_4 = {
-        boost::none,
+        std::nullopt,
         engine::Bearing{200, 10},
         engine::Bearing{100, 5},
     };
@@ -254,10 +259,10 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                 false,
                                 RouteParameters::GeometriesType::Polyline,
                                 RouteParameters::OverviewType::Simplified,
-                                boost::optional<bool>{},
+                                std::optional<bool>{},
                                 coords_1,
-                                std::vector<boost::optional<engine::Hint>>{},
+                                std::vector<std::optional<engine::Hint>>{},
-                                std::vector<boost::optional<double>>{},
+                                std::vector<std::optional<double>>{},
                                 bearings_4};
     auto result_5 = parseParameters<RouteParameters>("1,2;3,4?steps=false&bearings=;200,10;100,5");
     BOOST_CHECK(result_5);
@@ -296,8 +301,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     auto result_7 = parseParameters<RouteParameters>("1,2;3,4?radiuses=;unlimited");
     RouteParameters reference_7{};
     reference_7.coordinates = coords_1;
-    reference_7.radiuses = {boost::none,
+    reference_7.radiuses = {std::nullopt,
-                            boost::make_optional(std::numeric_limits<double>::infinity())};
+                            std::make_optional(std::numeric_limits<double>::infinity())};
     BOOST_CHECK(result_7);
     BOOST_CHECK_EQUAL(reference_7.steps, result_7->steps);
     BOOST_CHECK_EQUAL(reference_7.alternatives, result_7->alternatives);
@@ -314,14 +319,14 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     auto result_8 = parseParameters<RouteParameters>("1,2;3,4?radiuses=;");
     RouteParameters reference_8{};
     reference_8.coordinates = coords_1;
-    reference_8.radiuses = {boost::none, boost::none};
+    reference_8.radiuses = {std::nullopt, std::nullopt};
     BOOST_CHECK(result_8);
     CHECK_EQUAL_RANGE(reference_8.radiuses, result_8->radiuses);
 
     auto result_9 = parseParameters<RouteParameters>("1,2?radiuses=");
     RouteParameters reference_9{};
     reference_9.coordinates = coords_1;
-    reference_9.radiuses = {boost::none};
+    reference_9.radiuses = {std::nullopt};
     BOOST_CHECK(result_9);
     CHECK_EQUAL_RANGE(reference_9.radiuses, result_9->radiuses);
 
@@ -335,7 +340,7 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     phantom_3.input_location = coords_3[0];
     engine::PhantomNode phantom_4;
     phantom_4.input_location = coords_3[2];
-    std::vector<boost::optional<engine::Hint>> hints_10 = {
+    std::vector<std::optional<engine::Hint>> hints_10 = {
         engine::Hint{{engine::SegmentHint{phantom_3, 0x1337}}},
         {},
         engine::Hint{{engine::SegmentHint{phantom_4, 0x1337}}},
@@ -346,11 +351,11 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                  false,
                                  RouteParameters::GeometriesType::Polyline,
                                  RouteParameters::OverviewType::Simplified,
-                                 boost::optional<bool>{},
+                                 std::optional<bool>{},
                                  coords_3,
                                  hints_10,
-                                 std::vector<boost::optional<double>>{},
+                                 std::vector<std::optional<double>>{},
-                                 std::vector<boost::optional<engine::Bearing>>{}};
+                                 std::vector<std::optional<engine::Bearing>>{}};
     auto result_10 = parseParameters<RouteParameters>(
         "1,2;3,4;5,6;7,8?steps=false&hints=" + hints_10[0]->ToBase64() + ";;" +
         hints_10[2]->ToBase64() + ";");
@@ -447,8 +452,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     BOOST_CHECK_EQUAL(result_2->annotations_type == RouteParameters::AnnotationsType::All, true);
     BOOST_CHECK_EQUAL(result_17->annotations, true);
 
-    std::vector<boost::optional<engine::Approach>> approaches_18 = {
+    std::vector<std::optional<engine::Approach>> approaches_18 = {
-        boost::none,
+        std::nullopt,
         engine::Approach::CURB,
         engine::Approach::UNRESTRICTED,
         engine::Approach::OPPOSITE,
@@ -458,11 +463,11 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                  false,
                                  RouteParameters::GeometriesType::Polyline,
                                  RouteParameters::OverviewType::Simplified,
-                                 boost::optional<bool>{},
+                                 std::optional<bool>{},
                                  coords_3,
-                                 std::vector<boost::optional<engine::Hint>>{},
+                                 std::vector<std::optional<engine::Hint>>{},
-                                 std::vector<boost::optional<double>>{},
+                                 std::vector<std::optional<double>>{},
-                                 std::vector<boost::optional<engine::Bearing>>{},
+                                 std::vector<std::optional<engine::Bearing>>{},
                                  approaches_18};
 
     auto result_18 = parseParameters<RouteParameters>(
@@ -778,6 +783,7 @@ BOOST_AUTO_TEST_CASE(valid_trip_urls)
     reference_1.coordinates = coords_1;
     auto result_1 = parseParameters<TripParameters>("1,2;3,4");
     BOOST_CHECK(result_1);
+
     CHECK_EQUAL_RANGE(reference_1.radiuses, result_1->radiuses);
     CHECK_EQUAL_RANGE(reference_1.coordinates, result_1->coordinates);
 

unit_tests/util/static_rtree.cpp

@@ -332,13 +332,13 @@ BOOST_AUTO_TEST_CASE(radius_regression_test)
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 0.01, boost::none, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 0.01, std::nullopt, true);
         BOOST_CHECK_EQUAL(results.size(), 0);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 1, 0.01, boost::none, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 1, 0.01, std::nullopt, true);
         BOOST_CHECK_EQUAL(results.size(), 0);
     }
 }
@@ -364,25 +364,25 @@ BOOST_AUTO_TEST_CASE(permissive_edge_snapping)
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 1000, boost::none, false);
+            input, osrm::engine::Approach::UNRESTRICTED, 1000, std::nullopt, false);
         BOOST_CHECK_EQUAL(results.size(), 1);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 1000, boost::none, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 1000, std::nullopt, true);
         BOOST_CHECK_EQUAL(results.size(), 2);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 10, 1000, boost::none, false);
+            input, osrm::engine::Approach::UNRESTRICTED, 10, 1000, std::nullopt, false);
         BOOST_CHECK_EQUAL(results.size(), 1);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 10, 1000, boost::none, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 10, 1000, std::nullopt, true);
         BOOST_CHECK_EQUAL(results.size(), 2);
     }
 }
@@ -408,7 +408,7 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 5, boost::none, boost::none, false);
+            input, osrm::engine::Approach::UNRESTRICTED, 5, std::nullopt, std::nullopt, false);
         BOOST_CHECK_EQUAL(results.size(), 2);
         BOOST_CHECK_EQUAL(results.back().phantom_node.forward_segment_id.id, 0);
         BOOST_CHECK_EQUAL(results.back().phantom_node.reverse_segment_id.id, 1);
@@ -418,7 +418,7 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
         auto results = query.NearestPhantomNodes(input,
                                                  osrm::engine::Approach::UNRESTRICTED,
                                                  5,
-                                                 boost::none,
+                                                 std::nullopt,
                                                  engine::Bearing{270, 10},
                                                  false);
         BOOST_CHECK_EQUAL(results.size(), 0);
@@ -428,7 +428,7 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
         auto results = query.NearestPhantomNodes(input,
                                                  osrm::engine::Approach::UNRESTRICTED,
                                                  5,
-                                                 boost::none,
+                                                 std::nullopt,
                                                  engine::Bearing{45, 10},
                                                  false);
         BOOST_CHECK_EQUAL(results.size(), 2);
@@ -444,13 +444,13 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 11000, boost::none, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 11000, std::nullopt, true);
         BOOST_CHECK_EQUAL(results.size(), 2);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 10, 11000, boost::none, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 10, 11000, std::nullopt, true);
         BOOST_CHECK_EQUAL(results.size(), 2);
     }