Merge branch 'master' into sf-ankerl

git-subtree-dir: third_party/unordered_dense
git-subtree-split: 231e48c9426bd21c273669e5fdcd042c146975cf

.clang-tidy

@@ -17,7 +17,6 @@ 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,41 +177,39 @@ jobs:
             CXXCOMPILER: g++-13
             ENABLE_COVERAGE: ON
 
-          - name: clang-18-debug-asan-ubsan
+          - name: clang-15-debug-asan-ubsan
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
             CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
             ENABLE_SANITIZER: ON
             TARGET_ARCH: x86_64-asan-ubsan
             OSRM_CONNECTION_RETRIES: 10
             OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
 
-          - name: clang-18-release
+          - name: clang-15-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
-          - name: clang-18-debug
+          - name: clang-15-debug
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
           - name: clang-18-debug-clang-tidy
             continue-on-error: false
@@ -225,50 +223,46 @@ jobs:
             ENABLE_CLANG_TIDY: ON
 
 
-          - name: clang-17-release
+          - name: clang-14-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-17
-            CXXCOMPILER: clang++-17
+            CCOMPILER: clang-14
+            CXXCOMPILER: clang++-14
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
-          - name: clang-16-release
+          - name: clang-13-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
           - name: conan-linux-debug-asan-ubsan
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             ENABLE_CONAN: ON
             ENABLE_SANITIZER: ON
-            ENABLE_LTO: OFF
 
           - name: conan-linux-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             ENABLE_CONAN: ON
-            ENABLE_LTO: OFF
 
           - name: gcc-14-release
             continue-on-error: false
@@ -304,10 +298,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -315,10 +309,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TYPE: Debug
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -367,7 +361,6 @@ 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
@@ -446,14 +439,14 @@ jobs:
       if: steps.cache-boost.outputs.cache-hit != 'true' && runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
       run: |
         BOOST_VERSION="1.85.0"
-        BOOST_VERSION_FLAVOR="${BOOST_VERSION}-b2-nodocs"
-        wget -q https://github.com/boostorg/boost/releases/download/boost-${BOOST_VERSION}/boost-${BOOST_VERSION_FLAVOR}.tar.gz
-        tar xzf boost-${BOOST_VERSION_FLAVOR}.tar.gz
-        cd boost-${BOOST_VERSION}
+        BOOST_VERSION_UNDERSCORE="${BOOST_VERSION//./_}"
+        wget -q https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION}/source/boost_${BOOST_VERSION_UNDERSCORE}.tar.gz
+        tar xzf boost_${BOOST_VERSION_UNDERSCORE}.tar.gz
+        cd boost_${BOOST_VERSION_UNDERSCORE}
         sudo ./bootstrap.sh
         sudo ./b2 install
         cd ..
-        sudo rm -rf boost-${BOOST_VERSION}*
+        sudo rm -rf boost_${BOOST_VERSION_UNDERSCORE}*
     
     - name: Install dev dependencies
       run: |
@@ -495,20 +488,6 @@ 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: Add Apple-clang 16 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Apple-clang 16
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.runs-on == 'macos-14' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_darwin_arm64 -O /usr/local/bin/yq && sudo chmod +x /usr/local/bin/yq
-
-        conan config init
-        yq eval '.compiler.apple-clang.version += ["16.0"]' -i "$HOME/.conan/settings.yml"
     - name: Prepare build
       run: |
         mkdir ${OSRM_BUILD_DIR}
@@ -542,7 +521,6 @@ 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}
 
@@ -660,28 +638,48 @@ jobs:
   benchmarks:
     if: github.event_name == 'pull_request'
     needs: [format-taginfo-docs]
-    runs-on: self-hosted
+    runs-on: ubuntu-22.04
     env:
-      CCOMPILER: clang-16
-      CXXCOMPILER: clang++-16
-      CC: clang-16
-      CXX: clang++-16
+      CCOMPILER: clang-13
+      CXXCOMPILER: clang++-13
+      CC: clang-13
+      CXX: clang++-13
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       PR_NUMBER: ${{ github.event.pull_request.number }}
       GITHUB_REPOSITORY: ${{ github.repository }}
       RUN_BIG_BENCHMARK: ${{ contains(github.event.pull_request.labels.*.name, 'Performance') }}
     steps: 
+      - name: Enable data.osm.pbf cache
+        if: ${{ ! env.RUN_BIG_BENCHMARK }}        
+        uses: actions/cache@v4
+        with:
+          path: ~/data.osm.pbf
+          key: v1-data-osm-pbf
+          restore-keys: |
+            v1-data-osm-pbf
+      - name: Enable compiler cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.ccache
+          key: v1-ccache-benchmarks-${{ github.sha }}
+          restore-keys: |
+            v1-ccache-benchmarks-
+      - name: Enable Conan cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.conan
+          key: v1-conan-benchmarks-${{ github.sha }}
+          restore-keys: |
+            v1-conan-benchmarks-
       - name: Checkout PR Branch
         uses: actions/checkout@v4
         with:
           ref: ${{ github.head_ref }}
           path: pr
-      - name: Activate virtualenv
-        run: |
-          python3 -m venv .venv
-          source .venv/bin/activate
-          echo PATH=$PATH >> $GITHUB_ENV
-          pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
+      - name: Install dependencies
+        run: | 
+          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
+          sudo apt-get update -y && sudo apt-get install ccache
       - name: Prepare data
         run: |
           if [ "$RUN_BIG_BENCHMARK" = "true" ]; then
@@ -690,7 +688,7 @@ jobs:
               gunzip -c ./pr/test/data/poland_gps_traces.csv.gz > ~/gps_traces.csv
           else
               if [ ! -f "~/data.osm.pbf" ]; then
-                wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf -O ~/data.osm.pbf
+                wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf -O ~/data.osm.pbf --quiet
               else
                 echo "Using cached data.osm.pbf"
               fi
@@ -709,67 +707,50 @@ jobs:
           path: base
       - name: Build Base Branch
         run: |
-          cd base
-          npm ci --ignore-scripts
-          cd ..
           mkdir base/build
           cd base/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
           make -j$(nproc)
           make -j$(nproc) benchmarks
           cd ..
           make -C test/data 
       - name: Build PR Branch
         run: |
-          cd pr
-          npm ci --ignore-scripts
-          cd ..
           mkdir -p pr/build
           cd pr/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
           make -j$(nproc) 
           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: |
-          # if by any chance it was mounted before(e.g. due to previous job failed), unmount it
-          sudo umount ~/benchmarks | true
-          rm -rf ~/benchmarks 
-          mkdir -p ~/benchmarks
-      # see https://llvm.org/docs/Benchmarking.html
+        run: mkdir -p /opt/benchmarks
       - name: Run PR Benchmarks 
         run: |
-          sudo cset shield -c 2-3 -k on
-          sudo mount -t tmpfs -o size=4g none ~/benchmarks
-          cp -rf pr/build ~/benchmarks/build
-          cp -rf pr/lib ~/benchmarks/lib
-          mkdir -p ~/benchmarks/test
-          cp -rf pr/test/data ~/benchmarks/test/data
-          cp -rf pr/profiles ~/benchmarks/profiles
+          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
 
-          sudo cset shield --exec -- ./pr/scripts/ci/run_benchmarks.sh -f ~/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b ~/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount ~/benchmarks
-          sudo cset shield --reset
+          ./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: |
-          sudo cset shield -c 2-3 -k on
-          sudo mount -t tmpfs -o size=4g none ~/benchmarks
-          cp -rf base/build ~/benchmarks/build
-          cp -rf base/lib ~/benchmarks/lib
-          mkdir -p ~/benchmarks/test
-          cp -rf base/test/data ~/benchmarks/test/data
-          cp -rf base/profiles ~/benchmarks/profiles
+          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
+          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 ~/benchmarks/test/data/portugal_to_korea.json ]; then
-            cp base/src/benchmarks/portugal_to_korea.json ~/benchmarks/test/data/portugal_to_korea.json
+          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
-          sudo cset shield --exec -- cset shield --exec -- ./pr/scripts/ci/run_benchmarks.sh -f ~/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b ~/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount ~/benchmarks
-          sudo cset shield --reset
+          ./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,9 +1,5 @@
 name: 'Close stale issues'
 on:
-  # NOTE: 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:
@@ -16,7 +12,6 @@ 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

.gitignore

@@ -46,6 +46,7 @@ Thumbs.db
 /example/build/
 /test/data/monaco.osrm*
 /test/data/ch
+/test/data/corech
 /test/data/mld
 /cmake/postinst
 

CHANGELOG.md

@@ -1,7 +1,6 @@
 # Unreleased
   - Changes from 5.27.1
     - Features
-      - ADDED: Route pedestrians over highway=platform [#6993](https://github.com/Project-OSRM/osrm-backend/pull/6993)
       - REMOVED: Remove all core-CH left-overs [#6920](https://github.com/Project-OSRM/osrm-backend/pull/6920)
       - ADDED: Add support for a keepalive_timeout flag. [#6674](https://github.com/Project-OSRM/osrm-backend/pull/6674)
       - ADDED: Add support for a default_radius flag. [#6575](https://github.com/Project-OSRM/osrm-backend/pull/6575)
@@ -25,14 +24,6 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
-      - CHANGED: Use std::string_view for key type in json::Object. [#7062](https://github.com/Project-OSRM/osrm-backend/pull/7062)
-      - CHANGED: Use thread_local instead of boost::thread_specific_ptr. [#6991](https://github.com/Project-OSRM/osrm-backend/pull/6991)
-      - CHANGED: Bump flatbuffers to v24.3.25 version. [#6988](https://github.com/Project-OSRM/osrm-backend/pull/6988)
-      - 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)
@@ -80,7 +71,6 @@
       - ADDED: Extract prerelease/build information from package semver [#6839](https://github.com/Project-OSRM/osrm-backend/pull/6839)
     - Profiles:
       - FIXED: Bicycle and foot profiles now don't route on proposed ways [#6615](https://github.com/Project-OSRM/osrm-backend/pull/6615)
-      - ADDED: Add optional support of cargo bike exclusion and width to bicyle profile [#7044](https://github.com/Project-OSRM/osrm-backend/pull/7044)
     - Routing:
       - FIXED: Fix adding traffic signal penalties during compression [#6419](https://github.com/Project-OSRM/osrm-backend/pull/6419)
       - FIXED: Correctly handle compressed traffic signals. [#6724](https://github.com/Project-OSRM/osrm-backend/pull/6724)

CMakeLists.txt

@@ -31,12 +31,11 @@ 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 Link Time Optimisation" ON)
+option(ENABLE_LTO "Use LTO if available" OFF)
 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)
@@ -56,23 +55,8 @@ endif()
 if (POLICY CMP0074)
   cmake_policy(SET CMP0074 NEW)
 endif()
-if (POLICY CMP0167)
-  cmake_policy(SET CMP0167 NEW)
-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")
@@ -136,7 +120,6 @@ endif()
 
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/generated/include/)
 include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)
 
 set(BOOST_COMPONENTS date_time iostreams program_options thread unit_test_framework)
@@ -225,6 +208,17 @@ 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")
@@ -296,7 +290,6 @@ 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)
 
@@ -306,6 +299,10 @@ include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
 set(VTZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/vtzero/include")
 include_directories(SYSTEM ${VTZERO_INCLUDE_DIR})
 
+set(ANKERL_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/unordered_dense/include")
+include_directories(SYSTEM ${ANKERL_INCLUDE_DIR})
+
+
 set(FLATBUFFERS_BUILD_TESTS OFF CACHE BOOL "Disable the build of Flatbuffers tests and samples.")
 set(FLATBUFFERS_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers")
 set(FLATBUFFERS_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers/include")

cmake/warnings.cmake

@@ -64,6 +64,7 @@ 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)
@@ -83,6 +84,3 @@ 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

@@ -1,34 +1,20 @@
-FROM alpine:3.21.2 AS alpine-mimalloc
+FROM alpine:3.20.0 as alpine-mimalloc
 
-RUN apk update && \
-    apk upgrade && \
-    apk add --no-cache \
-        boost-iostreams \
-        boost-program_options \
-        boost-thread \
-        mimalloc
+RUN apk add --no-cache mimalloc
 
 ENV LD_PRELOAD=/usr/lib/libmimalloc.so.2
 ENV MIMALLOC_LARGE_OS_PAGES=1
 
 
-FROM alpine-mimalloc AS builder
+FROM alpine-mimalloc as builder
 ARG DOCKER_TAG
 ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
 
-RUN mkdir -p /src /opt && \
-    apk add --no-cache \
-    boost-dev \
-    boost-filesystem \
-    clang \
-    cmake \
-    expat-dev \
-    git \
-    libbz2 \
-    libxml2 \
-    lua5.4-dev \
-    make \
-    onetbb-dev
+RUN apk add --no-cache \
+    cmake make git clang libbz2 libxml2 \
+    boost-dev boost-program_options boost-filesystem boost-iostreams boost-thread \
+    lua5.4-dev onetbb-dev expat-dev
 
 COPY . /src
 WORKDIR /src
@@ -45,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=OFF && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
     make -j${NPROC} install && \
     cd ../profiles && \
     cp -r * /opt && \
@@ -53,18 +39,16 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
     rm -rf /src
 
 
-# Multistage build to reduce image size - https://docs.docker.com/build/building/multi-stage/#use-multi-stage-builds
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM alpine-mimalloc AS runstage
+FROM alpine-mimalloc as runstage
 
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
 
 RUN apk add --no-cache \
-    boost-date_time \
-    expat \
-    lua5.4 \
-    onetbb && \
+    boost-program_options boost-date_time boost-iostreams boost-thread \
+    expat lua5.4 onetbb && \
     ldconfig /usr/local/lib
 
 RUN /usr/local/bin/osrm-extract --help && \
@@ -76,4 +60,3 @@ RUN /usr/local/bin/osrm-extract --help && \
 WORKDIR /opt
 
 EXPOSE 5000
-

docker/Dockerfile-debian

@@ -1,30 +1,27 @@
-FROM debian:bookworm-slim AS builder
+FROM debian:bookworm-slim as builder
 ARG DOCKER_TAG
 ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
 
-RUN mkdir -p /src /opt && \
-    apt-get update && \
-    apt-get -y --no-install-recommends --no-install-suggests install \
-        ca-certificates \
-        cmake \
-        g++ \
-        gcc \
-        git \
-        libboost1.81-all-dev \
-        libbz2-dev \
-        liblua5.4-dev \
-        libtbb-dev \
-        libxml2-dev \
-        libzip-dev \
-        lua5.4 \
-        make \
-        pkg-config
+RUN apt-get update && \
+    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
+    libzip-dev libboost1.81-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    ldconfig /usr/local/lib && \
+    git clone --branch v2021.12.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
+    cd oneTBB && \
+    mkdir build && \
+    cd build && \
+    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
+    cmake --build . && \
+    cmake --install .
 
 COPY . /src
 WORKDIR /src
 
 RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized -Wno-stringop-overflow" && \
+    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized" && \
     echo "Building OSRM ${DOCKER_TAG}" && \
     git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
     echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
@@ -44,24 +41,19 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
     rm -rf /src
 
 
-# Multistage build to reduce image size - https://docs.docker.com/build/building/multi-stage/#use-multi-stage-builds
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM debian:bookworm-slim AS runstage
+FROM debian:bookworm-slim as runstage
 
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
 
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends --no-install-suggests \
-        expat \
-        libboost-date-time1.81.0 \
-        libboost-iostreams1.81.0 \
-        libboost-program-options1.81.0 \
-        libboost-thread1.81.0 \
-        liblua5.4-0 \
-        libtbb12 && \
+    apt-get install -y --no-install-recommends \
+        libboost-program-options1.81.0 libboost-date-time1.81.0 libboost-iostreams1.81.0 libboost-thread1.81.0 \
+        expat liblua5.4-0 && \
     rm -rf /var/lib/apt/lists/* && \
-# Add /usr/local/lib to ldconfig to allow loading libraries from there
+# add /usr/local/lib to ldconfig to allow loading libraries from there
     ldconfig /usr/local/lib
 
 RUN /usr/local/bin/osrm-extract --help && \
@@ -73,4 +65,3 @@ RUN /usr/local/bin/osrm-extract --help && \
 WORKDIR /opt
 
 EXPOSE 5000
-

features/foot/access.feature

@@ -26,15 +26,7 @@ Feature: Foot - Access tags on ways
             | motorway | no     |      |       |
             | motorway | no     | yes  | x     |
             | motorway | no     | no   |       |
-            | platform |        |      | x     |
-            | platform |        | yes  | x     |
-            | platform |        | no   |       |
-            | platform | yes    |      | x     |
-            | platform | yes    | yes  | x     |
-            | platform | yes    | no   |       |
-            | platform | no     |      |       |
-            | platform | no     | yes  | x     |
-            | platform | no     | no   |       |
+
 
     Scenario: Foot - Overwriting implied acccess on ways
         Then routability should be

features/guidance/collapse.feature

@@ -1061,7 +1061,7 @@ Feature: Collapse
         #    i
         #    """
 
-        Given the node locations
+        And the node locations
           | node |         lat |         lon |        #id |
           | a    | -33.9644254 | 151.1378673 |   33226063 |
           | b    | -33.9644373 | 151.1377172 | 1072787030 |

features/guidance/roundabout-left-sided.feature

@@ -9,7 +9,7 @@ Feature: Basic Roundabout
             """
 
     Scenario: Roundabout exit counting for left sided driving
-        Given a grid size of 10 meters
+        And a grid size of 10 meters
         And the node map
             """
                 a
@@ -33,7 +33,7 @@ Feature: Basic Roundabout
            | a,h       | ab,gh,gh | depart,roundabout turn right exit-3,arrive    |
 
     Scenario: Mixed Entry and Exit
-        Given a grid size of 10 meters
+        And a grid size of 10 meters
         And the node map
            """
              c   a

features/options/contract/help.feature

@@ -0,0 +1,44 @@
+@prepare @options @help
+Feature: osrm-contract command line options: help
+
+    Scenario: osrm-contract - Help should be shown when no options are passed
+        When I try to run "osrm-contract"
+        Then stderr should be empty
+        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--core"
+        And stdout should contain "--segment-speed-file"
+        And it should exit with an error
+
+    Scenario: osrm-contract - Help, short
+        When I run "osrm-contract -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--core"
+        And stdout should contain "--segment-speed-file"
+        And it should exit successfully
+
+    Scenario: osrm-contract - Help, long
+        When I run "osrm-contract --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--core"
+        And stdout should contain "--segment-speed-file"
+        And it should exit successfully

features/options/customize/help.feature

@@ -0,0 +1,38 @@
+@contract @options @help
+Feature: osrm-customize command line options: help
+
+    Scenario: osrm-customize - Help should be shown when no options are passed
+        When I try to run "osrm-customize"
+        Then stderr should be empty
+        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And it should exit with an error
+
+    Scenario: osrm-customize - Help, short
+        When I run "osrm-customize -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And it should exit successfully
+
+    Scenario: osrm-customize - Help, long
+        When I run "osrm-customize --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And it should exit successfully

features/options/datastore/datastore.feature

@@ -33,6 +33,10 @@ Feature: osrm-datastore command line options
         When I try to run "osrm-datastore {processed_file} --dataset-name cucumber/only_metric_test --only-metric"
         Then it should exit successfully
 
+    Scenario: osrm-datastore - Displaying help should work
+        When I try to run "osrm-datastore {processed_file} --help"
+        Then it should exit successfully
+
     Scenario: osrm-datastore - Errors on invalid path
         When I try to run "osrm-datastore invalid_path.osrm"
         Then stderr should contain "[error] Config contains invalid file paths."

features/options/extract/help.feature

@@ -0,0 +1,47 @@
+@extract @options @help
+Feature: osrm-extract command line options: help
+
+    Background:
+        Given the profile "testbot"
+
+    Scenario: osrm-extract - Help should be shown when no options are passed
+        When I run "osrm-extract"
+        Then stderr should be empty
+        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--profile"
+        And stdout should contain "--threads"
+        And stdout should contain "--small-component-size"
+        And it should exit successfully
+
+    Scenario: osrm-extract - Help, short
+        When I run "osrm-extract -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--profile"
+        And stdout should contain "--threads"
+        And stdout should contain "--small-component-size"
+        And it should exit successfully
+
+    Scenario: osrm-extract - Help, long
+        When I run "osrm-extract --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--profile"
+        And stdout should contain "--threads"
+        And stdout should contain "--small-component-size"
+        And it should exit successfully

features/options/partition/help.feature

@@ -0,0 +1,53 @@
+@partition @options @help
+Feature: osrm-partition command line options: help
+
+    Scenario: osrm-partition - Help should be shown when no options are passed
+        When I try to run "osrm-partition"
+        Then stderr should be empty
+        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--balance"
+        And stdout should contain "--boundary"
+        And stdout should contain "--optimizing-cuts"
+        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
+        And it should exit with an error
+
+    Scenario: osrm-partition - Help, short
+        When I run "osrm-partition -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--balance"
+        And stdout should contain "--boundary"
+        And stdout should contain "--optimizing-cuts"
+        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
+        And it should exit successfully
+
+    Scenario: osrm-partition - Help, long
+        When I run "osrm-partition --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--balance"
+        And stdout should contain "--boundary"
+        And stdout should contain "--optimizing-cuts"
+        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
+        And it should exit successfully

features/options/routed/help.feature

@@ -0,0 +1,71 @@
+@routed @options @help
+Feature: osrm-routed command line options: help
+
+    Background:
+        Given the profile "testbot"
+
+    Scenario: osrm-routed - Help should be shown when no options are passed
+        When I run "osrm-routed"
+        Then stderr should be empty
+        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "--trial"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--ip"
+        And stdout should contain "--port"
+        And stdout should contain "--threads"
+        And stdout should contain "--shared-memory"
+        And stdout should contain "--max-viaroute-size"
+        And stdout should contain "--max-trip-size"
+        And stdout should contain "--max-table-size"
+        And stdout should contain "--max-matching-size"
+        And stdout should contain "--default-radius"
+        And stdout should contain "--keepalive-timeout"
+        And it should exit successfully
+
+    Scenario: osrm-routed - Help, short
+        When I run "osrm-routed -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "--trial"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--ip"
+        And stdout should contain "--port"
+        And stdout should contain "--threads"
+        And stdout should contain "--shared-memory"
+        And stdout should contain "--max-viaroute-size"
+        And stdout should contain "--max-trip-size"
+        And stdout should contain "--max-table-size"
+        And stdout should contain "--max-matching-size"
+        And stdout should contain "--default-radius"
+        And stdout should contain "--keepalive-timeout"
+        And it should exit successfully
+
+    Scenario: osrm-routed - Help, long
+        When I run "osrm-routed --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "--trial"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--ip"
+        And stdout should contain "--port"
+        And stdout should contain "--threads"
+        And stdout should contain "--shared-memory"
+        And stdout should contain "--max-trip-size"
+        And stdout should contain "--max-table-size"
+        And stdout should contain "--max-table-size"
+        And stdout should contain "--max-matching-size"
+        And stdout should contain "--default-radius"
+        And stdout should contain "--keepalive-timeout"
+        And it should exit successfully

features/testbot/loop.feature

@@ -75,7 +75,7 @@ Feature: Avoid weird loops caused by rounding errors
 
     @412 @via
     Scenario: Avoid weird loops 3
-        Given the node map
+        And the node map
             """
             a
             b e

features/testbot/matching.feature

@@ -136,6 +136,22 @@ Feature: Basic Map Matching
             | trace | matchings |
             | abcbd | abbd      |
 
+    Scenario: Testbot - Map matching with core factor
+        Given the contract extra arguments "--core 0.8"
+        Given the node map
+            """
+            a b c d
+                e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | abcd  | no     |
+
+        When I match I should get
+            | trace | timestamps | matchings |
+            | abcd  | 0 1 2 3    | abcd      |
+
     Scenario: Testbot - Map matching with small distortion
         Given the node map
             """

features/testbot/snap_intersection.feature

@@ -401,12 +401,12 @@ Feature: Snapping at intersections
         Given the extract extra arguments "--small-component-size=4"
 
         And the ways
-            | nodes | oneway | # comment  |
-            | ab    | no     |            |
-            | bc    | no     |            |
-            | cd    | no     |            |
-            | fed   | no     |            |
-            | bg    | yes    | small SCC  |
+            | nodes | oneway |
+            | ab    | no     |
+            | bc    | no     |
+            | cd    | no     |
+            | fed   | no     |
+            | bg    | yes    | # small SCC
 
         And the relations
             | type        | way:from | way:to | node:via | restriction   |
@@ -437,14 +437,14 @@ Feature: Snapping at intersections
         Given the extract extra arguments "--small-component-size=4"
 
         And the ways
-            | nodes | oneway | # comment |
-            | ab    | no     |           |
-            | bc    | no     |           |
-            | cd    | no     |           |
-            | fed   | no     |           |
-            | ghi   | no     |           |
-            | jkl   | no     |           |
-            | bm    | yes    | small SCC |
+            | nodes | oneway |
+            | ab    | no     |
+            | bc    | no     |
+            | cd    | no     |
+            | fed   | no     |
+            | ghi   | no     |
+            | jkl   | no     |
+            | bm    | yes    | # small SCC
 
         And the relations
             | type        | way:from | way:to | node:via | restriction   |

features/testbot/via.feature

@@ -65,6 +65,32 @@ Feature: Via points
             | waypoints | route          | turns                                                      |
             | 1,2,3     | cd,ac,ab,bd,cd | depart,new name right,new name right,new name right,arrive |
 
+    Scenario: Simple via point with core factor
+        Given the contract extra arguments "--core 0.8"
+        Given the node map
+            """
+            a b c d
+              e f g
+                h i
+                  j
+            """
+
+        And the ways
+            | nodes |
+            | abcd  |
+            | efg   |
+            | hi    |
+            | be    |
+            | cfh   |
+            | dgij  |
+
+        When I route I should get
+            | waypoints | route               |
+            | a,b,c     | abcd,abcd,abcd,abcd |
+            | c,b,a     | abcd,abcd,abcd,abcd |
+            | a,d,j     | abcd,abcd,dgij,dgij |
+            | j,d,a     | dgij,dgij,abcd,abcd |
+
     Scenario: Via point at a dead end
         Given the node map
             """

generated/include/engine/api/flatbuffers/fbresult_generated.h

@@ -1,249 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
-#define FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
-              FLATBUFFERS_VERSION_MINOR == 3 &&
-              FLATBUFFERS_VERSION_REVISION == 25,
-             "Non-compatible flatbuffers version included");
-
-#include "route_generated.h"
-#include "table_generated.h"
-
-namespace osrm {
-namespace engine {
-namespace api {
-namespace fbresult {
-
-struct Error;
-struct ErrorBuilder;
-
-struct FBResult;
-struct FBResultBuilder;
-
-struct Error FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef ErrorBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_CODE = 4,
-    VT_MESSAGE = 6
-  };
-  const ::flatbuffers::String *code() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_CODE);
-  }
-  const ::flatbuffers::String *message() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_MESSAGE);
-  }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_CODE) &&
-           verifier.VerifyString(code()) &&
-           VerifyOffset(verifier, VT_MESSAGE) &&
-           verifier.VerifyString(message()) &&
-           verifier.EndTable();
-  }
-};
-
-struct ErrorBuilder {
-  typedef Error Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_code(::flatbuffers::Offset<::flatbuffers::String> code) {
-    fbb_.AddOffset(Error::VT_CODE, code);
-  }
-  void add_message(::flatbuffers::Offset<::flatbuffers::String> message) {
-    fbb_.AddOffset(Error::VT_MESSAGE, message);
-  }
-  explicit ErrorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Error> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Error>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Error> CreateError(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> code = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> message = 0) {
-  ErrorBuilder builder_(_fbb);
-  builder_.add_message(message);
-  builder_.add_code(code);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Error> CreateErrorDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *code = nullptr,
-    const char *message = nullptr) {
-  auto code__ = code ? _fbb.CreateString(code) : 0;
-  auto message__ = message ? _fbb.CreateString(message) : 0;
-  return osrm::engine::api::fbresult::CreateError(
-      _fbb,
-      code__,
-      message__);
-}
-
-struct FBResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef FBResultBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_ERROR = 4,
-    VT_CODE = 6,
-    VT_DATA_VERSION = 8,
-    VT_WAYPOINTS = 10,
-    VT_ROUTES = 12,
-    VT_TABLE = 14
-  };
-  bool error() const {
-    return GetField<uint8_t>(VT_ERROR, 0) != 0;
-  }
-  const osrm::engine::api::fbresult::Error *code() const {
-    return GetPointer<const osrm::engine::api::fbresult::Error *>(VT_CODE);
-  }
-  const ::flatbuffers::String *data_version() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_DATA_VERSION);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_WAYPOINTS);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *>(VT_ROUTES);
-  }
-  const osrm::engine::api::fbresult::TableResult *table() const {
-    return GetPointer<const osrm::engine::api::fbresult::TableResult *>(VT_TABLE);
-  }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyField<uint8_t>(verifier, VT_ERROR, 1) &&
-           VerifyOffset(verifier, VT_CODE) &&
-           verifier.VerifyTable(code()) &&
-           VerifyOffset(verifier, VT_DATA_VERSION) &&
-           verifier.VerifyString(data_version()) &&
-           VerifyOffset(verifier, VT_WAYPOINTS) &&
-           verifier.VerifyVector(waypoints()) &&
-           verifier.VerifyVectorOfTables(waypoints()) &&
-           VerifyOffset(verifier, VT_ROUTES) &&
-           verifier.VerifyVector(routes()) &&
-           verifier.VerifyVectorOfTables(routes()) &&
-           VerifyOffset(verifier, VT_TABLE) &&
-           verifier.VerifyTable(table()) &&
-           verifier.EndTable();
-  }
-};
-
-struct FBResultBuilder {
-  typedef FBResult Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_error(bool error) {
-    fbb_.AddElement<uint8_t>(FBResult::VT_ERROR, static_cast<uint8_t>(error), 0);
-  }
-  void add_code(::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code) {
-    fbb_.AddOffset(FBResult::VT_CODE, code);
-  }
-  void add_data_version(::flatbuffers::Offset<::flatbuffers::String> data_version) {
-    fbb_.AddOffset(FBResult::VT_DATA_VERSION, data_version);
-  }
-  void add_waypoints(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
-    fbb_.AddOffset(FBResult::VT_WAYPOINTS, waypoints);
-  }
-  void add_routes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes) {
-    fbb_.AddOffset(FBResult::VT_ROUTES, routes);
-  }
-  void add_table(::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table) {
-    fbb_.AddOffset(FBResult::VT_TABLE, table);
-  }
-  explicit FBResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<FBResult> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<FBResult>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<FBResult> CreateFBResult(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    bool error = false,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> data_version = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes = 0,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table = 0) {
-  FBResultBuilder builder_(_fbb);
-  builder_.add_table(table);
-  builder_.add_routes(routes);
-  builder_.add_waypoints(waypoints);
-  builder_.add_data_version(data_version);
-  builder_.add_code(code);
-  builder_.add_error(error);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<FBResult> CreateFBResultDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    bool error = false,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code = 0,
-    const char *data_version = nullptr,
-    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr,
-    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes = nullptr,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table = 0) {
-  auto data_version__ = data_version ? _fbb.CreateString(data_version) : 0;
-  auto waypoints__ = waypoints ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
-  auto routes__ = routes ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>(*routes) : 0;
-  return osrm::engine::api::fbresult::CreateFBResult(
-      _fbb,
-      error,
-      code,
-      data_version__,
-      waypoints__,
-      routes__,
-      table);
-}
-
-inline const osrm::engine::api::fbresult::FBResult *GetFBResult(const void *buf) {
-  return ::flatbuffers::GetRoot<osrm::engine::api::fbresult::FBResult>(buf);
-}
-
-inline const osrm::engine::api::fbresult::FBResult *GetSizePrefixedFBResult(const void *buf) {
-  return ::flatbuffers::GetSizePrefixedRoot<osrm::engine::api::fbresult::FBResult>(buf);
-}
-
-inline bool VerifyFBResultBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<osrm::engine::api::fbresult::FBResult>(nullptr);
-}
-
-inline bool VerifySizePrefixedFBResultBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<osrm::engine::api::fbresult::FBResult>(nullptr);
-}
-
-inline void FinishFBResultBuffer(
-    ::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::FBResult> root) {
-  fbb.Finish(root);
-}
-
-inline void FinishSizePrefixedFBResultBuffer(
-    ::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::FBResult> root) {
-  fbb.FinishSizePrefixed(root);
-}
-
-}  // namespace fbresult
-}  // namespace api
-}  // namespace engine
-}  // namespace osrm
-
-#endif  // FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_

generated/include/engine/api/flatbuffers/position_generated.h

@@ -1,51 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_
-#define FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
-              FLATBUFFERS_VERSION_MINOR == 3 &&
-              FLATBUFFERS_VERSION_REVISION == 25,
-             "Non-compatible flatbuffers version included");
-
-namespace osrm {
-namespace engine {
-namespace api {
-namespace fbresult {
-
-struct Position;
-
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Position FLATBUFFERS_FINAL_CLASS {
- private:
-  float longitude_;
-  float latitude_;
-
- public:
-  Position()
-      : longitude_(0),
-        latitude_(0) {
-  }
-  Position(float _longitude, float _latitude)
-      : longitude_(::flatbuffers::EndianScalar(_longitude)),
-        latitude_(::flatbuffers::EndianScalar(_latitude)) {
-  }
-  float longitude() const {
-    return ::flatbuffers::EndianScalar(longitude_);
-  }
-  float latitude() const {
-    return ::flatbuffers::EndianScalar(latitude_);
-  }
-};
-FLATBUFFERS_STRUCT_END(Position, 8);
-
-}  // namespace fbresult
-}  // namespace api
-}  // namespace engine
-}  // namespace osrm
-
-#endif  // FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_

generated/include/engine/api/flatbuffers/table_generated.h

@@ -1,149 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_
-#define FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
-              FLATBUFFERS_VERSION_MINOR == 3 &&
-              FLATBUFFERS_VERSION_REVISION == 25,
-             "Non-compatible flatbuffers version included");
-
-#include "waypoint_generated.h"
-
-namespace osrm {
-namespace engine {
-namespace api {
-namespace fbresult {
-
-struct TableResult;
-struct TableResultBuilder;
-
-struct TableResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef TableResultBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_DURATIONS = 4,
-    VT_ROWS = 6,
-    VT_COLS = 8,
-    VT_DISTANCES = 10,
-    VT_DESTINATIONS = 12,
-    VT_FALLBACK_SPEED_CELLS = 14
-  };
-  const ::flatbuffers::Vector<float> *durations() const {
-    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_DURATIONS);
-  }
-  uint16_t rows() const {
-    return GetField<uint16_t>(VT_ROWS, 0);
-  }
-  uint16_t cols() const {
-    return GetField<uint16_t>(VT_COLS, 0);
-  }
-  const ::flatbuffers::Vector<float> *distances() const {
-    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_DISTANCES);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_DESTINATIONS);
-  }
-  const ::flatbuffers::Vector<uint32_t> *fallback_speed_cells() const {
-    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_FALLBACK_SPEED_CELLS);
-  }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_DURATIONS) &&
-           verifier.VerifyVector(durations()) &&
-           VerifyField<uint16_t>(verifier, VT_ROWS, 2) &&
-           VerifyField<uint16_t>(verifier, VT_COLS, 2) &&
-           VerifyOffset(verifier, VT_DISTANCES) &&
-           verifier.VerifyVector(distances()) &&
-           VerifyOffset(verifier, VT_DESTINATIONS) &&
-           verifier.VerifyVector(destinations()) &&
-           verifier.VerifyVectorOfTables(destinations()) &&
-           VerifyOffset(verifier, VT_FALLBACK_SPEED_CELLS) &&
-           verifier.VerifyVector(fallback_speed_cells()) &&
-           verifier.EndTable();
-  }
-};
-
-struct TableResultBuilder {
-  typedef TableResult Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_durations(::flatbuffers::Offset<::flatbuffers::Vector<float>> durations) {
-    fbb_.AddOffset(TableResult::VT_DURATIONS, durations);
-  }
-  void add_rows(uint16_t rows) {
-    fbb_.AddElement<uint16_t>(TableResult::VT_ROWS, rows, 0);
-  }
-  void add_cols(uint16_t cols) {
-    fbb_.AddElement<uint16_t>(TableResult::VT_COLS, cols, 0);
-  }
-  void add_distances(::flatbuffers::Offset<::flatbuffers::Vector<float>> distances) {
-    fbb_.AddOffset(TableResult::VT_DISTANCES, distances);
-  }
-  void add_destinations(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations) {
-    fbb_.AddOffset(TableResult::VT_DESTINATIONS, destinations);
-  }
-  void add_fallback_speed_cells(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> fallback_speed_cells) {
-    fbb_.AddOffset(TableResult::VT_FALLBACK_SPEED_CELLS, fallback_speed_cells);
-  }
-  explicit TableResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<TableResult> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<TableResult>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<TableResult> CreateTableResult(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::Vector<float>> durations = 0,
-    uint16_t rows = 0,
-    uint16_t cols = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<float>> distances = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> fallback_speed_cells = 0) {
-  TableResultBuilder builder_(_fbb);
-  builder_.add_fallback_speed_cells(fallback_speed_cells);
-  builder_.add_destinations(destinations);
-  builder_.add_distances(distances);
-  builder_.add_durations(durations);
-  builder_.add_cols(cols);
-  builder_.add_rows(rows);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<TableResult> CreateTableResultDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<float> *durations = nullptr,
-    uint16_t rows = 0,
-    uint16_t cols = 0,
-    const std::vector<float> *distances = nullptr,
-    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations = nullptr,
-    const std::vector<uint32_t> *fallback_speed_cells = nullptr) {
-  auto durations__ = durations ? _fbb.CreateVector<float>(*durations) : 0;
-  auto distances__ = distances ? _fbb.CreateVector<float>(*distances) : 0;
-  auto destinations__ = destinations ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*destinations) : 0;
-  auto fallback_speed_cells__ = fallback_speed_cells ? _fbb.CreateVector<uint32_t>(*fallback_speed_cells) : 0;
-  return osrm::engine::api::fbresult::CreateTableResult(
-      _fbb,
-      durations__,
-      rows,
-      cols,
-      distances__,
-      destinations__,
-      fallback_speed_cells__);
-}
-
-}  // namespace fbresult
-}  // namespace api
-}  // namespace engine
-}  // namespace osrm
-
-#endif  // FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_

generated/include/engine/api/flatbuffers/waypoint_generated.h

@@ -1,205 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_
-#define FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
-              FLATBUFFERS_VERSION_MINOR == 3 &&
-              FLATBUFFERS_VERSION_REVISION == 25,
-             "Non-compatible flatbuffers version included");
-
-#include "position_generated.h"
-
-namespace osrm {
-namespace engine {
-namespace api {
-namespace fbresult {
-
-struct Uint64Pair;
-
-struct Waypoint;
-struct WaypointBuilder;
-
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Uint64Pair FLATBUFFERS_FINAL_CLASS {
- private:
-  uint64_t first_;
-  uint64_t second_;
-
- public:
-  Uint64Pair()
-      : first_(0),
-        second_(0) {
-  }
-  Uint64Pair(uint64_t _first, uint64_t _second)
-      : first_(::flatbuffers::EndianScalar(_first)),
-        second_(::flatbuffers::EndianScalar(_second)) {
-  }
-  uint64_t first() const {
-    return ::flatbuffers::EndianScalar(first_);
-  }
-  uint64_t second() const {
-    return ::flatbuffers::EndianScalar(second_);
-  }
-};
-FLATBUFFERS_STRUCT_END(Uint64Pair, 16);
-
-struct Waypoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef WaypointBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_HINT = 4,
-    VT_DISTANCE = 6,
-    VT_NAME = 8,
-    VT_LOCATION = 10,
-    VT_NODES = 12,
-    VT_MATCHINGS_INDEX = 14,
-    VT_WAYPOINT_INDEX = 16,
-    VT_ALTERNATIVES_COUNT = 18,
-    VT_TRIPS_INDEX = 20
-  };
-  const ::flatbuffers::String *hint() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_HINT);
-  }
-  float distance() const {
-    return GetField<float>(VT_DISTANCE, 0.0f);
-  }
-  const ::flatbuffers::String *name() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
-  }
-  const osrm::engine::api::fbresult::Position *location() const {
-    return GetStruct<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
-  }
-  const osrm::engine::api::fbresult::Uint64Pair *nodes() const {
-    return GetStruct<const osrm::engine::api::fbresult::Uint64Pair *>(VT_NODES);
-  }
-  uint32_t matchings_index() const {
-    return GetField<uint32_t>(VT_MATCHINGS_INDEX, 0);
-  }
-  uint32_t waypoint_index() const {
-    return GetField<uint32_t>(VT_WAYPOINT_INDEX, 0);
-  }
-  uint32_t alternatives_count() const {
-    return GetField<uint32_t>(VT_ALTERNATIVES_COUNT, 0);
-  }
-  uint32_t trips_index() const {
-    return GetField<uint32_t>(VT_TRIPS_INDEX, 0);
-  }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_HINT) &&
-           verifier.VerifyString(hint()) &&
-           VerifyField<float>(verifier, VT_DISTANCE, 4) &&
-           VerifyOffset(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) &&
-           VerifyField<osrm::engine::api::fbresult::Position>(verifier, VT_LOCATION, 4) &&
-           VerifyField<osrm::engine::api::fbresult::Uint64Pair>(verifier, VT_NODES, 8) &&
-           VerifyField<uint32_t>(verifier, VT_MATCHINGS_INDEX, 4) &&
-           VerifyField<uint32_t>(verifier, VT_WAYPOINT_INDEX, 4) &&
-           VerifyField<uint32_t>(verifier, VT_ALTERNATIVES_COUNT, 4) &&
-           VerifyField<uint32_t>(verifier, VT_TRIPS_INDEX, 4) &&
-           verifier.EndTable();
-  }
-};
-
-struct WaypointBuilder {
-  typedef Waypoint Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_hint(::flatbuffers::Offset<::flatbuffers::String> hint) {
-    fbb_.AddOffset(Waypoint::VT_HINT, hint);
-  }
-  void add_distance(float distance) {
-    fbb_.AddElement<float>(Waypoint::VT_DISTANCE, distance, 0.0f);
-  }
-  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
-    fbb_.AddOffset(Waypoint::VT_NAME, name);
-  }
-  void add_location(const osrm::engine::api::fbresult::Position *location) {
-    fbb_.AddStruct(Waypoint::VT_LOCATION, location);
-  }
-  void add_nodes(const osrm::engine::api::fbresult::Uint64Pair *nodes) {
-    fbb_.AddStruct(Waypoint::VT_NODES, nodes);
-  }
-  void add_matchings_index(uint32_t matchings_index) {
-    fbb_.AddElement<uint32_t>(Waypoint::VT_MATCHINGS_INDEX, matchings_index, 0);
-  }
-  void add_waypoint_index(uint32_t waypoint_index) {
-    fbb_.AddElement<uint32_t>(Waypoint::VT_WAYPOINT_INDEX, waypoint_index, 0);
-  }
-  void add_alternatives_count(uint32_t alternatives_count) {
-    fbb_.AddElement<uint32_t>(Waypoint::VT_ALTERNATIVES_COUNT, alternatives_count, 0);
-  }
-  void add_trips_index(uint32_t trips_index) {
-    fbb_.AddElement<uint32_t>(Waypoint::VT_TRIPS_INDEX, trips_index, 0);
-  }
-  explicit WaypointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Waypoint> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Waypoint>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Waypoint> CreateWaypoint(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> hint = 0,
-    float distance = 0.0f,
-    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
-    const osrm::engine::api::fbresult::Position *location = nullptr,
-    const osrm::engine::api::fbresult::Uint64Pair *nodes = nullptr,
-    uint32_t matchings_index = 0,
-    uint32_t waypoint_index = 0,
-    uint32_t alternatives_count = 0,
-    uint32_t trips_index = 0) {
-  WaypointBuilder builder_(_fbb);
-  builder_.add_trips_index(trips_index);
-  builder_.add_alternatives_count(alternatives_count);
-  builder_.add_waypoint_index(waypoint_index);
-  builder_.add_matchings_index(matchings_index);
-  builder_.add_nodes(nodes);
-  builder_.add_location(location);
-  builder_.add_name(name);
-  builder_.add_distance(distance);
-  builder_.add_hint(hint);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Waypoint> CreateWaypointDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *hint = nullptr,
-    float distance = 0.0f,
-    const char *name = nullptr,
-    const osrm::engine::api::fbresult::Position *location = nullptr,
-    const osrm::engine::api::fbresult::Uint64Pair *nodes = nullptr,
-    uint32_t matchings_index = 0,
-    uint32_t waypoint_index = 0,
-    uint32_t alternatives_count = 0,
-    uint32_t trips_index = 0) {
-  auto hint__ = hint ? _fbb.CreateString(hint) : 0;
-  auto name__ = name ? _fbb.CreateString(name) : 0;
-  return osrm::engine::api::fbresult::CreateWaypoint(
-      _fbb,
-      hint__,
-      distance,
-      name__,
-      location,
-      nodes,
-      matchings_index,
-      waypoint_index,
-      alternatives_count,
-      trips_index);
-}
-
-}  // namespace fbresult
-}  // namespace api
-}  // namespace engine
-}  // namespace osrm
-
-#endif  // FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_

include/customizer/cell_customizer.hpp

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

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 <optional>
+#include <boost/optional.hpp>
 
 #include <algorithm>
 #include <vector>
@@ -74,12 +74,12 @@ struct BaseParameters
     };
 
     std::vector<util::Coordinate> coordinates;
-    std::vector<std::optional<Hint>> hints;
-    std::vector<std::optional<double>> radiuses;
-    std::vector<std::optional<Bearing>> bearings;
-    std::vector<std::optional<Approach>> approaches;
+    std::vector<boost::optional<Hint>> hints;
+    std::vector<boost::optional<double>> radiuses;
+    std::vector<boost::optional<Bearing>> bearings;
+    std::vector<boost::optional<Approach>> approaches;
     std::vector<std::string> exclude;
-    std::optional<OutputFormatType> format = OutputFormatType::JSON;
+    boost::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<std::optional<Hint>> hints_ = {},
-                   std::vector<std::optional<double>> radiuses_ = {},
-                   std::vector<std::optional<Bearing>> bearings_ = {},
-                   std::vector<std::optional<Approach>> approaches_ = {},
+                   std::vector<boost::optional<Hint>> hints_ = {},
+                   std::vector<boost::optional<double>> radiuses_ = {},
+                   std::vector<boost::optional<Bearing>> bearings_ = {},
+                   std::vector<boost::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 std::optional<Bearing> &bearing_and_range)
+                           [](const boost::optional<Bearing> &bearing_and_range)
                            {
                                if (bearing_and_range)
                                {

include/engine/api/flatbuffers/fbresult.fbs

@@ -14,7 +14,7 @@ table FBResult {
     data_version: string;
     waypoints: [Waypoint]; //Used as 'sources' waypoints for a 'Table' service
     routes: [RouteObject];
-    table: TableResult;
+    table: Table;
 }
 
 root_type FBResult;

include/engine/api/flatbuffers/table.fbs

@@ -1,7 +1,7 @@
 include "waypoint.fbs";
 namespace osrm.engine.api.fbresult;
 
-table TableResult {
+table Table {
     durations: [float];
     rows: ushort;
     cols: ushort;

include/engine/api/json_factory.hpp

@@ -12,7 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"
 
-#include <optional>
+#include <boost/optional.hpp>
 
 #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,
-                             std::optional<util::json::Value> geometry,
+                             boost::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();
-        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
+        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
         if (!data_timestamp.empty())
         {
             data_version_string = fb_result.CreateString(data_timestamp);
@@ -136,7 +136,7 @@ class NearestAPI final : public BaseAPI
             forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id);
 
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(forward_geometry[phantom_node.fwd_segment_position]);
+                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position));
             to_node = static_cast<std::uint64_t>(osm_node_id);
         }
 
@@ -146,14 +146,14 @@ class NearestAPI final : public BaseAPI
             const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
             const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id);
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(geometry[phantom_node.fwd_segment_position + 1]);
+                facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1));
             from_node = static_cast<std::uint64_t>(osm_node_id);
         }
         else if (phantom_node.forward_segment_id.enabled && phantom_node.fwd_segment_position > 0)
         {
             // In the case of one way, rely on forward segment only
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(forward_geometry[phantom_node.fwd_segment_position - 1]);
+                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position - 1));
             from_node = static_cast<std::uint64_t>(osm_node_id);
         }
 

include/engine/api/route_api.hpp

@@ -184,10 +184,10 @@ class RouteAPI : public BaseAPI
         return builder.CreateVectorOfStructs(coordinates);
     }
 
-    std::optional<util::json::Value>
-    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
+    boost::optional<util::json::Value>
+    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
     {
-        std::optional<util::json::Value> json_geometry;
+        boost::optional<util::json::Value> json_geometry;
         if (annotations)
         {
             auto begin = annotations->begin();
@@ -720,7 +720,8 @@ class RouteAPI : public BaseAPI
         std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
 
         auto route = guidance::assembleRoute(legs);
-        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));
+        boost::optional<util::json::Value> json_overview =
+            MakeGeometry(MakeOverview(leg_geometries));
 
         std::vector<util::json::Value> step_geometries;
         const auto total_step_count =
@@ -996,10 +997,10 @@ class RouteAPI : public BaseAPI
         return result;
     }
 
-    std::optional<std::vector<Coordinate>>
+    boost::optional<std::vector<Coordinate>>
     MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
     {
-        std::optional<std::vector<Coordinate>> overview;
+        boost::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 std::optional<bool> continue_straight_,
+                    const boost::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 std::optional<bool> continue_straight_,
+                    const boost::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 std::optional<bool> continue_straight_,
+                    const boost::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 std::optional<bool> continue_straight_,
+                    const boost::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 std::optional<bool> continue_straight_,
+                    const boost::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;
-    std::optional<bool> continue_straight;
+    boost::optional<bool> continue_straight;
     std::vector<std::size_t> waypoints;
 
     bool IsValid() const

include/engine/api/table_api.hpp

@@ -137,7 +137,7 @@ class TableAPI final : public BaseAPI
             speed_cells = MakeEstimatesTable(fb_result, fallback_speed_cells);
         }
 
-        fbresult::TableResultBuilder table(fb_result);
+        fbresult::TableBuilder table(fb_result);
         table.add_destinations(destinations);
         table.add_rows(number_of_sources);
         table.add_cols(number_of_destinations);

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 <optional>
+#include <boost/optional.hpp>
 #include <vector>
 
 namespace osrm::engine::api

include/engine/base64.hpp

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

include/engine/datafacade/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 std::optional<Bearing> bearing,
+                               const boost::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 std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::optional<double> max_distance,
+                        const boost::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, std::nullopt);
+            input_coordinate, approach, max_results, max_distance, bearing, boost::none);
     }
 
     PhantomCandidateAlternatives
     NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<double> max_distance,
+                                                     const boost::optional<Bearing> bearing,
                                                      const Approach approach,
                                                      const bool use_all_edges) const override final
     {
@@ -603,8 +603,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         auto found_range = std::equal_range(
             m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});
 
-        results.reserve(std::distance(found_range.first, found_range.second));
-
         std::for_each(found_range.first,
                       found_range.second,
                       [&](const auto &override)

include/engine/datafacade/datafacade_base.hpp

@@ -29,11 +29,12 @@
 #include "util/typedefs.hpp"
 
 #include "osrm/coordinate.hpp"
+
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/any_range.hpp>
 #include <cstddef>
 
 #include <engine/bearing.hpp>
-#include <optional>
-#include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -48,21 +49,20 @@ class BaseDataFacade
     using RTreeLeaf = extractor::EdgeBasedNodeSegment;
 
     using NodeForwardRange =
-        std::ranges::subrange<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
-    using NodeReverseRange = std::ranges::reverse_view<NodeForwardRange>;
+        boost::iterator_range<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
+    using NodeReverseRange = boost::reversed_range<const NodeForwardRange>;
 
     using WeightForwardRange =
-        std::ranges::subrange<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
-
-    using WeightReverseRange = std::ranges::reverse_view<WeightForwardRange>;
+        boost::iterator_range<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
+    using WeightReverseRange = boost::reversed_range<const WeightForwardRange>;
 
     using DurationForwardRange =
-        std::ranges::subrange<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
-    using DurationReverseRange = std::ranges::reverse_view<DurationForwardRange>;
+        boost::iterator_range<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
+    using DurationReverseRange = boost::reversed_range<const DurationForwardRange>;
 
     using DatasourceForwardRange =
-        std::ranges::subrange<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
-    using DatasourceReverseRange = std::ranges::reverse_view<DatasourceForwardRange>;
+        boost::iterator_range<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
+    using DatasourceReverseRange = boost::reversed_range<const DatasourceForwardRange>;
 
     BaseDataFacade() {}
     virtual ~BaseDataFacade() {}
@@ -126,21 +126,21 @@ class BaseDataFacade
     virtual std::vector<PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                                const double max_distance,
-                               const std::optional<Bearing> bearing,
+                               const boost::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 std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing,
                         const Approach approach) const = 0;
 
     virtual PhantomCandidateAlternatives
     NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<double> max_distance,
+                                                     const boost::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;
-    double default_radius = -1.0;
+    boost::optional<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 <optional>
+#include <boost/optional.hpp>
 
 #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 std::optional<Bearing> bearing_with_range,
-                        const std::optional<bool> use_all_edges) const
+                        const boost::optional<Bearing> bearing_with_range,
+                        const boost::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 std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing_with_range,
-                        const std::optional<bool> use_all_edges) const
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing_with_range,
+                        const boost::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 std::optional<double> max_distance,
-        const std::optional<Bearing> bearing_with_range,
-        const std::optional<bool> use_all_edges) const
+        const boost::optional<double> max_distance,
+        const boost::optional<Bearing> bearing_with_range,
+        const boost::optional<bool> use_all_edges) const
     {
         bool has_nearest = false;
         bool has_big_component = false;
@@ -394,7 +394,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             alias_cast<EdgeDuration>(forward_durations[data.fwd_segment_position]);
         EdgeDistance forward_distance =
             to_alias<EdgeDistance>(util::coordinate_calculation::greatCircleDistance(
-                datafacade.GetCoordinateOfNode(forward_geometry[data.fwd_segment_position]),
+                datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position)),
                 point_on_segment));
 
         const auto reverse_weight_offset = alias_cast<EdgeWeight>(
@@ -426,7 +426,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         EdgeDistance reverse_distance =
             to_alias<EdgeDistance>(util::coordinate_calculation::greatCircleDistance(
                 point_on_segment,
-                datafacade.GetCoordinateOfNode(forward_geometry[data.fwd_segment_position + 1])));
+                datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position + 1))));
 
         ratio = std::min(1.0, std::max(0.0, ratio));
         if (data.forward_segment_id.id != SPECIAL_SEGMENTID)

include/engine/guidance/assemble_geometry.hpp

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

include/engine/guidance/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 <optional>
+#include <boost/optional.hpp>
 
 #include <string>
 #include <vector>

include/engine/guidance/route_step.hpp

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

include/engine/internal_route_result.hpp

@@ -15,7 +15,7 @@
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"
 
-#include <optional>
+#include <boost/optional.hpp>
 #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
-    std::optional<EdgeID> turn_edge;
+    boost::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 std::optional<double> default_radius)
+                const boost::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 std::optional<double> default_radius);
+    explicit NearestPlugin(const int max_results, const boost::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 std::optional<double> default_radius_) : default_radius(default_radius_) {}
+    BasePlugin(const boost::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] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_bearings ? parameters.bearings[i] : boost::none,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                            : 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] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_bearings ? parameters.bearings[i] : boost::none,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                            : 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] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_bearings ? parameters.bearings[i] : boost::none,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                            : engine::Approach::UNRESTRICTED,
                 use_all_edges);
 
@@ -325,7 +325,7 @@ class BasePlugin
                std::to_string(missing_index);
     }
 
-    const std::optional<double> default_radius;
+    const boost::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 std::optional<double> default_radius);
+                         const boost::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_, std::optional<double> default_radius)
+    explicit TripPlugin(const int max_locations_trip_, boost::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,
-                            std::optional<double> default_radius);
+                            boost::optional<double> default_radius);
 
     Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::RouteParameters &route_parameters,

include/engine/routing_algorithms.hpp

@@ -25,7 +25,7 @@ class RoutingAlgorithmsInterface
 
     virtual InternalRouteResult
     ShortestPathSearch(const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                       const std::optional<bool> continue_straight_at_waypoint) const = 0;
+                       const boost::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<std::optional<double>> &trace_gps_precision,
+                const std::vector<boost::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 std::optional<bool> continue_straight_at_waypoint) const final override;
+        const boost::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<std::optional<double>> &trace_gps_precision,
+                const std::vector<boost::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 std::optional<bool> continue_straight_at_waypoint) const
+    const boost::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<std::optional<double>> &trace_gps_precision,
+    const std::vector<boost::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<std::optional<double>> &trace_gps_precision,
+                            const std::vector<boost::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],
-                                             std::nullopt});
+                                             boost::none});
         }
         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],
-                     std::nullopt});
+                     boost::none});
     }
 
     if (!unpacked_path.empty())

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -487,13 +487,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
 
 using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
-
-struct UnpackedPath
-{
-    EdgeWeight weight;
-    UnpackedNodes nodes;
-    UnpackedEdges edges;
-};
+using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
 
 template <typename Algorithm, typename Heap, typename... Args>
 std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
@@ -557,7 +551,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
         facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
     if (!searchResult)
     {
-        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
+        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
     }
 
     auto [middle, weight] = *searchResult;
@@ -601,27 +595,25 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
             forward_heap.Insert(source, {0}, {source});
             reverse_heap.Insert(target, {0}, {target});
 
-            auto unpacked_subpath = search(engine_working_data,
-                                           facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           force_step_nodes,
-                                           INVALID_EDGE_WEIGHT,
-                                           sublevel,
-                                           parent_cell_id);
-            BOOST_ASSERT(!unpacked_subpath.edges.empty());
-            BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
-            BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
-            BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
-            unpacked_nodes.insert(unpacked_nodes.end(),
-                                  std::next(unpacked_subpath.nodes.begin()),
-                                  unpacked_subpath.nodes.end());
-            unpacked_edges.insert(
-                unpacked_edges.end(), unpacked_subpath.edges.begin(), unpacked_subpath.edges.end());
+            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
+                                                                         facade,
+                                                                         forward_heap,
+                                                                         reverse_heap,
+                                                                         force_step_nodes,
+                                                                         INVALID_EDGE_WEIGHT,
+                                                                         sublevel,
+                                                                         parent_cell_id);
+            BOOST_ASSERT(!subpath_edges.empty());
+            BOOST_ASSERT(subpath_nodes.size() > 1);
+            BOOST_ASSERT(subpath_nodes.front() == source);
+            BOOST_ASSERT(subpath_nodes.back() == target);
+            unpacked_nodes.insert(
+                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
+            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
         }
     }
 
-    return {weight, std::move(unpacked_nodes), std::move(unpacked_edges)};
+    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
 }
 
 template <typename Algorithm, typename... Args>
@@ -662,15 +654,13 @@ 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
-    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);
+    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
+                                                           facade,
+                                                           forward_heap,
+                                                           reverse_heap,
+                                                           force_step_nodes,
+                                                           weight_upper_bound,
+                                                           endpoints);
 }
 
 // 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 std::optional<bool> continue_straight_at_waypoint);
+                   const boost::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 <optional>
+#include <boost/optional.hpp>
 
 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
-    std::optional<size_t> forward_to_forward;
-    std::optional<size_t> reverse_to_forward;
-    std::optional<size_t> forward_to_reverse;
-    std::optional<size_t> reverse_to_reverse;
+    boost::optional<size_t> forward_to_forward;
+    boost::optional<size_t> reverse_to_forward;
+    boost::optional<size_t> forward_to_reverse;
+    boost::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 std::optional<bool> continue_straight_at_waypoint)
+                   const boost::optional<bool> continue_straight_at_waypoint)
 {
     const bool allow_uturn_at_waypoint =
         !(continue_straight_at_waypoint ? *continue_straight_at_waypoint

include/engine/search_engine_data.hpp

@@ -5,6 +5,8 @@
 #include "util/query_heap.hpp"
 #include "util/typedefs.hpp"
 
+#include <boost/thread/tss.hpp>
+
 namespace osrm::engine
 {
 
@@ -43,19 +45,19 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
                                                 ManyToManyHeapData,
                                                 util::UnorderedMapStorage<NodeID, int>>;
 
-    using SearchEngineHeapPtr = std::unique_ptr<QueryHeap>;
+    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
 
-    using ManyToManyHeapPtr = std::unique_ptr<ManyToManyQueryHeap>;
+    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
 
-    static thread_local SearchEngineHeapPtr forward_heap_1;
-    static thread_local SearchEngineHeapPtr reverse_heap_1;
-    static thread_local SearchEngineHeapPtr forward_heap_2;
-    static thread_local SearchEngineHeapPtr reverse_heap_2;
-    static thread_local SearchEngineHeapPtr forward_heap_3;
-    static thread_local SearchEngineHeapPtr reverse_heap_3;
-    static thread_local ManyToManyHeapPtr many_to_many_heap;
-    static thread_local SearchEngineHeapPtr map_matching_forward_heap_1;
-    static thread_local SearchEngineHeapPtr map_matching_reverse_heap_1;
+    static SearchEngineHeapPtr forward_heap_1;
+    static SearchEngineHeapPtr reverse_heap_1;
+    static SearchEngineHeapPtr forward_heap_2;
+    static SearchEngineHeapPtr reverse_heap_2;
+    static SearchEngineHeapPtr forward_heap_3;
+    static SearchEngineHeapPtr reverse_heap_3;
+    static ManyToManyHeapPtr many_to_many_heap;
+    static SearchEngineHeapPtr map_matching_forward_heap_1;
+    static SearchEngineHeapPtr map_matching_reverse_heap_1;
 
     void InitializeOrClearMapMatchingThreadLocalStorage(unsigned number_of_nodes);
 
@@ -125,16 +127,16 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
                                                  MapMatchingMultiLayerDijkstraHeapData,
                                                  util::TwoLevelStorage<NodeID, int>>;
 
-    using SearchEngineHeapPtr = std::unique_ptr<QueryHeap>;
-    using ManyToManyHeapPtr = std::unique_ptr<ManyToManyQueryHeap>;
-    using MapMatchingHeapPtr = std::unique_ptr<MapMatchingQueryHeap>;
+    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
+    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
+    using MapMatchingHeapPtr = boost::thread_specific_ptr<MapMatchingQueryHeap>;
 
-    static thread_local SearchEngineHeapPtr forward_heap_1;
-    static thread_local SearchEngineHeapPtr reverse_heap_1;
-    static thread_local MapMatchingHeapPtr map_matching_forward_heap_1;
-    static thread_local MapMatchingHeapPtr map_matching_reverse_heap_1;
+    static SearchEngineHeapPtr forward_heap_1;
+    static SearchEngineHeapPtr reverse_heap_1;
+    static MapMatchingHeapPtr map_matching_forward_heap_1;
+    static MapMatchingHeapPtr map_matching_reverse_heap_1;
 
-    static thread_local ManyToManyHeapPtr many_to_many_heap;
+    static ManyToManyHeapPtr many_to_many_heap;
 
     void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes,
                                                   unsigned number_of_boundary_nodes);
@@ -146,4 +148,4 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
 };
 } // namespace osrm::engine
 
-#endif // SEARCH_ENGINE_DATA_HPP
+#endif // SEARCH_ENGINE_DATA_HPP

include/extractor/class_data.hpp

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

include/extractor/node_restriction_map.hpp

@@ -5,6 +5,8 @@
 #include "restriction_graph.hpp"
 #include "util/typedefs.hpp"
 
+#include <boost/range/adaptor/filtered.hpp>
+
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ -24,7 +26,7 @@ template <typename RestrictionFilter> class NodeRestrictionMap
     // Find all restrictions applicable to (from,via,*) turns
     auto Restrictions(NodeID from, NodeID via) const
     {
-        return getRange(from, via) | std::views::filter(index_filter);
+        return getRange(from, via) | boost::adaptors::filtered(index_filter);
     };
 
     // Find all restrictions applicable to (from,via,to) turns
@@ -32,7 +34,7 @@ template <typename RestrictionFilter> class NodeRestrictionMap
     {
         const auto turnFilter = [this, to](const auto &restriction)
         { return index_filter(restriction) && restriction->IsTurnRestricted(to); };
-        return getRange(from, via) | std::views::filter(turnFilter);
+        return getRange(from, via) | boost::adaptors::filtered(turnFilter);
     };
 
   private:

include/extractor/restriction_graph.hpp

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

include/extractor/segment_data_container.hpp

@@ -7,8 +7,11 @@
 
 #include "storage/shared_memory_ownership.hpp"
 #include "storage/tar_fwd.hpp"
+
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/iterator_range.hpp>
+
 #include <filesystem>
-#include <ranges>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -76,12 +79,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = nodes.begin() + index[id];
         const auto end = nodes.begin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseGeometry(const DirectionalGeometryID id)
     {
-        return GetForwardGeometry(id) | std::views::reverse;
+        return boost::adaptors::reverse(GetForwardGeometry(id));
     }
 
     auto GetForwardDurations(const DirectionalGeometryID id)
@@ -89,7 +92,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_durations.begin() + index[id] + 1;
         const auto end = fwd_durations.begin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDurations(const DirectionalGeometryID id)
@@ -97,7 +100,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_durations.begin() + index[id];
         const auto end = rev_durations.begin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardWeights(const DirectionalGeometryID id)
@@ -105,7 +108,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_weights.begin() + index[id] + 1;
         const auto end = fwd_weights.begin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseWeights(const DirectionalGeometryID id)
@@ -113,7 +116,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_weights.begin() + index[id];
         const auto end = rev_weights.begin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardDatasources(const DirectionalGeometryID id)
@@ -121,7 +124,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_datasources.begin() + index[id] + 1;
         const auto end = fwd_datasources.begin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDatasources(const DirectionalGeometryID id)
@@ -129,7 +132,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_datasources.begin() + index[id];
         const auto end = rev_datasources.begin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardGeometry(const DirectionalGeometryID id) const
@@ -137,12 +140,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = nodes.cbegin() + index[id];
         const auto end = nodes.cbegin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseGeometry(const DirectionalGeometryID id) const
     {
-        return GetForwardGeometry(id) | std::views::reverse;
+        return boost::adaptors::reverse(GetForwardGeometry(id));
     }
 
     auto GetForwardDurations(const DirectionalGeometryID id) const
@@ -150,7 +153,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_durations.cbegin() + index[id] + 1;
         const auto end = fwd_durations.cbegin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDurations(const DirectionalGeometryID id) const
@@ -158,7 +161,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_durations.cbegin() + index[id];
         const auto end = rev_durations.cbegin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardWeights(const DirectionalGeometryID id) const
@@ -166,7 +169,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_weights.cbegin() + index[id] + 1;
         const auto end = fwd_weights.cbegin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseWeights(const DirectionalGeometryID id) const
@@ -174,7 +177,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_weights.cbegin() + index[id];
         const auto end = rev_weights.cbegin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardDatasources(const DirectionalGeometryID id) const
@@ -182,7 +185,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_datasources.cbegin() + index[id] + 1;
         const auto end = fwd_datasources.cbegin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDatasources(const DirectionalGeometryID id) const
@@ -190,7 +193,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_datasources.cbegin() + index[id];
         const auto end = rev_datasources.cbegin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetNumberOfGeometries() const { return index.size() - 1; }

include/nodejs/json_v8_renderer.hpp

@@ -30,7 +30,7 @@ struct V8Renderer
         {
             Napi::Value child;
             std::visit(V8Renderer(env, child), keyValue.second);
-            obj.Set(keyValue.first.data(), child);
+            obj.Set(keyValue.first, child);
         }
         out = obj;
     }

include/nodejs/node_osrm_support.hpp

@@ -21,7 +21,7 @@
 #include <napi.h>
 
 #include <boost/assert.hpp>
-#include <optional>
+#include <boost/optional.hpp>
 
 #include <algorithm>
 #include <iterator>
@@ -395,11 +395,11 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
     return engine_config;
 }
 
-inline std::optional<std::vector<osrm::Coordinate>>
+inline boost::optional<std::vector<osrm::Coordinate>>
 parseCoordinateArray(const Napi::Array &coordinates_array)
 {
     Napi::HandleScope scope(coordinates_array.Env());
-    std::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
+    boost::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 = std::make_optional(std::move(temp_coordinates));
+    resulting_coordinates = boost::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 std::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
+    const boost::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
 {
     if (args.Length() < 3 || !args[1].IsObject())
     {

include/partitioner/bisection_graph_view.hpp

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

include/partitioner/cell_storage.hpp

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

include/partitioner/multi_level_partition.hpp

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

include/partitioner/partition_graph.hpp

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

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(std::nullopt);
+                base_parameters.hints.emplace_back(boost::none);
             }
         };
 
@@ -96,24 +96,13 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
             [](engine::api::BaseParameters &base_parameters,
                boost::optional<boost::fusion::vector2<short, short>> bearing_range)
         {
-            std::optional<engine::Bearing> bearing;
+            boost::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(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);
+            base_parameters.bearings.push_back(std::move(bearing));
         };
 
         polyline_chars = qi::char_("a-zA-Z0-9_.--[]{}@?|\\%~`^");
@@ -155,9 +144,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=") >
-            (-(qi::double_ | unlimited_rule))[ph::bind(add_radius, qi::_r1, qi::_1)] % ';';
+        radiuses_rule = qi::lit("radiuses=") >
+                        (-(qi::double_ | unlimited_rule) %
+                         ';')[ph::bind(&engine::api::BaseParameters::radiuses, qi::_r1) = qi::_1];
 
         hints_rule =
             qi::lit("hints=") >
@@ -181,7 +170,8 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
             "curb", engine::Approach::CURB)("opposite", engine::Approach::OPPOSITE);
 
         approach_rule = qi::lit("approaches=") >
-                        (-approach_type)[ph::bind(add_approach, qi::_r1, qi::_1)] % ';';
+                        (-approach_type %
+                         ';')[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>
-std::optional<ParameterT> parseParameters(std::string::iterator &iter,
-                                          const std::string::iterator end);
+boost::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>
-std::optional<ParameterT> parseParameters(std::string options_string)
+boost::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 <optional>
+#include <boost/optional.hpp>
 
 #include <string>
 
@@ -11,9 +11,9 @@ namespace osrm::server::api
 {
 
 // Starts parsing and iter and modifies it until iter == end or parsing failed
-std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end);
+boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end);
 
-inline std::optional<ParsedURL> parseURL(std::string url_string)
+inline boost::optional<ParsedURL> parseURL(std::string url_string)
 {
     auto iter = url_string.begin();
     return parseURL(iter, url_string.end());

include/util/bearing.hpp

@@ -11,6 +11,46 @@ namespace osrm::util
 namespace bearing
 {
 
+inline std::string get(const double heading)
+{
+    BOOST_ASSERT(heading >= 0);
+    BOOST_ASSERT(heading <= 360);
+
+    if (heading <= 22.5)
+    {
+        return "N";
+    }
+    if (heading <= 67.5)
+    {
+        return "NE";
+    }
+    if (heading <= 112.5)
+    {
+        return "E";
+    }
+    if (heading <= 157.5)
+    {
+        return "SE";
+    }
+    if (heading <= 202.5)
+    {
+        return "S";
+    }
+    if (heading <= 247.5)
+    {
+        return "SW";
+    }
+    if (heading <= 292.5)
+    {
+        return "W";
+    }
+    if (heading <= 337.5)
+    {
+        return "NW";
+    }
+    return "N";
+}
+
 // Checks whether A is between B-range and B+range, all modulo 360
 // e.g. A = 5, B = 5, range = 10 == true
 //      A = -6, B = 5, range = 10 == false

include/util/bit_range.hpp

@@ -2,13 +2,43 @@
 #define OSRM_UTIL_BIT_RANGE_HPP
 
 #include "util/msb.hpp"
-#include <bit>
+
 #include <boost/iterator/iterator_facade.hpp>
-#include <ranges>
+#include <boost/range/iterator_range.hpp>
 
 namespace osrm::util
 {
 
+namespace detail
+{
+template <typename T> std::size_t countOnes(T value)
+{
+    static_assert(std::is_unsigned<T>::value, "Only unsigned types allowed");
+    std::size_t number_of_ones = 0;
+    while (value > 0)
+    {
+        auto index = msb(value);
+        value = value & ~(T{1} << index);
+        number_of_ones++;
+    }
+    return number_of_ones;
+}
+
+#if (defined(__clang__) || defined(__GNUC__) || defined(__GNUG__))
+inline std::size_t countOnes(std::uint8_t value)
+{
+    return __builtin_popcount(std::uint32_t{value});
+}
+inline std::size_t countOnes(std::uint16_t value)
+{
+    return __builtin_popcount(std::uint32_t{value});
+}
+inline std::size_t countOnes(unsigned int value) { return __builtin_popcount(value); }
+inline std::size_t countOnes(unsigned long value) { return __builtin_popcountl(value); }
+inline std::size_t countOnes(unsigned long long value) { return __builtin_popcountll(value); }
+#endif
+} // namespace detail
+
 // Investigate if we can replace this with
 // http://www.boost.org/doc/libs/1_64_0/libs/dynamic_bitset/dynamic_bitset.html
 template <typename DataT>
@@ -40,7 +70,7 @@ class BitIterator : public boost::iterator_facade<BitIterator<DataT>,
 
     difference_type distance_to(const BitIterator &other) const
     {
-        return std::popcount(m_value) - std::popcount(other.m_value);
+        return detail::countOnes(m_value) - detail::countOnes(other.m_value);
     }
 
     bool equal(const BitIterator &other) const { return m_value == other.m_value; }
@@ -58,7 +88,7 @@ class BitIterator : public boost::iterator_facade<BitIterator<DataT>,
 // Returns range over all 1 bits of value
 template <typename T> auto makeBitRange(const T value)
 {
-    return std::ranges::subrange(BitIterator<T>{value}, BitIterator<T>{});
+    return boost::make_iterator_range(BitIterator<T>{value}, BitIterator<T>{});
 }
 } // namespace osrm::util
 

include/util/json_container.hpp

@@ -104,7 +104,7 @@ using Value = std::variant<String, Number, Object, Array, True, False, Null>;
  */
 struct Object
 {
-    std::unordered_map<std::string_view, Value> values;
+    std::unordered_map<std::string, Value> values;
 };
 
 /**

include/util/json_deep_compare.hpp

@@ -44,13 +44,13 @@ struct Comparator
 
     bool operator()(const Object &lhs, const Object &rhs) const
     {
-        std::set<std::string_view> lhs_keys;
+        std::set<std::string> lhs_keys;
         for (const auto &key_value : lhs.values)
         {
             lhs_keys.insert(key_value.first);
         }
 
-        std::set<std::string_view> rhs_keys;
+        std::set<std::string> rhs_keys;
         for (const auto &key_value : rhs.values)
         {
             rhs_keys.insert(key_value.first);
@@ -60,7 +60,7 @@ struct Comparator
         {
             if (rhs_keys.find(key) == rhs_keys.end())
             {
-                reason = rhs_path + " doesn't have key \"" + std::string(key) + "\"";
+                reason = rhs_path + " doesn't have key \"" + key + "\"";
                 return false;
             }
         }
@@ -69,7 +69,7 @@ struct Comparator
         {
             if (lhs_keys.find(key) == lhs_keys.end())
             {
-                reason = lhs_path + " doesn't have key \"" + std::string(key) + "\"";
+                reason = lhs_path + " doesn't have key \"" + key + "\"";
                 return false;
             }
         }
@@ -81,11 +81,10 @@ struct Comparator
 
             const auto &rhs_child = rhs.values.find(key)->second;
             const auto &lhs_child = lhs.values.find(key)->second;
-            auto is_same = std::visit(Comparator(reason,
-                                                 lhs_path + "." + std::string(key),
-                                                 rhs_path + "." + std::string(key)),
-                                      lhs_child,
-                                      rhs_child);
+            auto is_same =
+                std::visit(Comparator(reason, lhs_path + "." + key, rhs_path + "." + key),
+                           lhs_child,
+                           rhs_child);
             if (!is_same)
             {
                 return false;

include/util/json_renderer.hpp

@@ -97,7 +97,7 @@ template <typename Out> struct Renderer
     void operator()(const Null &) { write<>("null"); }
 
   private:
-    void write(std::string_view str);
+    void write(const std::string &str);
     void write(const char *str, size_t size);
     void write(char ch);
 
@@ -110,7 +110,7 @@ template <typename Out> struct Renderer
     Out &out;
 };
 
-template <> void Renderer<std::vector<char>>::write(std::string_view str)
+template <> void Renderer<std::vector<char>>::write(const std::string &str)
 {
     out.insert(out.end(), str.begin(), str.end());
 }
@@ -122,7 +122,7 @@ template <> void Renderer<std::vector<char>>::write(const char *str, size_t size
 
 template <> void Renderer<std::vector<char>>::write(char ch) { out.push_back(ch); }
 
-template <> void Renderer<std::ostream>::write(std::string_view str) { out << str; }
+template <> void Renderer<std::ostream>::write(const std::string &str) { out << str; }
 
 template <> void Renderer<std::ostream>::write(const char *str, size_t size)
 {
@@ -131,7 +131,7 @@ template <> void Renderer<std::ostream>::write(const char *str, size_t size)
 
 template <> void Renderer<std::ostream>::write(char ch) { out << ch; }
 
-template <> void Renderer<std::string>::write(std::string_view str) { out += str; }
+template <> void Renderer<std::string>::write(const std::string &str) { out += str; }
 
 template <> void Renderer<std::string>::write(const char *str, size_t size)
 {

include/util/meminfo.hpp

@@ -2,7 +2,6 @@
 #define MEMINFO_HPP
 
 #include "util/log.hpp"
-#include <cstddef>
 
 #ifndef _WIN32
 #include <sys/resource.h>
@@ -11,31 +10,22 @@
 namespace osrm::util
 {
 
-inline size_t PeakRAMUsedInBytes()
+inline void DumpMemoryStats()
 {
 #ifndef _WIN32
     rusage usage;
     getrusage(RUSAGE_SELF, &usage);
 #ifdef __linux__
     // Under linux, ru.maxrss is in kb
-    return usage.ru_maxrss * 1024;
+    util::Log() << "RAM: peak bytes used: " << usage.ru_maxrss * 1024;
 #else  // __linux__
     // Under BSD systems (OSX), it's in bytes
-    return usage.ru_maxrss;
+    util::Log() << "RAM: peak bytes used: " << usage.ru_maxrss;
 #endif // __linux__
-#else  // _WIN32
-    return 0;
-#endif // _WIN32
-}
-
-inline void DumpMemoryStats()
-{
-#ifndef _WIN32
-    util::Log() << "RAM: peak bytes used: " << PeakRAMUsedInBytes();
 #else  // _WIN32
     util::Log() << "RAM: peak bytes used: <not implemented on Windows>";
 #endif // _WIN32
 }
 } // namespace osrm::util
 
-#endif
+#endif

include/util/msb.hpp

@@ -1,24 +1,50 @@
 #ifndef OSRM_UTIL_MSB_HPP
 #define OSRM_UTIL_MSB_HPP
 
-#include <bit>
 #include <boost/assert.hpp>
+
+#include <climits>
 #include <cstdint>
-#include <limits>
+#include <utility>
 
 namespace osrm::util
 {
 
+// get the msb of an integer
+// return 0 for integers without msb
 template <typename T> std::size_t msb(T value)
 {
-    BOOST_ASSERT(value > 0);
-
     static_assert(std::is_integral<T>::value && !std::is_signed<T>::value, "Integer required.");
-    constexpr auto MSB_INDEX = std::numeric_limits<unsigned char>::digits * sizeof(T) - 1;
-
-    return MSB_INDEX - std::countl_zero(value);
+    std::size_t msb = 0;
+    while (value > 0)
+    {
+        value >>= 1u;
+        msb++;
+    }
+    BOOST_ASSERT(msb > 0);
+    return msb - 1;
 }
 
+#if (defined(__clang__) || defined(__GNUC__) || defined(__GNUG__))
+inline std::size_t msb(unsigned long long v)
+{
+    BOOST_ASSERT(v > 0);
+    constexpr auto MSB_INDEX = CHAR_BIT * sizeof(unsigned long long) - 1;
+    return MSB_INDEX - __builtin_clzll(v);
+}
+inline std::size_t msb(unsigned long v)
+{
+    BOOST_ASSERT(v > 0);
+    constexpr auto MSB_INDEX = CHAR_BIT * sizeof(unsigned long) - 1;
+    return MSB_INDEX - __builtin_clzl(v);
+}
+inline std::size_t msb(unsigned int v)
+{
+    BOOST_ASSERT(v > 0);
+    constexpr auto MSB_INDEX = CHAR_BIT * sizeof(unsigned int) - 1;
+    return MSB_INDEX - __builtin_clz(v);
+}
+#endif
 } // namespace osrm::util
 
 #endif

include/util/packed_vector.hpp

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

include/util/query_heap.hpp

@@ -5,11 +5,14 @@
 #include <boost/heap/d_ary_heap.hpp>
 
 #include <algorithm>
+#include <ankerl/unordered_dense.h>
+#include <boost/unordered_map.hpp>
 #include <cstdint>
 #include <limits>
 #include <map>
 #include <optional>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 namespace osrm::util
@@ -33,7 +36,7 @@ template <typename NodeID, typename Key> class ArrayStorage
 template <typename NodeID, typename Key> class UnorderedMapStorage
 {
   public:
-    explicit UnorderedMapStorage(std::size_t) { nodes.rehash(1000); }
+    explicit UnorderedMapStorage(std::size_t) {}
 
     Key &operator[](const NodeID node) { return nodes[node]; }
 
@@ -56,7 +59,7 @@ template <typename NodeID, typename Key> class UnorderedMapStorage
     void Clear() { nodes.clear(); }
 
   private:
-    std::unordered_map<NodeID, Key> nodes;
+    ankerl::unordered_dense::segmented_map<NodeID, Key> nodes;
 };
 
 template <typename NodeID,

include/util/vector_view.hpp

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

package-lock.json

@@ -10,8 +10,7 @@
       "hasInstallScript": true,
       "license": "BSD-2-Clause",
       "dependencies": {
-        "@mapbox/node-pre-gyp": "^1.0.11",
-        "seedrandom": "^3.0.5"
+        "@mapbox/node-pre-gyp": "^1.0.11"
       },
       "devDependencies": {
         "@babel/cli": "^7.18.10",
@@ -14653,11 +14652,6 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "devOptional": true
     },
-    "node_modules/seedrandom": {
-      "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
-      "integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg=="
-    },
     "node_modules/semver": {
       "version": "5.7.2",
       "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
@@ -30302,11 +30296,6 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "devOptional": true
     },
-    "seedrandom": {
-      "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
-      "integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg=="
-    },
     "semver": {
       "version": "5.7.2",
       "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",

package.json

@@ -4,8 +4,7 @@
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++ designed to run on OpenStreetMap data.",
   "dependencies": {
-    "@mapbox/node-pre-gyp": "^1.0.11",
-    "seedrandom": "^3.0.5"
+    "@mapbox/node-pre-gyp": "^1.0.11"
   },
   "browserify": {
     "transform": [
@@ -58,7 +57,6 @@
     "jsonpath": "^1.1.1",
     "mkdirp": "^0.5.6",
     "node-addon-api": "^5.0.0",
-    "node-cmake": "^2.5.1",
     "node-timeout": "0.0.4",
     "polyline": "^0.2.0",
     "request": "^2.88.2",
@@ -66,13 +64,12 @@
     "tape": "^4.16.0",
     "turf": "^3.0.14",
     "uglify-js": "^3.17.0",
-    "xmlbuilder": "^4.2.1"
+    "xmlbuilder": "^4.2.1",
+    "node-cmake": "^2.5.1"
   },
   "main": "lib/index.js",
   "binary": {
-    "napi_versions": [
-      8
-    ],
+    "napi_versions": [8],
     "module_name": "node_osrm",
     "module_path": "./lib/binding_napi_v{napi_build_version}/",
     "host": "https://github.com",

profiles/bicycle.lua

@@ -35,10 +35,6 @@ function setup()
     turn_bias                 = 1.4,
     use_public_transport      = true,
 
-    -- Exclude narrow ways, in particular to route with cargo bike
-    width                     = nil, -- Cargo bike could 0.5 width, in meters
-    exclude_cargo_bike        = false,
-
     allowed_start_modes = Set {
       mode.cycling,
       mode.pushing_bike
@@ -247,27 +243,6 @@ function process_node(profile, node, result)
     end
   end
 
-  if profile.exclude_cargo_bike then
-    local cargo_bike = node:get_value_by_key("cargo_bike")
-    if cargo_bike and cargo_bike == "no" then
-      result.barrier = true
-    end
-  end
-
-  -- width
-  if profile.width then
-    -- From barrier=cycle_barrier or other barriers
-    local maxwidth_physical = node:get_value_by_key("maxwidth:physical")
-    local maxwidth_physical_meter = maxwidth_physical and Measure.parse_value_meters(maxwidth_physical) or 99
-    local opening = node:get_value_by_key("opening")
-    local opening_meter = opening and Measure.parse_value_meters(opening) or 99
-    local width_meter = math.min(maxwidth_physical_meter, opening_meter)
-
-    if width_meter and width_meter < profile.width then
-      result.barrier = true
-    end
-  end
-
   -- check if node is a traffic light
   result.traffic_lights = TrafficSignal.get_value(node)
 end
@@ -324,8 +299,6 @@ function handle_bicycle_tags(profile,way,result,data)
 
   bike_push_handler(profile,way,result,data)
 
-  -- width should be after bike_push
-  width_handler(profile,way,result,data)
 
   -- maxspeed
   limit( result, data.maxspeed, data.maxspeed_forward, data.maxspeed_backward )
@@ -480,27 +453,6 @@ function cycleway_handler(profile,way,result,data)
   end
 end
 
-function width_handler(profile,way,result,data)
-  if profile.exclude_cargo_bike then
-    local cargo_bike = way:get_value_by_key("cargo_bike")
-    if cargo_bike and cargo_bike == "no" then
-      result.forward_mode = mode.inaccessible
-      result.backward_mode = mode.inaccessible
-    end
-  end
-
-  if profile.width then
-    local width = way:get_value_by_key("width")
-    if width then
-      local width_meter = Measure.parse_value_meters(width)
-      if width_meter and width_meter < profile.width then
-        result.forward_mode = mode.inaccessible
-        result.backward_mode = mode.inaccessible
-      end
-    end
-  end
-end
-
 function bike_push_handler(profile,way,result,data)
   -- pushing bikes - if no other mode found
   if result.forward_mode == mode.inaccessible or result.backward_mode == mode.inaccessible or

profiles/foot.lua

@@ -90,7 +90,6 @@ function setup()
         path            = walking_speed,
         steps           = walking_speed,
         pedestrian      = walking_speed,
-        platform        = walking_speed,
         footway         = walking_speed,
         pier            = walking_speed,
       },

scripts/ci/bench.js

@@ -1,211 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-const seedrandom = require('seedrandom');
-
-
-let RNG;
-
-class GPSData {
-    constructor(gpsTracesFilePath) {
-        this.tracks = {};
-        this.coordinates = [];
-        this.trackIds = [];
-        this._loadGPSTraces(gpsTracesFilePath);
-    }
-
-    _loadGPSTraces(gpsTracesFilePath) {
-        const expandedPath = path.resolve(gpsTracesFilePath);
-        const data = fs.readFileSync(expandedPath, 'utf-8');
-        const lines = data.split('\n');
-        const headers = lines[0].split(',');
-
-        const latitudeIndex = headers.indexOf('Latitude');
-        const longitudeIndex = headers.indexOf('Longitude');
-        const trackIdIndex = headers.indexOf('TrackID');
-
-        for (let i = 1; i < lines.length; i++) {
-            if (lines[i].trim() === '') continue;
-            const row = lines[i].split(',');
-
-            const latitude = parseFloat(row[latitudeIndex]);
-            const longitude = parseFloat(row[longitudeIndex]);
-            const trackId = row[trackIdIndex];
-
-            const coord = [longitude, latitude];
-            this.coordinates.push(coord);
-
-            if (!this.tracks[trackId]) {
-                this.tracks[trackId] = [];
-            }
-            this.tracks[trackId].push(coord);
-        }
-
-        this.trackIds = Object.keys(this.tracks);
-    }
-
-    getRandomCoordinate() {
-        const randomIndex = Math.floor(RNG() * this.coordinates.length);
-        return this.coordinates[randomIndex];
-    }
-
-    getRandomTrack() {
-        const randomIndex = Math.floor(RNG() * this.trackIds.length);
-        const trackId = this.trackIds[randomIndex];
-        return this.tracks[trackId];
-    }
-};
-
-async function runOSRMMethod(osrm, method, coordinates) {
-    const time = await new Promise((resolve, reject) => {
-        const startTime = process.hrtime();
-        osrm[method]({coordinates}, (err, result) => {
-            if (err) {
-                if (['NoSegment', 'NoMatch', 'NoRoute', 'NoTrips'].includes(err.message)) {
-                    resolve(null);
-                } else {
-
-                reject(err);
-                }
-            } else {
-                const endTime = process.hrtime(startTime);
-                resolve(endTime[0] + endTime[1] / 1e9);
-            }
-        });
-    });
-    return time;
-}
-
-async function nearest(osrm, gpsData) {
-    const times = [];
-    for (let i = 0; i < 1000; i++) {
-        const coord = gpsData.getRandomCoordinate();
-        times.push(await runOSRMMethod(osrm, 'nearest', [coord]));
-    }
-    return times;
-}
-
-async function route(osrm, gpsData) {
-    const times = [];
-    for (let i = 0; i < 1000; i++) {
-        const from = gpsData.getRandomCoordinate();
-        const to = gpsData.getRandomCoordinate();
-
-        
-        times.push(await runOSRMMethod(osrm, 'route', [from, to]));
-    }
-    return times;
-}
-
-async function table(osrm, gpsData) {
-    const times = [];
-    for (let i = 0; i < 250; i++) {
-        const numPoints = Math.floor(RNG() * 3) + 15;
-        const coordinates = [];
-        for (let i = 0; i < numPoints; i++) {
-            coordinates.push(gpsData.getRandomCoordinate());
-        }
-
-        
-        times.push(await runOSRMMethod(osrm, 'table', coordinates));
-    }
-    return times;
-}
-
-async function match(osrm, gpsData) {
-    const times = [];
-    for (let i = 0; i < 1000; i++) {
-        const numPoints = Math.floor(RNG() * 50) + 50;
-        const coordinates = gpsData.getRandomTrack().slice(0, numPoints);
-
-        
-        times.push(await runOSRMMethod(osrm, 'match', coordinates));
-    }
-    return times;
-}
-
-async function trip(osrm, gpsData) {
-    const times = [];
-    for (let i = 0; i < 250; i++) {
-        const numPoints = Math.floor(RNG() * 2) + 5;
-        const coordinates = [];
-        for (let i = 0; i < numPoints; i++) {
-            coordinates.push(gpsData.getRandomCoordinate());
-        }
-
-        
-        times.push(await runOSRMMethod(osrm, 'trip', coordinates));
-    }
-    return times;
-}
-
-function bootstrapConfidenceInterval(data, numSamples = 1000, confidenceLevel = 0.95) {
-    let means = [];
-    let dataLength = data.length;
-
-    for (let i = 0; i < numSamples; i++) {
-        let sample = [];
-        for (let j = 0; j < dataLength; j++) {
-            let randomIndex = Math.floor(RNG() * dataLength);
-            sample.push(data[randomIndex]);
-        }
-        let sampleMean = sample.reduce((a, b) => a + b, 0) / sample.length;
-        means.push(sampleMean);
-    }
-
-    means.sort((a, b) => a - b);
-    let lowerBoundIndex = Math.floor((1 - confidenceLevel) / 2 * numSamples);
-    let upperBoundIndex = Math.floor((1 + confidenceLevel) / 2 * numSamples);
-    let mean = means.reduce((a, b) => a + b, 0) / means.length;
-    let lowerBound = means[lowerBoundIndex];
-    let upperBound = means[upperBoundIndex];
-
-    return { mean: mean, lowerBound: lowerBound, upperBound: upperBound };
-}
-
-function calculateConfidenceInterval(data) {
-    let { mean, lowerBound, upperBound } = bootstrapConfidenceInterval(data);
-    let bestValue = Math.max(...data);
-    let errorMargin = (upperBound - lowerBound) / 2;
-
-    return { mean, errorMargin, bestValue };
-}
-
-async function main() {
-    const args = process.argv.slice(2);
-
-    const {OSRM} = require(args[0]);
-    const path = args[1];
-    const algorithm = args[2].toUpperCase();
-    const method = args[3];
-    const gpsTracesFilePath = args[4];
-    const iterations = parseInt(args[5]);
-
-    const gpsData = new GPSData(gpsTracesFilePath);
-    const osrm = new OSRM({path, algorithm});
-
-
-    const functions = {
-        route: route,
-        table: table,
-        nearest: nearest,
-        match: match,
-        trip: trip
-    };
-    const func = functions[method];
-    if (!func) {
-        throw new Error('Unknown method');
-    }
-    const allTimes = [];
-    for (let i = 0; i < iterations; i++) {
-        RNG = seedrandom(42);
-        allTimes.push((await func(osrm, gpsData)).filter(t => t !== null));
-    }
-
-    const opsPerSec = allTimes.map(times => times.length / times.reduce((a, b) => a + b, 0));
-    const { mean, errorMargin, bestValue } = calculateConfidenceInterval(opsPerSec);
-    console.log(`Ops: ${mean.toFixed(1)} ± ${errorMargin.toFixed(1)} ops/s. Best: ${bestValue.toFixed(1)} ops/s`);
-
-}
-
-main();

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, min_is_best=True):
+def calculate_confidence_interval(data):
     mean, lower, upper = bootstrap_confidence_interval(data)
-    min_value = np.min(data) if min_is_best else np.max(data)
+    min_value = np.min(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), min_is_best=False)
+    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_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/post_benchmark_results.py

@@ -102,4 +102,4 @@ def main():
         
 
 if __name__ == "__main__":
-    main()
+    main()

scripts/ci/run_benchmarks.sh

@@ -53,7 +53,6 @@ function run_benchmarks_for_folder {
     mkdir -p $RESULTS_FOLDER
 
     BENCHMARKS_FOLDER="$BINARIES_FOLDER/src/benchmarks"
-
     echo "Running match-bench MLD"
     $BENCHMARKS_FOLDER/match-bench "$FOLDER/test/data/mld/monaco.osrm" mld > "$RESULTS_FOLDER/match_mld.bench"
     echo "Running match-bench CH"
@@ -82,18 +81,6 @@ function run_benchmarks_for_folder {
     echo "Running osrm-contract"
     measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-contract $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_contract.bench"
 
-
-    for ALGORITHM in ch mld; do
-        for BENCH in nearest table trip route match; do
-            echo "Running node $BENCH $ALGORITHM"
-            START=$(date +%s.%N)
-            node $SCRIPTS_FOLDER/scripts/ci/bench.js $FOLDER/lib/binding/node_osrm.node $FOLDER/data.osrm $ALGORITHM $BENCH $GPS_TRACES > "$RESULTS_FOLDER/node_${BENCH}_${ALGORITHM}.bench" 5
-            END=$(date +%s.%N)
-            DIFF=$(echo "$END - $START" | bc)
-            echo "Took: ${DIFF}s"
-        done
-    done
-
     for ALGORITHM in ch mld; do
         for BENCH in nearest table trip route match; do
             echo "Running random $BENCH $ALGORITHM"

scripts/ci/windows-build.bat

@@ -59,22 +59,28 @@ IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
 SET test_region=monaco
 SET test_region_ch=ch\monaco
+SET test_region_corech=corech\monaco
 SET test_region_mld=mld\monaco
 SET test_osm=%test_region%.osm.pbf
-COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm%
+COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm% 
 %CONFIGURATION%\osrm-extract.exe -p %PROJECT_DIR%\profiles\car.lua %test_osm%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
 MKDIR ch
 XCOPY %test_region%.osrm.* ch\
 XCOPY %test_region%.osrm ch\
+MKDIR corech
+XCOPY %test_region%.osrm.* corech\
+XCOPY %test_region%.osrm corech\
 MKDIR mld
 XCOPY %test_region%.osrm.* mld\
 XCOPY %test_region%.osrm mld\
 %CONFIGURATION%\osrm-contract.exe %test_region_ch%.osrm
+%CONFIGURATION%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
 %CONFIGURATION%\osrm-partition.exe %test_region_mld%.osrm
 %CONFIGURATION%\osrm-customize.exe %test_region_mld%.osrm
 XCOPY /Y ch\*.* ..\test\data\ch\
+XCOPY /Y corech\*.* ..\test\data\corech\
 XCOPY /Y mld\*.* ..\test\data\mld\
 unit_tests\%CONFIGURATION%\library-tests.exe
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

scripts/update_dependencies.sh

@@ -10,7 +10,7 @@ set -o nounset
 # http://git.661346.n2.nabble.com/subtree-merges-lose-prefix-after-rebase-td7332850.html
 
 OSMIUM_PATH="osmcode/libosmium"
-OSMIUM_TAG=v2.20.0
+OSMIUM_TAG=v2.14.0
 
 SOL_PATH="ThePhD/sol2"
 SOL_TAG=v3.3.0
@@ -22,7 +22,7 @@ MICROTAR_PATH="rxi/microtar"
 MICROTAR_TAG=v0.1.0
 
 PROTOZERO_PATH="mapbox/protozero"
-PROTOZERO_TAG=v1.7.1
+PROTOZERO_TAG=v1.6.2
 
 VTZERO_PATH="mapbox/vtzero"
 VTZERO_TAG=v1.1.0
@@ -30,8 +30,8 @@ VTZERO_TAG=v1.1.0
 FMT_PATH="fmtlib/fmt"
 FMT_TAG=v10.2.1
 
-FLATBUFFERS_PATH="google/flatbuffers"
-FLATBUFFERS_TAG=v24.3.25
+ANKERL_PATH="martinus/unordered_dense"
+ANKERL_TAG=v4.4.0
 
 function update_subtree () {
     name=$(echo "$1" | tr '[:lower:]' '[:upper:]')
@@ -56,6 +56,6 @@ function update_subtree () {
 }
 
 ## Update dependencies
-for dep in osmium sol rapidjson microtar protozero vtzero fmt flatbuffers; do
+for dep in ankerl osmium sol rapidjson microtar protozero vtzero fmt; do
     update_subtree $dep
 done

src/benchmarks/bench.cpp

@@ -16,8 +16,8 @@
 #include "osrm/osrm.hpp"
 #include "osrm/status.hpp"
 
-#include "util/meminfo.hpp"
 #include <boost/assert.hpp>
+
 #include <boost/optional/optional.hpp>
 #include <cstdlib>
 #include <exception>
@@ -134,7 +134,6 @@ struct ConfidenceInterval
     double mean;
     double confidence;
     double min;
-    double max;
 };
 
 // Helper function to calculate the bootstrap confidence interval
@@ -162,10 +161,8 @@ 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 = {mean,
-                             (upper_bound - lower_bound) / 2,
-                             *std::min_element(data.begin(), data.end()),
-                             *std::max_element(data.begin(), data.end())};
+    ConfidenceInterval ci = {
+        mean, (upper_bound - lower_bound) / 2, *std::min_element(data.begin(), data.end())};
     return ci;
 }
 
@@ -263,7 +260,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.max << "ops/s." << std::endl;
+       << "best: " << ops_ci.min << "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;
@@ -360,8 +357,8 @@ void runRouteBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati
 
                       if (benchmark.radius)
                       {
-                          params.radiuses = std::vector<std::optional<double>>(
-                              params.coordinates.size(), std::make_optional(*benchmark.radius));
+                          params.radiuses = std::vector<boost::optional<double>>(
+                              params.coordinates.size(), boost::make_optional(*benchmark.radius));
                       }
 
                       engine::api::ResultT result = json::Object();
@@ -655,12 +652,6 @@ try
         std::cerr << "Unknown benchmark: " << benchmarkToRun << std::endl;
         return EXIT_FAILURE;
     }
-
-    std::cout << "Peak RAM: " << std::setprecision(3)
-              << static_cast<double>(osrm::util::PeakRAMUsedInBytes()) /
-                     static_cast<double>((1024 * 1024))
-              << "MB" << std::endl;
-
     return EXIT_SUCCESS;
 }
 catch (const std::exception &e)

src/benchmarks/json_render.cpp

@@ -9,17 +9,12 @@
 #include <rapidjson/document.h>
 #include <sstream>
 #include <stdexcept>
-#include <unordered_set>
 
 using namespace osrm;
 
 namespace
 {
 
-// we use std::string_view as a key in the object, so since here we have dynamic keys we have to
-// "hold" them somewhere okay for tests...
-static std::unordered_set<std::string> gKeysHolder;
-
 void convert(const rapidjson::Value &value, json::Value &result)
 {
     if (value.IsString())
@@ -37,8 +32,7 @@ void convert(const rapidjson::Value &value, json::Value &result)
         {
             json::Value member;
             convert(itr->value, member);
-            auto keyItr = gKeysHolder.emplace(itr->name.GetString()).first;
-            object.values.emplace(*keyItr, std::move(member));
+            object.values.emplace(itr->name.GetString(), std::move(member));
         }
         result = std::move(object);
     }
@@ -128,7 +122,6 @@ int main(int argc, char **argv)
 
     if (std::string{out_vec.begin(), out_vec.end()} != out_str || out_str != out_ss_str)
     {
-        std::cerr << "Vector/string results are not equal\n";
         throw std::logic_error("Vector/stringstream/string results are not equal");
     }
     return EXIT_SUCCESS;

src/benchmarks/route.cpp

@@ -66,8 +66,8 @@ try
 
         if (benchmark.radius)
         {
-            params.radiuses = std::vector<std::optional<double>>(
-                params.coordinates.size(), std::make_optional(*benchmark.radius));
+            params.radiuses = std::vector<boost::optional<double>>(
+                params.coordinates.size(), boost::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 <optional>
+#include <boost/optional.hpp>
 
 #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,
-                             std::optional<util::json::Value> geometry,
+                             boost::optional<util::json::Value> geometry,
                              const char *weight_name)
 {
     util::json::Object json_route;

src/engine/engine_config.cpp

@@ -12,13 +12,15 @@ 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 = 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) &&
-                              unlimited_or_more_than(default_radius, 0) && max_alternatives >= 0;
+    const bool limits_valid =
+        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)) &&
+        max_alternatives >= 0;
 
     return ((use_shared_memory && all_path_are_empty) || (use_mmap && storage_config.IsValid()) ||
             storage_config.IsValid()) &&