Merge branch 'master' into sf-flatbuffers

.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,

.github/workflows/osrm-backend.yml

@@ -177,39 +177,41 @@ jobs:
             CXXCOMPILER: g++-13
             ENABLE_COVERAGE: ON
 
-          - name: clang-15-debug-asan-ubsan
+          - name: clang-18-debug-asan-ubsan
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-15
+            CCOMPILER: clang-18
             CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-15
+            CXXCOMPILER: clang++-18
             ENABLE_SANITIZER: ON
             TARGET_ARCH: x86_64-asan-ubsan
             OSRM_CONNECTION_RETRIES: 10
             OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
 
-          - name: clang-15-release
+          - name: clang-18-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-15
+            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-15
+            CXXCOMPILER: clang++-18
             CUCUMBER_TIMEOUT: 60000
+            ENABLE_LTO: OFF
 
-          - name: clang-15-debug
+          - name: clang-18-debug
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-15
+            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-15
+            CXXCOMPILER: clang++-18
             CUCUMBER_TIMEOUT: 60000
+            ENABLE_LTO: OFF
 
           - name: clang-18-debug-clang-tidy
             continue-on-error: false
@@ -223,46 +225,50 @@ jobs:
             ENABLE_CLANG_TIDY: ON
 
 
-          - name: clang-14-release
+          - name: clang-17-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-14
+            CCOMPILER: clang-17
-            CXXCOMPILER: clang++-14
+            CXXCOMPILER: clang++-17
             CUCUMBER_TIMEOUT: 60000
+            ENABLE_LTO: OFF
 
-          - name: clang-13-release
+          - name: clang-16-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-13
+            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-13
+            CXXCOMPILER: clang++-16
             CUCUMBER_TIMEOUT: 60000
+            ENABLE_LTO: OFF
 
           - name: conan-linux-debug-asan-ubsan
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-15
+            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-15
+            CXXCOMPILER: clang++-18
             ENABLE_CONAN: ON
             ENABLE_SANITIZER: ON
+            ENABLE_LTO: OFF
 
           - name: conan-linux-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-15
+            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-15
+            CXXCOMPILER: clang++-18
             ENABLE_CONAN: ON
+            ENABLE_LTO: OFF
 
           - name: gcc-14-release
             continue-on-error: false
@@ -298,10 +304,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TYPE: Release
-            CCOMPILER: clang-13
+            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-13
+            CXXCOMPILER: clang++-16
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -309,10 +315,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
             BUILD_TYPE: Debug
-            CCOMPILER: clang-13
+            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-13
+            CXXCOMPILER: clang++-16
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -361,6 +367,7 @@ jobs:
       TARGET_ARCH: ${{ matrix.TARGET_ARCH }}
       OSRM_CONNECTION_RETRIES: ${{ matrix.OSRM_CONNECTION_RETRIES }}
       OSRM_CONNECTION_EXP_BACKOFF_COEF: ${{ matrix.OSRM_CONNECTION_EXP_BACKOFF_COEF }}
+      ENABLE_LTO: ${{ matrix.ENABLE_LTO }}
     steps:
     - uses: actions/checkout@v4
     - name: Build machine architecture
@@ -488,6 +495,13 @@ jobs:
         tar zxvf onetbb.tgz
         sudo cp -a oneapi-tbb-${TBB_VERSION}/lib/. /usr/local/lib/
         sudo cp -a oneapi-tbb-${TBB_VERSION}/include/. /usr/local/include/
+    - name: Add Clang 18 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Clang 18
+      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.CCOMPILER == 'clang-18' }}
+      run: |
+        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_linux_amd64 -O /usr/bin/yq && sudo chmod +x /usr/bin/yq
+
+        conan config init
+        yq eval '.compiler.clang.version += ["18"]' -i "$HOME/.conan/settings.yml"
     - name: Prepare build
       run: |
         mkdir ${OSRM_BUILD_DIR}
@@ -521,6 +535,7 @@ jobs:
                  -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
                  -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
                  -DENABLE_CCACHE=ON \
+                 -DENABLE_LTO=${ENABLE_LTO:-ON} \
                  -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
         make --jobs=${JOBS}
 
@@ -638,12 +653,12 @@ jobs:
   benchmarks:
     if: github.event_name == 'pull_request'
     needs: [format-taginfo-docs]
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     env:
-      CCOMPILER: clang-13
+      CCOMPILER: clang-16
-      CXXCOMPILER: clang++-13
+      CXXCOMPILER: clang++-16
-      CC: clang-13
+      CC: clang-16
-      CXX: clang++-13
+      CXX: clang++-16
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       PR_NUMBER: ${{ github.event.pull_request.number }}
       GITHUB_REPOSITORY: ${{ github.repository }}
@@ -678,7 +693,7 @@ jobs:
           path: pr
       - name: Install dependencies
         run: | 
-          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
+          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" --break-system-packages
           sudo apt-get update -y && sudo apt-get install ccache
       - name: Prepare data
         run: |
@@ -723,14 +738,34 @@ jobs:
           make -j$(nproc) benchmarks
           cd ..
           make -C test/data 
+      # we run benchmarks in tmpfs to avoid impact of disk IO
+      - name: Create folder for tmpfs 
+        run: mkdir -p /opt/benchmarks
       - name: Run PR Benchmarks 
         run: |
-          ./pr/scripts/ci/run_benchmarks.sh -f $(pwd)/pr -r $(pwd)/pr_results -s $(pwd)/pr -b $(pwd)/pr/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
+          cp -rf pr/build /opt/benchmarks/build
+          mkdir -p /opt/benchmarks/test
+          cp -rf pr/test/data /opt/benchmarks/test/data
+          cp -rf pr/profiles /opt/benchmarks/profiles
+
+          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo umount /opt/benchmarks
       - name: Run Base Benchmarks
         run: |
-          # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
+          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
-          ./pr/scripts/ci/run_benchmarks.sh -f $(pwd)/base -r $(pwd)/base_results -s $(pwd)/pr -b $(pwd)/base/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          cp -rf base/build /opt/benchmarks/build
+          mkdir -p /opt/benchmarks/test
+          cp -rf base/test/data /opt/benchmarks/test/data
+          cp -rf base/profiles /opt/benchmarks/profiles
 
+          # TODO: remove it when base branch will have this file at needed location
+          if [ ! -f /opt/benchmarks/test/data/portugal_to_korea.json ]; then
+            cp base/src/benchmarks/portugal_to_korea.json /opt/benchmarks/test/data/portugal_to_korea.json
+          fi
+          # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
+          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo umount /opt/benchmarks
       - name: Post Benchmark Results
         run: |
           python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results

.github/workflows/stale.yml

@@ -1,5 +1,9 @@
 name: 'Close stale issues'
 on:
+  # uncomment if you want to test changes to this file in PRs CI
+  # pull_request:
+  #   branches:
+  #     - master
   schedule:
     - cron: '30 1 * * *' # every day at 1:30am
 permissions:
@@ -12,6 +16,7 @@ jobs:
     steps:
       - uses: actions/stale@v9
         with:
+          operations-per-run: 3000
           stale-issue-message: 'This issue seems to be stale. It will be closed in 30 days if no further activity occurs.'
           stale-pr-message: 'This PR seems to be stale. Is it still relevant?'
           days-before-issue-stale: 180 # 6 months

CHANGELOG.md

@@ -24,6 +24,14 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
+      - CHANGED: Add .reserve(...) to assembleGeometry function. [#6983](https://github.com/Project-OSRM/osrm-backend/pull/6983)
+      - 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)
+      - CHANGED: Re-use priority queue in StaticRTree. [#6952](https://github.com/Project-OSRM/osrm-backend/pull/6952)
+      - CHANGED: Optimise encodePolyline function. [#6940](https://github.com/Project-OSRM/osrm-backend/pull/6940)
+      - CHANGED: Avoid reallocations in base64 encoding. [#6951](https://github.com/Project-OSRM/osrm-backend/pull/6951)
       - CHANGED: Get rid of unused Boost dependencies. [#6960](https://github.com/Project-OSRM/osrm-backend/pull/6960)
       - CHANGED: Apply micro-optimisation for Table & Trip APIs. [#6949](https://github.com/Project-OSRM/osrm-backend/pull/6949)
       - CHANGED: Apply micro-optimisation for Route API. [#6948](https://github.com/Project-OSRM/osrm-backend/pull/6948)

CMakeLists.txt

@@ -31,11 +31,12 @@ option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
 option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
 option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
-option(ENABLE_LTO "Use LTO if available" OFF)
+option(ENABLE_LTO "Use Link Time Optimisation" ON)
 option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
 option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
 option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
 
+
 if (ENABLE_CLANG_TIDY)
   find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
   if(NOT CLANG_TIDY_COMMAND)
@@ -57,6 +58,18 @@ if (POLICY CMP0074)
 endif()
 project(OSRM C CXX)
 
+
+if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
+  if(LTO_SUPPORTED)
+      message(STATUS "IPO / LTO enabled")
+      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  else()
+      message(FATAL_ERROR "IPO / LTO not supported: <${error}>")
+  endif()
+endif()
+
 # add @loader_path/$ORIGIN to rpath to make binaries relocatable
 if (APPLE)
   set(CMAKE_BUILD_RPATH "@loader_path")
@@ -209,17 +222,6 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -ggdb")
 endif()
 
-if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
-  if(LTO_SUPPORTED)
-      message(STATUS "IPO / LTO enabled")
-      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-  else()
-      message(WARNING "IPO / LTO not supported: <${error}>")
-  endif()
-endif()
-
 set(MAYBE_COVERAGE_LIBRARIES "")
 if (ENABLE_COVERAGE)
   if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
@@ -291,6 +293,7 @@ include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})
 
 add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
 set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
+
 target_no_warning(MICROTAR unused-variable)
 target_no_warning(MICROTAR format)
 

cmake/warnings.cmake

@@ -64,7 +64,6 @@ add_warning(init-self)
 add_warning(bool-compare)
 add_warning(logical-not-parentheses)
 add_warning(logical-op)
-add_warning(maybe-uninitialized)
 add_warning(misleading-indentation)
 # `no-` prefix is part of warning name(i.e. doesn't mean we are disabling it)
 add_warning(no-return-local-addr)
@@ -84,3 +83,6 @@ no_warning(comma-subscript)
 no_warning(ambiguous-reversed-operator)
 no_warning(restrict)
 no_warning(free-nonheap-object)
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+  no_warning(stringop-overflow)
+endif()

docker/Dockerfile-alpine

@@ -31,7 +31,7 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
     case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
     case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
     echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=OFF && \
     make -j${NPROC} install && \
     cd ../profiles && \
     cp -r * /opt && \

docker/Dockerfile-debian

@@ -21,7 +21,7 @@ COPY . /src
 WORKDIR /src
 
 RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized" && \
+    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized -Wno-stringop-overflow" && \
     echo "Building OSRM ${DOCKER_TAG}" && \
     git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
     echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \

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

@@ -47,24 +47,29 @@ namespace engine
 // Encodes a chunk of memory to Base64.
 inline std::string encodeBase64(const unsigned char *first, std::size_t size)
 {
-    std::vector<unsigned char> bytes{first, first + size};
+    BOOST_ASSERT(size > 0);
-    BOOST_ASSERT(!bytes.empty());
 
-    std::size_t bytes_to_pad{0};
+    std::string encoded;
+    encoded.reserve(((size + 2) / 3) * 4);
 
-    while (bytes.size() % 3 != 0)
+    auto padding = (3 - size % 3) % 3;
+
+    BOOST_ASSERT(padding == 0 || padding == 1 || padding == 2);
+
+    for (auto itr = detail::Base64FromBinary(first); itr != detail::Base64FromBinary(first + size);
+         ++itr)
     {
-        bytes_to_pad += 1;
+        encoded.push_back(*itr);
-        bytes.push_back(0);
     }
 
-    BOOST_ASSERT(bytes_to_pad == 0 || bytes_to_pad == 1 || bytes_to_pad == 2);
+    for (size_t index = 0; index < padding; ++index)
-    BOOST_ASSERT_MSG(0 == bytes.size() % 3, "base64 input data size is not a multiple of 3");
+    {
+        encoded.push_back('=');
+    }
 
-    std::string encoded{detail::Base64FromBinary{bytes.data()},
+    BOOST_ASSERT(encoded.size() == (size + 2) / 3 * 4);
-                        detail::Base64FromBinary{bytes.data() + (bytes.size() - bytes_to_pad)}};
 
-    return encoded.append(bytes_to_pad, '=');
+    return encoded;
 }
 
 // C++11 standard 3.9.1/1: Plain char, signed char, and unsigned char are three distinct types

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_geometry.hpp

@@ -37,6 +37,14 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 {
     LegGeometry geometry;
 
+    // each container will at most have `leg_data.size()` + 1/2 elements in it
+    // these additional 1/2 elements come from processing of very first and very last segment
+    geometry.locations.reserve(leg_data.size() + 2);
+    geometry.segment_distances.reserve(leg_data.size() + 1);
+    geometry.segment_offsets.reserve(leg_data.size() + 1);
+    geometry.annotations.reserve(leg_data.size() + 1);
+    geometry.node_ids.reserve(leg_data.size() + 2);
+
     // segment 0 first and last
     geometry.segment_offsets.push_back(0);
     geometry.locations.push_back(source_node.location);

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

@@ -12,7 +12,7 @@ namespace osrm::engine
 {
 namespace detail
 {
-std::string encode(std::vector<int> &numbers);
+void encode(int number_to_encode, std::string &output);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                      std::string::const_iterator last);
 } // namespace detail
@@ -30,27 +30,24 @@ std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter
         return {};
     }
 
-    std::vector<int> delta_numbers;
+    std::string output;
-    BOOST_ASSERT(size > 0);
+    // just a guess that we will need ~4 bytes per coordinate to avoid reallocations
-    delta_numbers.reserve((size - 1) * 2);
+    output.reserve(size * 4);
+
     int current_lat = 0;
     int current_lon = 0;
-    std::for_each(
+    for (auto it = begin; it != end; ++it)
-        begin,
-        end,
-        [&delta_numbers, &current_lat, &current_lon, coordinate_to_polyline](
-            const util::Coordinate loc)
     {
         const int lat_diff =
-                std::round(static_cast<int>(loc.lat) * coordinate_to_polyline) - current_lat;
+            std::round(static_cast<int>(it->lat) * coordinate_to_polyline) - current_lat;
         const int lon_diff =
-                std::round(static_cast<int>(loc.lon) * coordinate_to_polyline) - current_lon;
+            std::round(static_cast<int>(it->lon) * coordinate_to_polyline) - current_lon;
-            delta_numbers.emplace_back(lat_diff);
+        detail::encode(lat_diff, output);
-            delta_numbers.emplace_back(lon_diff);
+        detail::encode(lon_diff, output);
         current_lat += lat_diff;
         current_lon += lon_diff;
-        });
+    }
-    return detail::encode(delta_numbers);
+    return output;
 }
 
 // Decodes geometry from polyline format

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

@@ -487,7 +487,13 @@ void routingStep(const DataFacade<Algorithm> &facade,
 
 using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
-using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
+
+struct UnpackedPath
+{
+    EdgeWeight weight;
+    UnpackedNodes nodes;
+    UnpackedEdges edges;
+};
 
 template <typename Algorithm, typename Heap, typename... Args>
 std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
@@ -551,7 +557,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
         facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
     if (!searchResult)
     {
-        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
+        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
     }
 
     auto [middle, weight] = *searchResult;
@@ -595,7 +601,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
             forward_heap.Insert(source, {0}, {source});
             reverse_heap.Insert(target, {0}, {target});
 
-            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
+            auto unpacked_subpath = search(engine_working_data,
                                            facade,
                                            forward_heap,
                                            reverse_heap,
@@ -603,17 +609,19 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
                                            INVALID_EDGE_WEIGHT,
                                            sublevel,
                                            parent_cell_id);
-            BOOST_ASSERT(!subpath_edges.empty());
+            BOOST_ASSERT(!unpacked_subpath.edges.empty());
-            BOOST_ASSERT(subpath_nodes.size() > 1);
+            BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
-            BOOST_ASSERT(subpath_nodes.front() == source);
+            BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
-            BOOST_ASSERT(subpath_nodes.back() == target);
+            BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
-            unpacked_nodes.insert(
+            unpacked_nodes.insert(unpacked_nodes.end(),
-                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
+                                  std::next(unpacked_subpath.nodes.begin()),
-            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
+                                  unpacked_subpath.nodes.end());
+            unpacked_edges.insert(
+                unpacked_edges.end(), unpacked_subpath.edges.begin(), unpacked_subpath.edges.end());
         }
     }
 
-    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
+    return {weight, std::move(unpacked_nodes), std::move(unpacked_edges)};
 }
 
 template <typename Algorithm, typename... Args>
@@ -654,13 +662,15 @@ inline void search(SearchEngineData<Algorithm> &engine_working_data,
                    const EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
     // TODO: change search calling interface to use unpacked_edges result
-    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
+    auto unpacked_path = search(engine_working_data,
                                 facade,
                                 forward_heap,
                                 reverse_heap,
                                 force_step_nodes,
                                 weight_upper_bound,
                                 endpoints);
+    weight = unpacked_path.weight;
+    unpacked_nodes = std::move(unpacked_path.nodes);
 }
 
 // TODO: refactor CH-related stub to use unpacked_edges

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

include/util/binary_heap.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include <algorithm>
+#include <boost/assert.hpp>
+#include <vector>
+
+namespace osrm::util
+{
+
+// in its essence it is std::priority_queue, but with `clear` method
+template <typename T> class BinaryHeap
+{
+  public:
+    bool empty() const { return heap_.empty(); }
+
+    const T &top() const
+    {
+        BOOST_ASSERT(!heap_.empty());
+        return heap_.front();
+    }
+
+    void pop()
+    {
+        BOOST_ASSERT(!heap_.empty());
+        std::pop_heap(heap_.begin(), heap_.end());
+        heap_.pop_back();
+    }
+
+    template <typename... Args> void emplace(Args &&...args)
+    {
+        heap_.emplace_back(std::forward<Args>(args)...);
+        std::push_heap(heap_.begin(), heap_.end());
+    }
+
+    void clear() { heap_.clear(); }
+
+  private:
+    std::vector<T> heap_;
+};
+
+} // namespace osrm::util

include/util/static_rtree.hpp

@@ -2,7 +2,9 @@
 #define STATIC_RTREE_HPP
 
 #include "storage/tar_fwd.hpp"
+#include "osrm/coordinate.hpp"
 #include "util/bearing.hpp"
+#include "util/binary_heap.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/deallocating_vector.hpp"
 #include "util/exception.hpp"
@@ -15,8 +17,6 @@
 #include "util/vector_view.hpp"
 #include "util/web_mercator.hpp"
 
-#include "osrm/coordinate.hpp"
-
 #include "storage/shared_memory_ownership.hpp"
 
 #include <boost/assert.hpp>
@@ -554,9 +554,12 @@ class StaticRTree
         auto projected_coordinate = web_mercator::fromWGS84(input_coordinate);
         Coordinate fixed_projected_coordinate{projected_coordinate};
 
+        // we re-use queue for each query to avoid re-allocating memory
+        static thread_local util::BinaryHeap<QueryCandidate> traversal_queue;
+
+        traversal_queue.clear();
         // initialize queue with root element
-        std::priority_queue<QueryCandidate> traversal_queue;
+        traversal_queue.emplace(QueryCandidate{0, TreeIndex{}});
-        traversal_queue.push(QueryCandidate{0, TreeIndex{}});
 
         while (!traversal_queue.empty())
         {
@@ -710,7 +713,8 @@ class StaticRTree
             // distance must be non-negative
             BOOST_ASSERT(0. <= squared_distance);
             BOOST_ASSERT(i < std::numeric_limits<std::uint32_t>::max());
-            traversal_queue.push(QueryCandidate{squared_distance,
+
+            traversal_queue.emplace(QueryCandidate{squared_distance,
                                                    leaf_id,
                                                    static_cast<std::uint32_t>(i),
                                                    Coordinate{projected_nearest}});
@@ -742,7 +746,7 @@ class StaticRTree
                 child.minimum_bounding_rectangle.GetMinSquaredDist(
                     fixed_projected_input_coordinate);
 
-            traversal_queue.push(QueryCandidate{
+            traversal_queue.emplace(QueryCandidate{
                 squared_lower_bound_to_element,
                 TreeIndex(parent.level + 1, child_index - m_tree_level_starts[parent.level + 1])});
         }

scripts/ci/e2e_benchmark.py

@@ -86,9 +86,9 @@ def bootstrap_confidence_interval(data, num_samples=1000, confidence_level=0.95)
     mean = np.mean(means)
     return mean, lower_bound, upper_bound
 
-def calculate_confidence_interval(data):
+def calculate_confidence_interval(data, min_is_best=True):
     mean, lower, upper = bootstrap_confidence_interval(data)
-    min_value = np.min(data)
+    min_value = np.min(data) if min_is_best else np.max(data)
     return mean, (upper - lower) / 2, min_value
 
 
@@ -117,7 +117,7 @@ def main():
 
 
     total_time, total_ci, total_best = calculate_confidence_interval(np.sum(all_times, axis=1))
-    ops_per_sec, ops_per_sec_ci, ops_per_sec_best = calculate_confidence_interval(float(all_times.shape[1]) / np.sum(all_times / 1000, axis=1))
+    ops_per_sec, ops_per_sec_ci, ops_per_sec_best = calculate_confidence_interval(float(all_times.shape[1]) / np.sum(all_times / 1000, axis=1), min_is_best=False)
     min_time, min_ci, _ = calculate_confidence_interval(np.min(all_times, axis=1))
     mean_time, mean_ci, _ = calculate_confidence_interval(np.mean(all_times, axis=1))
     median_time, median_ci, _ = calculate_confidence_interval(np.median(all_times, axis=1))

scripts/ci/run_benchmarks.sh

@@ -64,7 +64,7 @@ function run_benchmarks_for_folder {
     echo "Running alias"
     $BENCHMARKS_FOLDER/alias-bench > "$RESULTS_FOLDER/alias.bench"
     echo "Running json-render-bench"
-    $BENCHMARKS_FOLDER/json-render-bench  "$FOLDER/src/benchmarks/portugal_to_korea.json" > "$RESULTS_FOLDER/json-render.bench"
+    $BENCHMARKS_FOLDER/json-render-bench  "$FOLDER/test/data/portugal_to_korea.json" > "$RESULTS_FOLDER/json-render.bench"
     echo "Running packedvector-bench"
     $BENCHMARKS_FOLDER/packedvector-bench > "$RESULTS_FOLDER/packedvector.bench"
     echo "Running rtree-bench"

src/benchmarks/bench.cpp

@@ -134,6 +134,7 @@ struct ConfidenceInterval
     double mean;
     double confidence;
     double min;
+    double max;
 };
 
 // Helper function to calculate the bootstrap confidence interval
@@ -161,8 +162,10 @@ ConfidenceInterval confidenceInterval(const std::vector<double> &data,
     double upper_bound = means[(int)((1 + confidence_level) / 2 * num_samples)];
     double mean = std::accumulate(means.begin(), means.end(), 0.0) / means.size();
 
-    ConfidenceInterval ci = {
+    ConfidenceInterval ci = {mean,
-        mean, (upper_bound - lower_bound) / 2, *std::min_element(data.begin(), data.end())};
+                             (upper_bound - lower_bound) / 2,
+                             *std::min_element(data.begin(), data.end()),
+                             *std::max_element(data.begin(), data.end())};
     return ci;
 }
 
@@ -260,7 +263,7 @@ std::ostream &operator<<(std::ostream &os, Statistics &statistics)
     ConfidenceInterval ops_ci = statistics.ops_per_sec();
 
     os << "ops: " << ops_ci.mean << " ± " << ops_ci.confidence << " ops/s. "
-       << "best: " << ops_ci.min << "ops/s." << std::endl;
+       << "best: " << ops_ci.max << "ops/s." << std::endl;
     os << "total: " << total_ci.mean << " ± " << total_ci.confidence << "ms. "
        << "best: " << total_ci.min << "ms." << std::endl;
     os << "avg: " << mean_ci.mean << " ± " << mean_ci.confidence << "ms" << std::endl;
@@ -357,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_radius_map_matching, 0) &&
                               unlimited_or_more_than(max_locations_trip, 2) &&
                               unlimited_or_more_than(max_locations_viaroute, 2) &&
                               unlimited_or_more_than(max_results_nearest, 0) &&
-        (!default_radius.has_value() || unlimited_or_more_than(*default_radius, 0)) &&
+                              unlimited_or_more_than(default_radius, 0) && max_alternatives >= 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/polyline_compressor.cpp

@@ -10,9 +10,19 @@
 namespace osrm::engine::detail // anonymous to keep TU local
 {
 
-std::string encode(int number_to_encode)
+void encode(int number_to_encode, std::string &output)
 {
-    std::string output;
+    if (number_to_encode < 0)
+    {
+        const unsigned binary = std::llabs(number_to_encode);
+        const unsigned twos = (~binary) + 1u;
+        const unsigned shl = twos << 1u;
+        number_to_encode = static_cast<int>(~shl);
+    }
+    else
+    {
+        number_to_encode <<= 1u;
+    }
     while (number_to_encode >= 0x20)
     {
         const int next_value = (0x20 | (number_to_encode & 0x1f)) + 63;
@@ -22,31 +32,6 @@ std::string encode(int number_to_encode)
 
     number_to_encode += 63;
     output += static_cast<char>(number_to_encode);
-    return output;
-}
-
-std::string encode(std::vector<int> &numbers)
-{
-    std::string output;
-    for (auto &number : numbers)
-    {
-        if (number < 0)
-        {
-            const unsigned binary = std::llabs(number);
-            const unsigned twos = (~binary) + 1u;
-            const unsigned shl = twos << 1u;
-            number = static_cast<int>(~shl);
-        }
-        else
-        {
-            number <<= 1u;
-        }
-    }
-    for (const int number : numbers)
-    {
-        output += encode(number);
-    }
-    return output;
 }
 
 // https://developers.google.com/maps/documentation/utilities/polylinealgorithm

src/engine/routing_algorithms/alternative_path_mld.cpp

@@ -621,12 +621,7 @@ void unpackPackedPaths(InputIt first,
                 BOOST_ASSERT(!facade.ExcludeNode(source));
                 BOOST_ASSERT(!facade.ExcludeNode(target));
 
-                // TODO: when structured bindings will be allowed change to
+                auto unpacked_subpath = search(search_engine_data,
-                // auto [subpath_weight, subpath_source, subpath_target, subpath] = ...
-                EdgeWeight subpath_weight;
-                std::vector<NodeID> subpath_nodes;
-                std::vector<EdgeID> subpath_edges;
-                std::tie(subpath_weight, subpath_nodes, subpath_edges) = search(search_engine_data,
                                                facade,
                                                forward_heap,
                                                reverse_heap,
@@ -634,14 +629,16 @@ void unpackPackedPaths(InputIt first,
                                                INVALID_EDGE_WEIGHT,
                                                sublevel,
                                                parent_cell_id);
-                BOOST_ASSERT(!subpath_edges.empty());
+                BOOST_ASSERT(!unpacked_subpath.edges.empty());
-                BOOST_ASSERT(subpath_nodes.size() > 1);
+                BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
-                BOOST_ASSERT(subpath_nodes.front() == source);
+                BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
-                BOOST_ASSERT(subpath_nodes.back() == target);
+                BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
-                unpacked_nodes.insert(
+                unpacked_nodes.insert(unpacked_nodes.end(),
-                    unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
+                                      std::next(unpacked_subpath.nodes.begin()),
-                unpacked_edges.insert(
+                                      unpacked_subpath.nodes.end());
-                    unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
+                unpacked_edges.insert(unpacked_edges.end(),
+                                      unpacked_subpath.edges.begin(),
+                                      unpacked_subpath.edges.end());
             }
         }
 

src/engine/routing_algorithms/direct_shortest_path.cpp

@@ -70,12 +70,7 @@ InternalRouteResult directShortestPathSearch(SearchEngineData<mld::Algorithm> &e
     auto &reverse_heap = *engine_working_data.reverse_heap_1;
     insertNodesInHeaps(forward_heap, reverse_heap, endpoint_candidates);
 
-    // TODO: when structured bindings will be allowed change to
+    auto unpacked_path = mld::search(engine_working_data,
-    // auto [weight, source_node, target_node, unpacked_edges] = ...
-    EdgeWeight weight = INVALID_EDGE_WEIGHT;
-    std::vector<NodeID> unpacked_nodes;
-    std::vector<EdgeID> unpacked_edges;
-    std::tie(weight, unpacked_nodes, unpacked_edges) = mld::search(engine_working_data,
                                      facade,
                                      forward_heap,
                                      reverse_heap,
@@ -83,7 +78,11 @@ InternalRouteResult directShortestPathSearch(SearchEngineData<mld::Algorithm> &e
                                      INVALID_EDGE_WEIGHT,
                                      endpoint_candidates);
 
-    return extractRoute(facade, weight, endpoint_candidates, unpacked_nodes, unpacked_edges);
+    return extractRoute(facade,
+                        unpacked_path.weight,
+                        endpoint_candidates,
+                        unpacked_path.nodes,
+                        unpacked_path.edges);
 }
 
 } // namespace osrm::engine::routing_algorithms

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;
@@ -401,6 +401,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
         auto trace_distance = 0.0;
         matching.nodes.reserve(reconstructed_indices.size());
         matching.indices.reserve(reconstructed_indices.size());
+        matching.alternatives_count.reserve(reconstructed_indices.size());
         for (const auto &idx : reconstructed_indices)
         {
             const auto timestamp_index = idx.first;
@@ -428,7 +429,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
 
         matching.confidence = confidence(trace_distance, matching_distance);
 
-        sub_matchings.push_back(matching);
+        sub_matchings.emplace_back(std::move(matching));
         sub_matching_begin = sub_matching_end;
     }
 
@@ -436,23 +437,21 @@ 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 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);
 
 // 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 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

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/extractor/extractor_callbacks.cpp

@@ -23,8 +23,6 @@
 #include <vector>
 
 #ifdef _MSC_VER
-#if (_MSC_VER >= 1928)
-#ifdef _DEBUG
 namespace osrm
 {
 namespace extractor
@@ -37,8 +35,6 @@ const ByEdgeOrByMeterValue::ValueByMeter ByEdgeOrByMeterValue::by_meter;
 } // namespace extractor
 } // namespace osrm
 #endif
-#endif
-#endif
 
 namespace osrm::extractor
 {

src/server/api/parameters_parser.cpp

@@ -28,7 +28,7 @@ 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)
 {
     using It = std::decay<decltype(iter)>::type;
@@ -56,12 +56,12 @@ 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)
 {
     return detail::parseParameters<engine::api::RouteParameters, RouteParametersGrammar<>>(iter,
@@ -69,7 +69,7 @@ boost::optional<engine::api::RouteParameters> parseParameters(std::string::itera
 }
 
 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)
 {
     return detail::parseParameters<engine::api::TableParameters, TableParametersGrammar<>>(iter,
@@ -77,7 +77,7 @@ boost::optional<engine::api::TableParameters> parseParameters(std::string::itera
 }
 
 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)
 {
     return detail::parseParameters<engine::api::NearestParameters, NearestParametersGrammar<>>(iter,
@@ -85,14 +85,14 @@ boost::optional<engine::api::NearestParameters> parseParameters(std::string::ite
 }
 
 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)
 {
     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)
 {
     return detail::parseParameters<engine::api::MatchParameters, MatchParametersGrammar<>>(iter,
@@ -100,7 +100,7 @@ boost::optional<engine::api::MatchParameters> parseParameters(std::string::itera
 }
 
 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)
 {
     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/base64.cpp

@@ -74,4 +74,98 @@ BOOST_AUTO_TEST_CASE(hint_encoding_decoding_roundtrip_bytewise)
                            reinterpret_cast<const unsigned char *>(&decoded)));
 }
 
+BOOST_AUTO_TEST_CASE(long_string_encoding)
+{
+    using namespace osrm::engine;
+    std::string long_string(1000, 'A'); // String of 1000 'A's
+    std::string encoded = encodeBase64(long_string);
+    BOOST_CHECK_EQUAL(decodeBase64(encoded), long_string);
+}
+
+BOOST_AUTO_TEST_CASE(invalid_base64_decoding)
+{
+    using namespace osrm::engine;
+    BOOST_CHECK_THROW(decodeBase64("Invalid!"), std::exception);
+}
+
+BOOST_AUTO_TEST_CASE(hint_serialization_size)
+{
+    using namespace osrm::engine;
+    using namespace osrm::util;
+
+    const Coordinate coordinate;
+    const PhantomNode phantom;
+    const osrm::test::MockDataFacade<osrm::engine::routing_algorithms::ch::Algorithm> facade{};
+
+    const SegmentHint hint{phantom, facade.GetCheckSum()};
+    const auto base64 = hint.ToBase64();
+
+    BOOST_CHECK_EQUAL(base64.size(), 112);
+}
+
+BOOST_AUTO_TEST_CASE(extended_roundtrip_tests)
+{
+    using namespace osrm::engine;
+
+    std::vector<std::string> test_strings = {
+        "Hello, World!",                    // Simple ASCII string
+        "1234567890",                       // Numeric string
+        "!@#$%^&*()_+",                     // Special characters
+        std::string(1000, 'A'),             // Long repeating string
+        "¡Hola, mundo!",                    // Non-ASCII characters
+        "こんにちは、世界！",               // Unicode characters
+        std::string("\x00\x01\x02\x03", 4), // Binary data
+        "a",                                // Single character
+        "ab",                               // Two characters
+        "abc",                              // Three characters (no padding in Base64)
+        std::string(190, 'x')               // String that doesn't align with Base64 padding
+    };
+
+    for (const auto &test_str : test_strings)
+    {
+        std::string encoded = encodeBase64(test_str);
+        std::string decoded = decodeBase64(encoded);
+        BOOST_CHECK_EQUAL(decoded, test_str);
+
+        // Additional checks
+        BOOST_CHECK(encoded.find_first_not_of(
+                        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=") ==
+                    std::string::npos);
+        if (test_str.length() % 3 != 0)
+        {
+            BOOST_CHECK(encoded.back() == '=');
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(roundtrip_with_url_safe_chars)
+{
+    using namespace osrm::engine;
+
+    std::string original = "Hello+World/Nothing?Is:Impossible";
+    std::string encoded = encodeBase64(original);
+
+    // Replace '+' with '-' and '/' with '_'
+    std::replace(encoded.begin(), encoded.end(), '+', '-');
+    std::replace(encoded.begin(), encoded.end(), '/', '_');
+
+    std::string decoded = decodeBase64(encoded);
+    BOOST_CHECK_EQUAL(decoded, original);
+}
+
+BOOST_AUTO_TEST_CASE(roundtrip_stress_test)
+{
+    using namespace osrm::engine;
+
+    std::string test_str;
+    for (int i = 0; i < 1000; ++i)
+    {
+        test_str += static_cast<char>(i % 256);
+    }
+
+    std::string encoded = encodeBase64(test_str);
+    std::string decoded = decodeBase64(encoded);
+    BOOST_CHECK_EQUAL(decoded, test_str);
+}
+
 BOOST_AUTO_TEST_SUITE_END()

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/engine/polyline_compressor.cpp

@@ -45,4 +45,96 @@ BOOST_AUTO_TEST_CASE(polyline6_test_case)
         decodePolyline<1000000>(encodePolyline<1000000>(coords.begin(), coords.end())).begin()));
 }
 
+BOOST_AUTO_TEST_CASE(empty_polyline_test)
+{
+    using namespace osrm::engine;
+    using namespace osrm::util;
+
+    std::vector<Coordinate> empty_coords;
+    BOOST_CHECK_EQUAL(encodePolyline(empty_coords.begin(), empty_coords.end()), "");
+    BOOST_CHECK(decodePolyline("").empty());
+}
+BOOST_AUTO_TEST_CASE(polyline_single_point_test)
+{
+    using namespace osrm::engine;
+    using namespace osrm::util;
+
+    const std::vector<Coordinate> coords({{FixedLongitude{-122414000}, FixedLatitude{37776000}}});
+
+    const std::string encoded = encodePolyline(coords.begin(), coords.end());
+    BOOST_CHECK_EQUAL(encoded, "_cqeFn~cjV");
+
+    const auto decoded = decodePolyline(encoded);
+    BOOST_CHECK_EQUAL(decoded.size(), 1);
+    BOOST_CHECK_EQUAL(decoded[0].lon, FixedLongitude{-122414000});
+    BOOST_CHECK_EQUAL(decoded[0].lat, FixedLatitude{37776000});
+}
+
+BOOST_AUTO_TEST_CASE(polyline_multiple_points_test)
+{
+    using namespace osrm::engine;
+    using namespace osrm::util;
+
+    const std::vector<Coordinate> coords({{FixedLongitude{-122414000}, FixedLatitude{37776000}},
+                                          {FixedLongitude{-122420000}, FixedLatitude{37779000}},
+                                          {FixedLongitude{-122421000}, FixedLatitude{37780000}}});
+
+    const std::string encoded = encodePolyline(coords.begin(), coords.end());
+    BOOST_CHECK_EQUAL(encoded, "_cqeFn~cjVwQnd@gEfE");
+
+    const auto decoded = decodePolyline(encoded);
+    BOOST_CHECK_EQUAL(decoded.size(), 3);
+    for (size_t i = 0; i < coords.size(); ++i)
+    {
+        BOOST_CHECK_EQUAL(decoded[i].lon, coords[i].lon);
+        BOOST_CHECK_EQUAL(decoded[i].lat, coords[i].lat);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(polyline_large_coordinate_difference_test)
+{
+    using namespace osrm::engine;
+    using namespace osrm::util;
+
+    const std::vector<Coordinate> coords({{FixedLongitude{-179000000}, FixedLatitude{-89000000}},
+                                          {FixedLongitude{179000000}, FixedLatitude{89000000}}});
+
+    const std::string encoded = encodePolyline(coords.begin(), coords.end());
+    BOOST_CHECK_EQUAL(encoded, "~xe~O~|oca@_sl}`@_{`hcA");
+
+    const auto decoded = decodePolyline(encoded);
+    BOOST_CHECK_EQUAL(decoded.size(), 2);
+    for (size_t i = 0; i < coords.size(); ++i)
+    {
+        BOOST_CHECK_EQUAL(decoded[i].lon, coords[i].lon);
+        BOOST_CHECK_EQUAL(decoded[i].lat, coords[i].lat);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(roundtrip)
+{
+    using namespace osrm::engine;
+    using namespace osrm::util;
+
+    {
+        const auto encoded = "_chxEn`zvN\\\\]]";
+        const auto decoded = decodePolyline(encoded);
+        const auto reencoded = encodePolyline(decoded.begin(), decoded.end());
+        BOOST_CHECK_EQUAL(encoded, reencoded);
+    }
+    {
+        const auto encoded =
+            "gcneIpgxzRcDnBoBlEHzKjBbHlG`@`IkDxIiKhKoMaLwTwHeIqHuAyGXeB~Ew@fFjAtIzExF";
+        const auto decoded = decodePolyline(encoded);
+        const auto reencoded = encodePolyline(decoded.begin(), decoded.end());
+        BOOST_CHECK_EQUAL(encoded, reencoded);
+    }
+    {
+        const auto encoded = "_p~iF~ps|U_ulLnnqC_mqNvxq`@";
+        const auto decoded = decodePolyline(encoded);
+        const auto reencoded = encodePolyline(decoded.begin(), decoded.end());
+        BOOST_CHECK_EQUAL(encoded, reencoded);
+    }
+}
+
 BOOST_AUTO_TEST_SUITE_END()

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/binary_heap.cpp

@@ -0,0 +1,132 @@
+#include "util/binary_heap.hpp"
+
+#include <boost/test/unit_test.hpp>
+#include <string>
+
+BOOST_AUTO_TEST_SUITE(binary_heap_test)
+
+BOOST_AUTO_TEST_CASE(empty_heap)
+{
+    osrm::util::BinaryHeap<int> heap;
+    BOOST_CHECK(heap.empty());
+}
+
+BOOST_AUTO_TEST_CASE(push_and_top)
+{
+    osrm::util::BinaryHeap<int> heap;
+    heap.emplace(5);
+    BOOST_CHECK_EQUAL(heap.top(), 5);
+    BOOST_CHECK(!heap.empty());
+}
+
+BOOST_AUTO_TEST_CASE(push_multiple_and_order)
+{
+    osrm::util::BinaryHeap<int> heap;
+    heap.emplace(5);
+    heap.emplace(10);
+    heap.emplace(3);
+    heap.emplace(8);
+    BOOST_CHECK_EQUAL(heap.top(), 10);
+}
+
+BOOST_AUTO_TEST_CASE(pop_and_order)
+{
+    osrm::util::BinaryHeap<int> heap;
+    heap.emplace(5);
+    heap.emplace(10);
+    heap.emplace(3);
+    heap.emplace(8);
+
+    BOOST_CHECK_EQUAL(heap.top(), 10);
+    heap.pop();
+    BOOST_CHECK_EQUAL(heap.top(), 8);
+    heap.pop();
+    BOOST_CHECK_EQUAL(heap.top(), 5);
+    heap.pop();
+    BOOST_CHECK_EQUAL(heap.top(), 3);
+    heap.pop();
+    BOOST_CHECK(heap.empty());
+}
+
+BOOST_AUTO_TEST_CASE(clear_heap)
+{
+    osrm::util::BinaryHeap<int> heap;
+    heap.emplace(5);
+    heap.emplace(10);
+    heap.clear();
+    BOOST_CHECK(heap.empty());
+}
+
+BOOST_AUTO_TEST_CASE(emplace_with_custom_type)
+{
+    struct CustomType
+    {
+        int value;
+        CustomType(int v) : value(v) {}
+        bool operator<(const CustomType &other) const { return value < other.value; }
+    };
+
+    osrm::util::BinaryHeap<CustomType> heap;
+    heap.emplace(5);
+    heap.emplace(10);
+    heap.emplace(3);
+    BOOST_CHECK_EQUAL(heap.top().value, 10);
+}
+
+BOOST_AUTO_TEST_CASE(large_number_of_elements)
+{
+    osrm::util::BinaryHeap<int> heap;
+    for (int i = 0; i < 1000; ++i)
+    {
+        heap.emplace(i);
+    }
+    BOOST_CHECK_EQUAL(heap.top(), 999);
+
+    for (int i = 999; i >= 0; --i)
+    {
+        BOOST_CHECK_EQUAL(heap.top(), i);
+        heap.pop();
+    }
+    BOOST_CHECK(heap.empty());
+}
+
+BOOST_AUTO_TEST_CASE(duplicate_values)
+{
+    osrm::util::BinaryHeap<int> heap;
+    heap.emplace(5);
+    heap.emplace(5);
+    heap.emplace(5);
+
+    BOOST_CHECK_EQUAL(heap.top(), 5);
+    heap.pop();
+    BOOST_CHECK_EQUAL(heap.top(), 5);
+    heap.pop();
+    BOOST_CHECK_EQUAL(heap.top(), 5);
+    heap.pop();
+    BOOST_CHECK(heap.empty());
+}
+
+BOOST_AUTO_TEST_CASE(string_type)
+{
+    osrm::util::BinaryHeap<std::string> heap;
+    heap.emplace("apple");
+    heap.emplace("banana");
+    heap.emplace("cherry");
+
+    BOOST_CHECK_EQUAL(heap.top(), "cherry");
+    heap.pop();
+    BOOST_CHECK_EQUAL(heap.top(), "banana");
+    heap.pop();
+    BOOST_CHECK_EQUAL(heap.top(), "apple");
+}
+
+BOOST_AUTO_TEST_CASE(emplace_after_clear)
+{
+    osrm::util::BinaryHeap<int> heap;
+    heap.emplace(5);
+    heap.clear();
+    heap.emplace(10);
+    BOOST_CHECK_EQUAL(heap.top(), 10);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

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);
     }