Remove example (no one uses this)

Simplify CMakeLists.txt
Add NOTE: label to comment in stale.yml (#6987 )
2024-07-10 13:25:25 +02:00 · 2024-07-10 12:51:46 +02:00 · 2024-07-09 21:27:46 +02:00 · 2024-07-09 20:12:47 +02:00 · 2024-07-09 19:58:03 +02:00 · 2024-07-09 19:32:03 +02:00
487 changed files with 18341 additions and 23423 deletions
@@ -13,6 +13,11 @@ Checks: >
    -bugprone-forward-declaration-namespace,
    -bugprone-sizeof-expression,
    -bugprone-throw-keyword-missing,
+    -bugprone-chained-comparison,
+    -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,
@@ -49,11 +54,13 @@ Checks: >
    -misc-misplaced-const,
    -misc-definitions-in-headers,
    -misc-unused-parameters,
+    -misc-include-cleaner,
    modernize-concat-nested-namespaces,
    modernize-use-using,
    performance-*,
-    -performance-noexcept-move-constructor,
    -performance-no-int-to-ptr,
+    -performance-enum-size,
+    -performance-avoid-endl,
    readability-*,
    -readability-avoid-const-params-in-decls,
    -readability-braces-around-statements,
@@ -82,6 +89,10 @@ Checks: >
    -readability-make-member-function-const,
    -readability-redundant-string-init,
    -readability-non-const-parameter,
+    -readability-redundant-inline-specifier,
+    -readability-avoid-nested-conditional-operator,
+    -readability-avoid-return-with-void-value,
+    -readability-redundant-casting,
    -readability-static-accessed-through-instance
    
 WarningsAsErrors: '*'
@@ -6,6 +6,9 @@ on:

 jobs:
  publish:
+    strategy:
+      matrix:
+        docker-base-image: ["debian", "alpine"]
    runs-on: ubuntu-latest
    steps:       
      - name: Check out the repo
@@ -53,10 +56,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile
+          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
          tags: ${{ steps.metadebug.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}
+            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}-${{ matrix.docker-base-image }}


      - name: Build container image - assertions
@@ -64,10 +67,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile
+          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
          tags: ${{ steps.metaassertions.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}
+            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}-${{ matrix.docker-base-image }}

      # build and publish "normal" image as last to get it listed on top
      - name: Build container image - normal
@@ -75,10 +78,7 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile
-          tags:  ${{ steps.meta.outputs.tags  }}
+          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          tags: ${{ steps.meta.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}            
-
-
-            
+            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}-${{ matrix.docker-base-image }}
@@ -15,7 +15,6 @@ env:
  CCACHE_TEMPDIR: /tmp/.ccache-temp
  CCACHE_COMPRESS: 1
  CASHER_TIME_OUT: 599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
-  CCACHE_VERSION: 3.3.1
  CMAKE_VERSION: 3.21.2
  ENABLE_NODE_BINDINGS: "ON"

@@ -31,11 +30,11 @@ jobs:
    env:
      BUILD_TYPE: Release
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - run: pip install "conan<2.0.0"
    - run: conan --version
    - run: cmake --version
-    - uses: actions/setup-node@v3
+    - uses: actions/setup-node@v4
      with:
        node-version: 18
    - run: node --version
@@ -47,15 +46,32 @@ jobs:
        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
    - run: npm install --ignore-scripts
    - run: npm link --ignore-scripts
-    - uses: microsoft/setup-msbuild@v1.1
    - name: Build
-      run: |
-        .\scripts\ci\windows-build.bat
-    - name: Run node tests
      shell: bash
      run: |
-        ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
-        node test/nodejs/index.js
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_CONAN=ON -DENABLE_NODE_BINDINGS=ON ..
+        cmake --build . --config Release
+        
+    # TODO: MSVC goes out of memory when building our tests
+    # - name: Run tests
+    #   shell: bash
+    #   run: |
+    #     cd build
+    #     cmake --build . --config Release --target tests
+    #     # TODO: run tests
+    # - name: Run node tests
+    #   shell: bash
+    #   run: |
+    #     ./lib/binding/osrm-extract.exe -p profiles/car.lua test/data/monaco.osm.pbf
+
+    #     mkdir -p test/data/ch
+    #     cp test/data/monaco.osrm* test/data/ch/
+    #     ./lib/binding/osrm-contract.exe test/data/ch/monaco.osrm
+
+    #     ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
+    #     node test/nodejs/index.js
    - name: Build Node package
      shell: bash
      run: ./scripts/ci/node_package.sh
@@ -76,13 +92,13 @@ jobs:
  format-taginfo-docs:
    runs-on: ubuntu-22.04
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: Use Node.js
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: 18
    - name: Enable Node.js cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@@ -100,15 +116,18 @@ jobs:
        npm run docs && ./scripts/error_on_dirty.sh
        npm audit --production

-  docker-image:
+  docker-image-matrix:
+    strategy:
+      matrix:
+        docker-base-image: ["debian", "alpine"]
    needs: format-taginfo-docs
    runs-on: ubuntu-22.04
    continue-on-error: false
    steps:
      - name: Check out the repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
      - name: Enable osm.pbf cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: berlin-latest.osm.pbf
          key: v1-berlin-osm-pbf
@@ -116,7 +135,7 @@ jobs:
            v1-berlin-osm-pbf
      - name: Docker build
        run: |
-          docker build -t osrm-backend-local -f docker/Dockerfile .
+          docker build -t osrm-backend-local -f docker/Dockerfile-${{ matrix.docker-base-image }} .
      - name: Test Docker image
        run: |
          if [ ! -f "${PWD}/berlin-latest.osm.pbf" ]; then
@@ -133,7 +152,6 @@ jobs:
            >&2 echo "No berlin-latest.geojson found"
            exit 1
          fi
-
          # removing `.osrm.nbg` to check that whole pipeline works without it
          rm -rf "${PWD}/berlin-latest.osrm.nbg"

@@ -152,104 +170,110 @@ jobs:
            continue-on-error: false
            node: 20
            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
            CCOMPILER: gcc-13
            CUCUMBER_TIMEOUT: 20000
            CXXCOMPILER: g++-13
            ENABLE_COVERAGE: ON

-          - name: clang-15-debug-asan-ubsan
+          - name: clang-18-debug-asan-ubsan
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Debug
-            CCOMPILER: clang-15
+            CCOMPILER: clang-18
            CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-15
+            CXXCOMPILER: clang++-18
            ENABLE_SANITIZER: ON
            TARGET_ARCH: x86_64-asan-ubsan
            OSRM_CONNECTION_RETRIES: 10
            OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5

-          - name: clang-15-release
+          - name: clang-18-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Release
-            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+            CCOMPILER: clang-18
+            CXXCOMPILER: clang++-18
            CUCUMBER_TIMEOUT: 60000
+            ENABLE_LTO: OFF

-          - name: clang-15-debug
+          - name: clang-18-debug
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Debug
-            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+            CCOMPILER: clang-18
+            CXXCOMPILER: clang++-18
            CUCUMBER_TIMEOUT: 60000
+            ENABLE_LTO: OFF

-          - name: clang-15-debug-clang-tidy
+          - name: clang-18-debug-clang-tidy
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Debug
-            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+            CCOMPILER: clang-18
+            CXXCOMPILER: clang++-18
            CUCUMBER_TIMEOUT: 60000
            ENABLE_CLANG_TIDY: ON

-          - name: clang-14-release
-            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang-14
-            CXXCOMPILER: clang++-14
-            CUCUMBER_TIMEOUT: 60000

-          - name: clang-13-release
+          - name: clang-17-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Release
-            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-13
+            CCOMPILER: clang-17
+            CXXCOMPILER: clang++-17
            CUCUMBER_TIMEOUT: 60000
+            ENABLE_LTO: OFF
+
+          - name: clang-16-release
+            continue-on-error: false
+            node: 18
+            runs-on: ubuntu-24.04
+            BUILD_TYPE: Release
+            CCOMPILER: clang-16
+            CXXCOMPILER: clang++-16
+            CUCUMBER_TIMEOUT: 60000
+            ENABLE_LTO: OFF

          - name: conan-linux-debug-asan-ubsan
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Release
-            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+            CCOMPILER: clang-18
+            CXXCOMPILER: clang++-18
            ENABLE_CONAN: ON
            ENABLE_SANITIZER: ON
+            ENABLE_LTO: OFF

          - name: conan-linux-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Release
-            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+            CCOMPILER: clang-18
+            CXXCOMPILER: clang++-18
            ENABLE_CONAN: ON
+            ENABLE_LTO: OFF
+
+          - name: gcc-14-release
+            continue-on-error: false
+            node: 20
+            runs-on: ubuntu-24.04
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-14
+            CXXCOMPILER: g++-14
+            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'

          - name: gcc-13-release
            continue-on-error: false
            node: 20
            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
            BUILD_TYPE: Release
            CCOMPILER: gcc-13
            CXXCOMPILER: g++-13
@@ -259,29 +283,19 @@ jobs:
            continue-on-error: false
            node: 20
            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
            BUILD_TYPE: Release
            CCOMPILER: gcc-12
            CXXCOMPILER: g++-12
            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'

-          - name: gcc-11-release
-            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-11
-            CXXCOMPILER: g++-11
-
          - name: conan-linux-release-node
            build_node_package: true
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Release
-            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-13
+            CCOMPILER: clang-16
+            CXXCOMPILER: clang++-16
            ENABLE_CONAN: ON
            NODE_PACKAGE_TESTS_ONLY: ON

@@ -289,10 +303,10 @@ jobs:
            build_node_package: true
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
            BUILD_TYPE: Debug
-            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-13
+            CCOMPILER: clang-16
+            CXXCOMPILER: clang++-16
            ENABLE_CONAN: ON
            NODE_PACKAGE_TESTS_ONLY: ON

@@ -324,7 +338,6 @@ jobs:
    continue-on-error: ${{ matrix.continue-on-error }}
    runs-on: ${{ matrix.runs-on }}
    env:
-      BUILD_TOOLS: ${{ matrix.BUILD_TOOLS }}
      BUILD_TYPE: ${{ matrix.BUILD_TYPE }}
      BUILD_SHARED_LIBS: ${{ matrix.BUILD_SHARED_LIBS }}
      CCOMPILER: ${{ matrix.CCOMPILER }}
@@ -341,45 +354,48 @@ 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@v3
+    - uses: actions/checkout@v4
    - name: Build machine architecture
      run: uname -m
    - name: Use Node.js
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: ${{ matrix.node }}
    - name: Enable Node.js cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
        restore-keys: |
          ${{ runner.os }}-node-
    - name: Enable compiler cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.ccache
        key: ccache-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          ccache-${{ matrix.name }}-
    - name: Enable Conan cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.conan
        key: v9-conan-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          v9-conan-${{ matrix.name }}-
    - name: Enable test cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ${{github.workspace}}/test/cache
        key: v4-test-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          v4-test-${{ matrix.name }}-
-
    - name: Prepare environment
      run: |
+        echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
+        mkdir -p $HOME/.ccache
+
        PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
        echo "OSRM_INSTALL_DIR=${GITHUB_WORKSPACE}/install-osrm" >> $GITHUB_ENV
@@ -396,7 +412,36 @@ jobs:
        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
          echo "JOBS=$((`sysctl -n hw.ncpu` + 1))" >>  $GITHUB_ENV
        fi
+    # See: https://github.com/actions/toolkit/issues/946#issuecomment-1590016041
+    # We need it to be able to access system folders while restoring cached Boost below
+    - name: Give tar root ownership 
+      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
+      run: sudo chown root /bin/tar && sudo chmod u+s /bin/tar
+    - name: Cache Boost
+      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
+      id: cache-boost
+      uses: actions/cache@v4
+      with:
+        path: |
+          /usr/local/include/boost
+          /usr/local/lib/libboost*
+        key: v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}
+        restore-keys: |
+          v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}

+    - name: Install Boost
+      if: steps.cache-boost.outputs.cache-hit != 'true' && runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
+      run: |
+        BOOST_VERSION="1.85.0"
+        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_UNDERSCORE}*
+    
    - name: Install dev dependencies
      run: |
        python3 -m pip install "conan<2.0.0" || python3 -m pip install "conan<2.0.0" --break-system-packages
@@ -417,7 +462,7 @@ jobs:
        # Linux dev packages
        if [ "${ENABLE_CONAN}" != "ON" ]; then
          sudo apt-get update -y
-          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev libboost-all-dev
+          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev
          if [[ "${CCOMPILER}" != clang-* ]]; then
            sudo apt-get install -y ${CXXCOMPILER}
          fi
@@ -427,7 +472,7 @@ jobs:
        fi

        # TBB
-        TBB_VERSION=2021.3.0
+        TBB_VERSION=2021.12.0
        if [[ "${RUNNER_OS}" == "Linux" ]]; then
          TBB_URL="https://github.com/oneapi-src/oneTBB/releases/download/v${TBB_VERSION}/oneapi-tbb-${TBB_VERSION}-lin.tgz"
        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
@@ -437,6 +482,13 @@ jobs:
        tar zxvf onetbb.tgz
        sudo cp -a oneapi-tbb-${TBB_VERSION}/lib/. /usr/local/lib/
        sudo cp -a oneapi-tbb-${TBB_VERSION}/include/. /usr/local/include/
+    - name: Add Clang 18 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Clang 18
+      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.CCOMPILER == 'clang-18' }}
+      run: |
+        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_linux_amd64 -O /usr/bin/yq && sudo chmod +x /usr/bin/yq
+
+        conan config init
+        yq eval '.compiler.clang.version += ["18"]' -i "$HOME/.conan/settings.yml"
    - name: Prepare build
      run: |
        mkdir ${OSRM_BUILD_DIR}
@@ -458,8 +510,8 @@ jobs:
      run: |
        echo "Using ${JOBS} jobs"
        pushd ${OSRM_BUILD_DIR}
-
-
+        
+        ccache --zero-stats
        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
                 -DENABLE_CONAN=${ENABLE_CONAN:-OFF} \
                 -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
@@ -468,15 +520,15 @@ jobs:
                 -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
                 -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
                 -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}

        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
          make tests --jobs=${JOBS}
          make benchmarks --jobs=${JOBS}
-          ccache -s
+
          sudo make install
          if [[ "${RUNNER_OS}" == "Linux" ]]; then
            echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib" >> $GITHUB_ENV
@@ -484,13 +536,6 @@ jobs:
          echo "PKG_CONFIG_PATH=${OSRM_INSTALL_DIR}/lib/pkgconfig" >> $GITHUB_ENV
        fi
        popd
-    - name: Build example
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
-      run: |
-        mkdir example/build && pushd example/build
-        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
-        make --jobs=${JOBS}
-        popd
    - name: Run all tests
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
      run: |
@@ -498,7 +543,6 @@ jobs:

        # macOS SIP strips the linker path. Reset this inside the running shell
        export LD_LIBRARY_PATH=${{ env.LD_LIBRARY_PATH }}
-        ./example/build/osrm-example test/data/mld/monaco.osrm

        # All tests assume to be run from the build directory
        pushd ${OSRM_BUILD_DIR}
@@ -511,7 +555,7 @@ jobs:

    - name: Use Node 18
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: 18
    - name: Run Node package tests on Node 18
@@ -521,7 +565,7 @@ jobs:
        npm run nodejs-tests
    - name: Use Node 20
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: 20
    - name: Run Node package tests on Node 20
@@ -531,7 +575,7 @@ jobs:
        npm run nodejs-tests
    - name: Use Node latest
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: latest
    - name: Run Node package tests on Node-latest
@@ -541,7 +585,7 @@ jobs:
        npm run nodejs-tests

    - name: Upload test logs
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      if: failure()
      with:
        name: logs
@@ -557,7 +601,7 @@ jobs:
    # # Uploading report to CodeCov
    # - name: Upload code coverage
    #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-    #   uses: codecov/codecov-action@v1
+    #   uses: codecov/codecov-action@v4
    #   with:
    #     files: coverage.info
    #     name: codecov-osrm-backend
@@ -579,52 +623,78 @@ jobs:
        omitNameDuringUpdate: true
        replacesArtifacts: true
        token: ${{ secrets.GITHUB_TOKEN }}
-
+    - name: Show CCache statistics
+      run: |
+        ccache -p
+        ccache -s

  benchmarks:
    if: github.event_name == 'pull_request'
    needs: [format-taginfo-docs]
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
    env:
-      CCOMPILER: clang-13
-      CXXCOMPILER: clang++-13
-      CC: clang-13
-      CXX: clang++-13
+      CCOMPILER: clang-16
+      CXXCOMPILER: clang++-16
+      CC: clang-16
+      CXX: clang++-16
      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@v3
+        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@v3
+        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@v3
+        uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
          path: pr
-      - run: python3 -m pip install "conan<2.0.0" "requests==2.31.0"
-      - name: Build PR Branch
+      - name: Install dependencies
+        run: | 
+          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" --break-system-packages
+          sudo apt-get update -y && sudo apt-get install ccache
+      - name: Prepare data
        run: |
-          mkdir -p pr/build
-          cd pr/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
-          make -j$(nproc) 
-          make -j$(nproc) benchmarks
-          cd ..
-          make -C test/data 
+          if [ "$RUN_BIG_BENCHMARK" = "true" ]; then
+              rm -rf ~/data.osm.pbf
+              wget http://download.geofabrik.de/europe/poland-latest.osm.pbf -O ~/data.osm.pbf --quiet
+              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
+              else
+                echo "Using cached data.osm.pbf"
+              fi
+              gunzip -c ./pr/test/data/berlin_gps_traces.csv.gz > ~/gps_traces.csv
+          fi
+      - name: Prepare environment
+        run: |
+          echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
+          mkdir -p $HOME/.ccache
+          ccache --zero-stats
+          ccache --max-size=256M
      - name: Checkout Base Branch
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.base.ref }}
          path: base
@@ -637,15 +707,54 @@ jobs:
          make -j$(nproc) benchmarks
          cd ..
          make -C test/data 
-      - name: Run Benchmarks
+      - name: Build PR Branch
        run: |
-          ./pr/scripts/ci/run_benchmarks.sh base pr
+          mkdir -p pr/build
+          cd pr/build
+          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: mkdir -p /opt/benchmarks
+      - name: Run PR Benchmarks 
+        run: |
+          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
+          cp -rf pr/build /opt/benchmarks/build
+          mkdir -p /opt/benchmarks/test
+          cp -rf pr/test/data /opt/benchmarks/test/data
+          cp -rf pr/profiles /opt/benchmarks/profiles
+
+          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo umount /opt/benchmarks
+      - name: Run Base Benchmarks
+        run: |
+          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 /opt/benchmarks/test/data/portugal_to_korea.json ]; then
+            cp base/src/benchmarks/portugal_to_korea.json /opt/benchmarks/test/data/portugal_to_korea.json
+          fi
+          # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
+          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo umount /opt/benchmarks
      - name: Post Benchmark Results
        run: |
          python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
+      - name: Show CCache statistics
+        run: |
+          ccache -p
+          ccache -s

  ci-complete:
    runs-on: ubuntu-22.04
-    needs: [build-test-publish, docker-image, windows-release-node, benchmarks]
+    needs: [build-test-publish, docker-image-matrix, windows-release-node, benchmarks]
    steps:
    - run: echo "CI complete"
+
@@ -0,0 +1,29 @@
+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:
+  issues: write
+  pull-requests: write
+
+jobs:
+  stale:
+    runs-on: ubuntu-24.04
+    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
+          days-before-issue-close: 30 # 1 month
+          days-before-pr-stale: 180 # 6 months
+          days-before-pr-close: -1 # never close PRs
+          exempt-issue-labels: 'Do Not Stale,Feature Request,Performance,Bug Report,CI,Starter Task,Refactor,Guidance'
+
+  
+
@@ -43,7 +43,6 @@ Thumbs.db
 #######################
 /_build*
 /build/
-/example/build/
 /test/data/monaco.osrm*
 /test/data/ch
 /test/data/corech
@@ -1,12 +1,17 @@
 # Unreleased
  - Changes from 5.27.1
    - Features
+      - 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)
      - ADDED: Add support for disabling feature datasets. [#6666](https://github.com/Project-OSRM/osrm-backend/pull/6666)
      - ADDED: Add support for opposite approach request parameter. [#6842](https://github.com/Project-OSRM/osrm-backend/pull/6842)
      - ADDED: Add support for accessing edge flags in `process_segment` [#6658](https://github.com/Project-OSRM/osrm-backend/pull/6658)
    - Build:
+      - CHANGED: Upgrade clang-format to version 15. [#6919](https://github.com/Project-OSRM/osrm-backend/pull/6919)
+      - CHANGED: Use Debian Bookworm as base Docker image [#6904](https://github.com/Project-OSRM/osrm-backend/pull/6904)
+      - CHANGED: Upgrade CI actions to latest versions [#6893](https://github.com/Project-OSRM/osrm-backend/pull/6893)
+      - CHANGED:  Remove outdated warnings #6894 [#6894](https://github.com/Project-OSRM/osrm-backend/pull/6894)
      - ADDED: Add CI job which builds OSRM with gcc 12. [#6455](https://github.com/Project-OSRM/osrm-backend/pull/6455)
      - CHANGED: Upgrade to clang-tidy 15. [#6439](https://github.com/Project-OSRM/osrm-backend/pull/6439)
      - CHANGED: Update actions/cache to v3. [#6420](https://github.com/Project-OSRM/osrm-backend/pull/6420)
@@ -19,7 +24,36 @@
    - NodeJS:
      - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
    - Misc:
-      - CHANGED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551), see also [#6592](https://github.com/Project-OSRM/osrm-backend/issues/6592)
+      - CHANGED: Add .reserve(...) to assembleGeometry function. [#6983](https://github.com/Project-OSRM/osrm-backend/pull/6983)
+      - CHANGED: Get rid of boost::optional leftovers. [#6977](https://github.com/Project-OSRM/osrm-backend/pull/6977)
+      - CHANGED: Use Link Time Optimisation whenever possible. [#6967](https://github.com/Project-OSRM/osrm-backend/pull/6967)
+      - CHANGED: Use struct instead of tuple to define UnpackedPath. [#6974](https://github.com/Project-OSRM/osrm-backend/pull/6974)
+      - CHANGED: Micro performance optimisation in map matching. [#6976](https://github.com/Project-OSRM/osrm-backend/pull/6976)
+      - CHANGED: Re-use priority queue in StaticRTree. [#6952](https://github.com/Project-OSRM/osrm-backend/pull/6952)
+      - CHANGED: Optimise encodePolyline function. [#6940](https://github.com/Project-OSRM/osrm-backend/pull/6940)
+      - CHANGED: Avoid reallocations in base64 encoding. [#6951](https://github.com/Project-OSRM/osrm-backend/pull/6951)
+      - CHANGED: Get rid of unused Boost dependencies. [#6960](https://github.com/Project-OSRM/osrm-backend/pull/6960)
+      - CHANGED: Apply micro-optimisation for Table & Trip APIs. [#6949](https://github.com/Project-OSRM/osrm-backend/pull/6949)
+      - CHANGED: Apply micro-optimisation for Route API. [#6948](https://github.com/Project-OSRM/osrm-backend/pull/6948)
+      - CHANGED: Apply micro-optimisation for Match API. [#6945](https://github.com/Project-OSRM/osrm-backend/pull/6945)
+      - CHANGED: Apply micro-optimisation for Nearest API. [#6944](https://github.com/Project-OSRM/osrm-backend/pull/6944)
+      - CHANGED: Avoid copy of intersection in totalTurnAngle. [#6938](https://github.com/Project-OSRM/osrm-backend/pull/6938)
+      - CHANGED: Use std::unordered_map::emplace instead of operator[] when producing JSONs. [#6936](https://github.com/Project-OSRM/osrm-backend/pull/6936)
+      - CHANGED: Avoid copy of vectors in MakeRoute function. [#6939](https://github.com/Project-OSRM/osrm-backend/pull/6939)
+      - FIXED: Fix bugprone-unused-return-value clang-tidy warning. [#6934](https://github.com/Project-OSRM/osrm-backend/pull/6934)
+      - FIXED: Fix performance-noexcept-move-constructor clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6933)
+      - FIXED: Fix performance-noexcept-swap clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6931)
+      - CHANGED: Use custom struct instead of std::pair in QueryHeap. [#6921](https://github.com/Project-OSRM/osrm-backend/pull/6921)
+      - CHANGED: Use std::string_view::starts_with instead of boost::starts_with. [#6918](https://github.com/Project-OSRM/osrm-backend/pull/6918)
+      - CHANGED: Get rid of boost::math::constants::* and M_PI in favor of std::numbers. [#6916](https://github.com/Project-OSRM/osrm-backend/pull/6916)
+      - CHANGED: Make constants in PackedVector constexpr. [#6917](https://github.com/Project-OSRM/osrm-backend/pull/6917)
+      - CHANGED: Use std::variant instead of mapbox::util::variant. [#6903](https://github.com/Project-OSRM/osrm-backend/pull/6903)
+      - CHANGED: Bump rapidjson to version f9d53419e912910fd8fa57d5705fa41425428c35 [#6906](https://github.com/Project-OSRM/osrm-backend/pull/6906)
+      - CHANGED: Bump mapbox/variant to version 1.2.0 [#6898](https://github.com/Project-OSRM/osrm-backend/pull/6898)
+      - CHANGED: Avoid copy of std::function-based callback in path unpacking [#6895](https://github.com/Project-OSRM/osrm-backend/pull/6895)
+      - CHANGED: Replace boost::hash by std::hash [#6892](https://github.com/Project-OSRM/osrm-backend/pull/6892)
+      - CHANGED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551)
+      - CHANGED: Replace boost::filesystem with std::filesystem [#6432](https://github.com/Project-OSRM/osrm-backend/pull/6432)
      - CHANGED: Update Conan Boost version to 1.85.0. [#6868](https://github.com/Project-OSRM/osrm-backend/pull/6868)
      - FIXED: Fix an error in a RouteParameters AnnotationsType operator overload. [#6646](https://github.com/Project-OSRM/osrm-backend/pull/6646)
      - ADDED: Add support for "unlimited" to be passed as a value for the default-radius and max-matching-radius flags. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
@@ -49,6 +83,7 @@
      - FIXED: Remove force-loop checks for routes with u-turns [#6858](https://github.com/Project-OSRM/osrm-backend/pull/6858)
      - FIXED: Correctly check runtime search conditions for forcing routing steps [#6866](https://github.com/Project-OSRM/osrm-backend/pull/6866)
    - Map Matching:
+      - CHANGED: Optimise path distance calculation in MLD map matching even more. [#6884](https://github.com/Project-OSRM/osrm-backend/pull/6884)
      - CHANGED: Optimise path distance calculation in MLD map matching. [#6876](https://github.com/Project-OSRM/osrm-backend/pull/6876)
      - CHANGED: Optimise R-tree queries in the case of map matching. [#6881](https://github.com/Project-OSRM/osrm-backend/pull/6876)
    - Debug tiles:
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.18)
-
-set(CMAKE_CXX_STANDARD 17)
+project(OSRM C CXX)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)

@@ -10,6 +10,12 @@ Please create a directory and run cmake from there, passing the path to this sou
 This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
 endif()

+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+  message(STATUS "Building on a 64 bit system")
+else()
+  message(FATAL_ERROR "Building on a 32 bit system is not supported")
+endif()
+
 # detect if this is included as subproject and if so expose
 # some variables to its parent scope
 get_directory_property(BUILD_AS_SUBPROJECT PARENT_DIRECTORY)
@@ -22,40 +28,36 @@ if (NOT WIN32 AND NOT DEFINED ENV{OSRM_BUILD_DIR})
  set(ENV{OSRM_BUILD_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 endif()

-option(ENABLE_CONAN "Use conan for dependencies" OFF)
-option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
-option(BUILD_TOOLS "Build OSRM tools" OFF)
-option(BUILD_PACKAGE "Build OSRM package" OFF)
-option(BUILD_ROUTED "Build osrm-routed HTTP server" ON)
-option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
-option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
-option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
-option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
-option(ENABLE_LTO "Use LTO if available" OFF)
-option(ENABLE_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)
-    message(FATAL_ERROR "ENABLE_CLANG_TIDY is ON but clang-tidy is not found!")
-  else()
-    message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
-    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
-  endif()
-endif()
-
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")

-# be compatible with version handling before cmake 3.x
-if (POLICY CMP0057)
-  cmake_policy(SET CMP0057 NEW)
+option(BUILD_PACKAGE "Build OSRM package" OFF)
+option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
+option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
+option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
+option(ENABLE_CONAN "Use conan for dependencies" OFF)
+option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
+option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
+option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
+option(ENABLE_LTO "Use Link Time Optimisation" ON)
+option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
+option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
+
+if (ENABLE_CLANG_TIDY)
+  find_program(CLANG_TIDY_COMMAND NAMES clang-tidy REQUIRED)
+  message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
+  set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
 endif()
-if (POLICY CMP0074)
-  cmake_policy(SET CMP0074 NEW)
+
+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()
-project(OSRM C CXX)

 # add @loader_path/$ORIGIN to rpath to make binaries relocatable
 if (APPLE)
@@ -73,14 +75,14 @@ sbeParseJson(packagejson packagejsonraw)
 # This regex is not strict enough, but the correct one is too complicated for cmake matching.
 # https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
 if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)([-+][0-9a-zA-Z.-]+)?$")
-    set(OSRM_VERSION_MAJOR            ${CMAKE_MATCH_1})
-    set(OSRM_VERSION_MINOR            ${CMAKE_MATCH_2})
-    set(OSRM_VERSION_PATCH            ${CMAKE_MATCH_3})
-    set(OSRM_VERSION_PRERELEASE_BUILD ${CMAKE_MATCH_4})
+  set(OSRM_VERSION_MAJOR            ${CMAKE_MATCH_1})
+  set(OSRM_VERSION_MINOR            ${CMAKE_MATCH_2})
+  set(OSRM_VERSION_PATCH            ${CMAKE_MATCH_3})
+  set(OSRM_VERSION_PRERELEASE_BUILD ${CMAKE_MATCH_4})

-    set(OSRM_VERSION packagejson.version)
+  set(OSRM_VERSION packagejson.version)
 else()
-    message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible label, but found ${packagejson.version}")
+  message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible label, but found ${packagejson.version}")
 endif()

 if (MSVC)
@@ -112,18 +114,11 @@ include(CheckCXXCompilerFlag)
 include(FindPackageHandleStandardArgs)
 include(GNUInstallDirs)

-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  message(STATUS "Building on a 64 bit system")
-else()
-  message(FATAL_ERROR "Building on a 32 bit system is not supported")
-endif()
-
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2-3.3.0/include)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/variant/include)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)

-set(BOOST_COMPONENTS date_time chrono filesystem iostreams program_options regex system thread unit_test_framework)
+set(BOOST_COMPONENTS date_time iostreams program_options thread unit_test_framework)

 configure_file(
  ${CMAKE_CURRENT_SOURCE_DIR}/include/util/version.hpp.in
@@ -139,7 +134,6 @@ file(GLOB UpdaterGlob src/updater/*.cpp)
 file(GLOB StorageGlob src/storage/*.cpp)
 file(GLOB ServerGlob src/server/*.cpp src/server/**/*.cpp)
 file(GLOB EngineGlob src/engine/*.cpp src/engine/**/*.cpp)
-file(GLOB ErrorcodesGlob src/osrm/errorcodes.cpp)

 add_library(UTIL OBJECT ${UtilGlob})
 add_library(EXTRACTOR OBJECT ${ExtractorGlob})
@@ -150,14 +144,11 @@ add_library(CONTRACTOR OBJECT ${ContractorGlob})
 add_library(UPDATER OBJECT ${UpdaterGlob})
 add_library(STORAGE OBJECT ${StorageGlob})
 add_library(ENGINE OBJECT ${EngineGlob})
-
-if (BUILD_ROUTED)
-  add_library(SERVER OBJECT ${ServerGlob})
-  add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
-endif()
+add_library(SERVER OBJECT ${ServerGlob})

 set_target_properties(UTIL PROPERTIES LINKER_LANGUAGE CXX)

+add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
 add_executable(osrm-extract src/tools/extract.cpp)
 add_executable(osrm-partition src/tools/partition.cpp)
 add_executable(osrm-customize src/tools/customize.cpp)
@@ -209,17 +200,6 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -ggdb")
 endif()

-if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
-  if(LTO_SUPPORTED)
-      message(STATUS "IPO / LTO enabled")
-      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-  else()
-      message(WARNING "IPO / LTO not supported: <${error}>")
-  endif()
-endif()
-
 set(MAYBE_COVERAGE_LIBRARIES "")
 if (ENABLE_COVERAGE)
  if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
@@ -267,7 +247,6 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
  add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
  add_dependency_defines(-D_CRT_SECURE_NO_WARNINGS)
  add_dependency_defines(-DNOMINMAX) # avoid min and max macros that can break compilation
-  add_dependency_defines(-D_USE_MATH_DEFINES) #needed for M_PI with cmath.h
  add_dependency_defines(-D_WIN32_WINNT=0x0501)
  add_dependency_defines(-DXML_STATIC)
  find_library(ws2_32_LIBRARY_PATH ws2_32)
@@ -292,6 +271,7 @@ include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})

 add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
 set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
+
 target_no_warning(MICROTAR unused-variable)
 target_no_warning(MICROTAR format)

@@ -332,20 +312,12 @@ if(ENABLE_CONAN)

  set(CONAN_BOOST_VERSION "1.85.0@#14265ec82b25d91305bbb3b30d3357f8")
  set(CONAN_BZIP2_VERSION "1.0.8@#d1b2d5816f25865acf978501dff1f897")
-  set(CONAN_EXPAT_VERSION "2.2.10@#916908d4a570ad839edd25322c3268cd")
-  set(CONAN_LUA_VERSION "5.4.4@#3ec62efc37cd0a5d80b9e5cb35277360")
-  set(CONAN_TBB_VERSION "2021.3.0@#507ec17cbd51a84167e143b20d170eea")
+  set(CONAN_EXPAT_VERSION "2.6.2@#2d385d0d50eb5561006a7ff9e356656b")
+  set(CONAN_LUA_VERSION "5.4.6@#658d6089093cf01992c2737ab2e96763")
+  set(CONAN_TBB_VERSION "2021.12.0@#e56e5b44be8d690530585dd3634c0106")

  set(CONAN_SYSTEM_INCLUDES ON)

-  # TODO:
-  # if we link TBB dynamically osrm-extract.exe finishes on the first access to any TBB symbol
-  # with exit code = -1073741515, which means that program cannot load required DLL.
-  if (MSVC)
-    set(TBB_SHARED False)
-  else()
-    set(TBB_SHARED True)
-  endif()

  set(CONAN_ARGS
    REQUIRES
@@ -358,9 +330,7 @@ if(ENABLE_CONAN)
    GENERATORS cmake_find_package json  # json generator generates a conanbuildinfo.json in the build folder so (non-CMake) projects can easily parse OSRM's dependencies
    KEEP_RPATHS
    NO_OUTPUT_DIRS
-    OPTIONS boost:filesystem_version=3 # https://stackoverflow.com/questions/73392648/error-with-boost-filesystem-version-in-cmake
-            onetbb:shared=${TBB_SHARED}
-            boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
+    OPTIONS boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
    BUILD missing
  )

@@ -389,14 +359,10 @@ if(ENABLE_CONAN)
  set(Boost_USE_STATIC_LIBS ON)
  find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
  set(Boost_DATE_TIME_LIBRARY "${Boost_date_time_LIB_TARGETS}")
-  set(Boost_CHRONO_LIBRARY "${Boost_chrono_LIB_TARGETS}")
  set(Boost_PROGRAM_OPTIONS_LIBRARY "${Boost_program_options_LIB_TARGETS}")
-  set(Boost_FILESYSTEM_LIBRARY "${Boost_filesystem_LIB_TARGETS}")
  set(Boost_IOSTREAMS_LIBRARY "${Boost_iostreams_LIB_TARGETS}")
  set(Boost_THREAD_LIBRARY "${Boost_thread_LIB_TARGETS}")
-  set(Boost_SYSTEM_LIBRARY "${Boost_system_LIB_TARGETS}")
  set(Boost_ZLIB_LIBRARY "${Boost_zlib_LIB_TARGETS}")
-  set(Boost_REGEX_LIBRARY "${Boost_regex_LIB_TARGETS}")
  set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY "${Boost_unit_test_framework_LIB_TARGETS}")


@@ -469,7 +435,6 @@ add_dependency_includes(${ZLIB_INCLUDE_DIRS})

 add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
 add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
-add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)

 # Workaround for https://github.com/boostorg/phoenix/issues/111
 add_dependency_defines(-DBOOST_PHOENIX_STL_TUPLE_H_)
@@ -479,11 +444,8 @@ include_directories(SYSTEM ${DEPENDENCIES_INCLUDE_DIRS})

 set(BOOST_BASE_LIBRARIES
   ${Boost_DATE_TIME_LIBRARY}
-   ${Boost_CHRONO_LIBRARY}
-   ${Boost_FILESYSTEM_LIBRARY}
   ${Boost_IOSTREAMS_LIBRARY}
-   ${Boost_THREAD_LIBRARY}
-   ${Boost_SYSTEM_LIBRARY})
+   ${Boost_THREAD_LIBRARY})

 set(BOOST_ENGINE_LIBRARIES
  ${Boost_ZLIB_LIBRARY}
@@ -496,13 +458,10 @@ target_link_libraries(osrm-extract osrm_extract ${Boost_PROGRAM_OPTIONS_LIBRARY}
 target_link_libraries(osrm-partition osrm_partition ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_link_libraries(osrm-customize osrm_customize ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_link_libraries(osrm-contract osrm_contract ${Boost_PROGRAM_OPTIONS_LIBRARY})
-if (BUILD_ROUTED)
-  target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
-endif()
+target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})

 set(EXTRACTOR_LIBRARIES
    ${BZIP2_LIBRARIES}
-    ${Boost_REGEX_LIBRARY}
    ${BOOST_BASE_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
    ${EXPAT_LIBRARIES}
@@ -573,18 +532,13 @@ target_link_libraries(osrm_partition ${PARTITIONER_LIBRARIES})
 target_link_libraries(osrm_customize ${CUSTOMIZER_LIBRARIES} osrm_update osrm_store)
 target_link_libraries(osrm_store ${STORAGE_LIBRARIES})

-# BUILD_COMPONENTS
 add_executable(osrm-components src/tools/components.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 target_link_libraries(osrm-components ${TBB_LIBRARIES} ${BOOST_BASE_LIBRARIES} ${UTIL_LIBRARIES})
 install(TARGETS osrm-components DESTINATION bin)

-if(BUILD_TOOLS)
-  message(STATUS "Activating OSRM internal tools")
-  add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
-  target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES} ${TBB_LIBRARIES})
-
-  install(TARGETS osrm-io-benchmark DESTINATION bin)
-endif()
+add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
+target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES} ${TBB_LIBRARIES})
+install(TARGETS osrm-io-benchmark DESTINATION bin)

 if (ENABLE_ASSERTIONS)
  message(STATUS "Enabling assertions")
@@ -603,49 +557,14 @@ set_property(TARGET osrm-extract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-partition PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-contract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-if (BUILD_ROUTED)
-  set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-endif()
+set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)

-file(GLOB VariantGlob third_party/variant/include/mapbox/*.hpp)
-file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
-file(GLOB LibraryGlob include/osrm/*.hpp)
-file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
-set(ApiHeader include/engine/api/base_result.hpp)
-set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/bearing.hpp include/engine/approach.hpp include/engine/phantom_node.hpp)
-set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/alias.hpp include/util/exception.hpp include/util/bearing.hpp)
-set(ExtractorHeader include/extractor/extractor.hpp include/storage/io_config.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
-set(PartitionerHeader include/partitioner/partitioner.hpp include/partitioner/partitioner_config.hpp)
-set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)
-set(StorageHeader include/storage/storage.hpp include/storage/io_config.hpp include/storage/storage_config.hpp)
-install(FILES ${EngineHeader} DESTINATION include/osrm/engine)
-install(FILES ${UtilHeader} DESTINATION include/osrm/util)
-install(FILES ${StorageHeader} DESTINATION include/osrm/storage)
-install(FILES ${ExtractorHeader} DESTINATION include/osrm/extractor)
-install(FILES ${PartitionerHeader} DESTINATION include/osrm/partitioner)
-install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
-install(FILES ${LibraryGlob} DESTINATION include/osrm)
-install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
-install(FILES ${ApiHeader} DESTINATION include/osrm/engine/api)
-install(FILES ${VariantGlob} DESTINATION include/mapbox)
-install(FILES ${FlatbuffersGlob} DESTINATION include/flatbuffers)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)
 install(TARGETS osrm-customize DESTINATION bin)
 install(TARGETS osrm-contract DESTINATION bin)
 install(TARGETS osrm-datastore DESTINATION bin)
-if (BUILD_ROUTED)
-  install(TARGETS osrm-routed DESTINATION bin)
-endif()
-install(TARGETS osrm DESTINATION lib)
-install(TARGETS osrm_extract DESTINATION lib)
-install(TARGETS osrm_partition DESTINATION lib)
-install(TARGETS osrm_customize DESTINATION lib)
-install(TARGETS osrm_update DESTINATION lib)
-install(TARGETS osrm_contract DESTINATION lib)
-install(TARGETS osrm_store DESTINATION lib)
-install(TARGETS osrm_guidance DESTINATION lib)
-
+install(TARGETS osrm-routed DESTINATION bin)

 # Install profiles and support library to /usr/local/share/osrm/profiles by default
 set(DefaultProfilesDir profiles)
@@ -656,8 +575,6 @@ set(DefaultProfilesDir data)
 install(DIRECTORY ${DefaultProfilesDir} DESTINATION share/osrm)

 # Setup exporting variables for pkgconfig and subproject
-#
-
 if(BUILD_PACKAGE)
  include(CPackConfig)
  include(CPack)
@@ -734,7 +651,6 @@ if (ENABLE_NODE_BINDINGS)
  add_subdirectory(src/nodejs)
 endif()

-
 if (ENABLE_FUZZING)
  # Requires libosrm being built with sanitizers; make configurable and default to ubsan
  set(FUZZ_SANITIZER "undefined" CACHE STRING "Sanitizer to be used for Fuzz testing")
@@ -768,4 +684,3 @@ foreach(header ${headers_to_check})
 endforeach()
 add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
 set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
-
@@ -55,7 +55,7 @@ function(_get_msvc_ide_version result)
        set(${result} 15 PARENT_SCOPE)
    elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930)
        set(${result} 16 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1950)
        set(${result} 17 PARENT_SCOPE)
    else()
        message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]")
@@ -50,9 +50,7 @@ add_warning(all)
 add_warning(extra)
 add_warning(pedantic)
 add_warning(error) # treat all warnings as errors
-if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    add_warning(strict-overflow=2)
-elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
    add_warning(strict-overflow=1)
 endif()
 add_warning(suggest-override)
@@ -66,7 +64,6 @@ add_warning(init-self)
 add_warning(bool-compare)
 add_warning(logical-not-parentheses)
 add_warning(logical-op)
-add_warning(maybe-uninitialized)
 add_warning(misleading-indentation)
 # `no-` prefix is part of warning name(i.e. doesn't mean we are disabling it)
 add_warning(no-return-local-addr)
@@ -79,15 +76,13 @@ add_warning(sizeof-array-argument)
 add_warning(switch-bool)
 add_warning(tautological-compare)
 add_warning(trampolines)
-no_warning(c++17-extensions)
-# TODO: these warnings are not enabled by default, but we consider them as useful and good to enable in the future
-no_warning(implicit-int-conversion)
-no_warning(implicit-float-conversion)
-no_warning(unused-member-function)
-no_warning(old-style-cast)
-no_warning(non-virtual-dtor)
-no_warning(float-conversion)
-no_warning(sign-conversion)
-no_warning(shorten-64-to-32)
-no_warning(padded)
-no_warning(missing-noreturn)
+# these warnings are not enabled by default
+# no_warning(name-of-warning)
+no_warning(deprecated-comma-subscript)
+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()
@@ -1,67 +0,0 @@
-FROM debian:bullseye-slim as builder
-ARG DOCKER_TAG
-ARG BUILD_CONCURRENCY
-RUN mkdir -p /src  && mkdir -p /opt
-
-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.74-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.3.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)} && \
-    echo "Building OSRM ${DOCKER_TAG}" && \
-    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
-    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
-    mkdir -p build && \
-    cd build && \
-    BUILD_TYPE="Release" && \
-    ENABLE_ASSERTIONS="Off" && \
-    BUILD_TOOLS="Off" && \
-    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
-    make -j${NPROC} install && \
-    cd ../profiles && \
-    cp -r * /opt && \
-    strip /usr/local/bin/* && \
-    rm -rf /src
-
-
-# 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:bullseye-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 libboost-program-options1.74.0 libboost-regex1.74.0 \
-        libboost-date-time1.74.0 libboost-chrono1.74.0 libboost-filesystem1.74.0 \
-        libboost-iostreams1.74.0 libboost-system1.74.0 libboost-thread1.74.0 \
-        expat liblua5.4-0 && \
-    rm -rf /var/lib/apt/lists/* && \
-# add /usr/local/lib to ldconfig to allow loading libraries from there
-    ldconfig /usr/local/lib
-
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
-
-WORKDIR /opt
-
-EXPOSE 5000
@@ -0,0 +1 @@
+Dockerfile-debian
@@ -0,0 +1,61 @@
+FROM alpine:3.20.0 as alpine-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
+ARG DOCKER_TAG
+ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
+
+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
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    echo "Building OSRM ${DOCKER_TAG}" && \
+    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
+    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
+    mkdir -p build && \
+    cd build && \
+    BUILD_TYPE="Release" && \
+    ENABLE_ASSERTIONS="Off" && \
+    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On";; esac && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DENABLE_LTO=OFF && \
+    make -j${NPROC} install && \
+    cd ../profiles && \
+    cp -r * /opt && \
+    strip /usr/local/bin/* && \
+    rm -rf /src
+
+
+# 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
+
+COPY --from=builder /usr/local /usr/local
+COPY --from=builder /opt /opt
+
+RUN apk add --no-cache \
+    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 && \
+    /usr/local/bin/osrm-routed --help && \
+    /usr/local/bin/osrm-contract --help && \
+    /usr/local/bin/osrm-partition --help && \
+    /usr/local/bin/osrm-customize --help
+
+WORKDIR /opt
+
+EXPOSE 5000
@@ -0,0 +1,66 @@
+FROM debian:bookworm-slim as builder
+ARG DOCKER_TAG
+ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
+
+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" && \
+    echo "Building OSRM ${DOCKER_TAG}" && \
+    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
+    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
+    mkdir -p build && \
+    cd build && \
+    BUILD_TYPE="Release" && \
+    ENABLE_ASSERTIONS="Off" && \
+    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On";; esac && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DENABLE_LTO=On && \
+    make -j${NPROC} install && \
+    cd ../profiles && \
+    cp -r * /opt && \
+    strip /usr/local/bin/* && \
+    rm -rf /src
+
+
+# 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
+
+COPY --from=builder /usr/local /usr/local
+COPY --from=builder /opt /opt
+
+RUN apt-get update && \
+    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
+    ldconfig /usr/local/lib
+
+RUN /usr/local/bin/osrm-extract --help && \
+    /usr/local/bin/osrm-routed --help && \
+    /usr/local/bin/osrm-contract --help && \
+    /usr/local/bin/osrm-partition --help && \
+    /usr/local/bin/osrm-customize --help
+
+WORKDIR /opt
+
+EXPOSE 5000
@@ -6,4 +6,8 @@
 # ensure that "COPY . /src" is referring to the repo root, not the directory
 # that contains the Dockerfile.
 # This script gets executed with a pwd of wherever the Dockerfile is.
-docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..
+
+DOCKER_BUILD="docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY} --build-arg DOCKER_TAG=${DOCKER_TAG:?unset} -t ${IMAGE_NAME:?unset} -f"
+
+$DOCKER_BUILD Dockerfile ..
+$DOCKER_BUILD Dockerfile-alpine ..
@@ -1,33 +0,0 @@
-## Introduction
-
-OSRM can be used as a library (libosrm) via C++ instead of using it through the HTTP interface and `osrm-routed`. This allows for fine-tuning OSRM and has much less overhead. Here is a quick introduction into how to use `libosrm` in the upcoming v5 release.
-
-Take a look at the example code that lives in the [example directory](https://github.com/Project-OSRM/osrm-backend/tree/master/example). Here is all you ever wanted to know about `libosrm`, that is a short description of what the types do and where to find documentation on it:
-
-## Important interface objects
-
- [`EngineConfig`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/engine_config.hpp) - for initializing an OSRM instance we can configure certain properties and constraints. E.g. the storage config is the base path such as `france.osm.osrm` from which we derive and load `france.osm.osrm.*` auxiliary files. This also lets you set constraints such as the maximum number of locations allowed for specific services.
-
- [`OSRM`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/osrm/osrm.hpp) - this is the main Routing Machine type with functions such as `Route` and `Table`. You initialize it with a `EngineConfig`. It does all the heavy lifting for you. Each function takes its own parameters, e.g. the `Route` function takes `RouteParameters`, and a out-reference to a JSON result that gets filled. The return value is a `Status`, indicating error or success.
-
- [`Status`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/status.hpp) - this is a type wrapping `Error` or `Ok` for indicating error or success, respectively.
-
- [`TableParameters`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/api/table_parameters.hpp) - this is an example of parameter types the Routing Machine functions expect. In this case `Table` expects its own parameters as `TableParameters`. You can see it wrapping two vectors, sources and destinations --- these are indices into your coordinates for the table service to construct a matrix from (empty sources or destinations means: use all of them). If you ask yourself where coordinates come from, you can see `TableParameters` inheriting from `BaseParameters`.
-
- [`BaseParameter`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/api/base_parameters.hpp) - this most importantly holds coordinates (and a few other optional properties that you don't need for basic usage); the specific parameter types inherit from `BaseParameters` to get these member attributes. That means your `TableParameters` type has `coordinates`, `sources` and `destination` member attributes (and a few other that we ignore for now).
-
- [`Coordinate`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/util/coordinate.hpp) - this is a wrapper around a (longitude, latitude) pair. We really don't care about (lon,lat) vs (lat, lon) but we don't want you to accidentally mix them up, so both latitude and longitude are strictly typed wrappers around integers (fixed notation such as `13423240`) and floating points (floating notation such as `13.42324`).
-
- [Parameters for other services](https://github.com/Project-OSRM/osrm-backend/tree/master/include/engine/api) - here are all other `*Parameters` you need for other Routing Machine services.
-
- [JSON](https://github.com/Project-OSRM/osrm-backend/blob/master/include/util/json_container.hpp) - this is a sum type resembling JSON. The Routing Machine service functions take a out-ref to a JSON result and fill it accordingly. It is currently implemented using [mapbox/variant](https://github.com/mapbox/variant) which is similar to [Boost.Variant](http://www.boost.org/doc/libs/1_55_0/doc/html/variant.html). There are two ways to work with this sum type: either provide a visitor that acts on each type on visitation or use the `get` function in case you're sure about the structure. The JSON structure is written down in the [HTTP API](#http-api).
-
-## Example
-
-See [the example folder](https://github.com/Project-OSRM/osrm-backend/tree/master/example) in the OSRM repository.
-
-## Workflow
-
- - Create an `OSRM` instance initialized with a `EngineConfig`
- - Call the service function on the `OSRM` object providing service specific `*Parameters`
- - Check the return code and use the JSON result
@@ -21,7 +21,7 @@ var osrm = new OSRM('network.osrm');
 **Parameters**

 -   `options` **([Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String))** Options for creating an OSRM object or string to the `.osrm` file. (optional, default `{shared_memory:true}`)
-    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
+    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', or 'MLD'. Default is 'CH'.
               Make sure you prepared the dataset with the correct toolchain.
    -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
               This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
@@ -1,34 +0,0 @@
-cmake_minimum_required(VERSION 3.18)
-
-if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
-  message(FATAL_ERROR "In-source builds are not allowed.
-Please create a directory and run cmake from there, passing the path to this source directory as the last argument.
-This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
-endif()
-
-if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
-  set(CMAKE_BUILD_TYPE Release)
-endif()
-
-project(osrm-example C CXX)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  message(STATUS "Building on a 64 bit system")
-else()
-  message(STATUS "Building on a 32 bit system")
-endif()
-
-link_directories(${LibOSRM_LIBRARY_DIRS})
-add_executable(osrm-example example.cpp)
-
-find_package(LibOSRM REQUIRED)
-
-target_link_libraries(osrm-example ${LibOSRM_LIBRARIES} ${LibOSRM_DEPENDENT_LIBRARIES})
-include_directories(SYSTEM ${LibOSRM_INCLUDE_DIRS})
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LibOSRM_CXXFLAGS}")
@@ -1,63 +0,0 @@
-# - Try to find LibOSRM
-# Once done this will define
-#  LibOSRM_FOUND - System has LibOSRM
-#  LibOSRM_LIBRARIES - The libraries and ldflags needed to use LibOSRM
-#  LibOSRM_DEPENDENT_LIBRARIES - The libraries and ldflags need to link LibOSRM dependencies
-#  LibOSRM_LIBRARY_DIRS - The libraries paths needed to find LibOSRM
-#  LibOSRM_CXXFLAGS - Compiler switches required for using LibOSRM
-
-find_package(PkgConfig)
-pkg_search_module(PC_LibOSRM QUIET libosrm)
-
-function(JOIN VALUES GLUE OUTPUT)
-  string (REPLACE ";" "${GLUE}" _TMP_STR "${VALUES}")
-  set (${OUTPUT} "${_TMP_STR}" PARENT_SCOPE)
-endfunction()
-
-list(REMOVE_ITEM PC_LibOSRM_CFLAGS " ")
-JOIN("${PC_LibOSRM_CFLAGS}" " " output)
-
-set(LibOSRM_CXXFLAGS ${output})
-set(LibOSRM_LIBRARY_DIRS ${PC_LibOSRM_LIBRARY_DIRS})
-
-find_path(LibOSRM_INCLUDE_DIR osrm/osrm.hpp
-  PATH_SUFFIXES osrm include/osrm include
-  HINTS ${PC_LibOSRM_INCLUDEDIR} ${PC_LibOSRM_INCLUDE_DIRS}
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt/local
-  /opt)
-
-find_library(TEST_LibOSRM_STATIC_LIBRARY Names osrm.lib libosrm.a
-  PATH_SUFFIXES osrm lib/osrm lib
-  HINTS ${PC_LibOSRM_LIBDIR} ${PC_LibOSRM_LIBRARY_DIRS}
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt/local
-  /opt)
-find_library(TEST_LibOSRM_DYNAMIC_LIBRARY Names libosrm.dylib libosrm.so
-  PATH_SUFFIXES osrm lib/osrm lib
-  HINTS ${PC_LibOSRM_LIBDIR} ${PC_LibOSRM_LIBRARY_DIRS}
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt/local
-  /opt)
-
-set(LibOSRM_DEPENDENT_LIBRARIES ${PC_LibOSRM_STATIC_LDFLAGS})
-set(LibOSRM_LIBRARIES ${PC_LibOSRM_LDFLAGS})
-
-include(FindPackageHandleStandardArgs)
-# handle the QUIETLY and REQUIRED arguments and set LIBOSRM_FOUND to TRUE
-# if all listed variables are TRUE
-find_package_handle_standard_args(LibOSRM DEFAULT_MSG
-                                LibOSRM_LIBRARY_DIRS
-                                LibOSRM_CXXFLAGS
-                                LibOSRM_LIBRARIES
-                                LibOSRM_DEPENDENT_LIBRARIES
-                                LibOSRM_INCLUDE_DIR)
@@ -1 +0,0 @@
-../../cmake/FindTBB.cmake
@@ -1,90 +0,0 @@
-#include "osrm/match_parameters.hpp"
-#include "osrm/nearest_parameters.hpp"
-#include "osrm/route_parameters.hpp"
-#include "osrm/table_parameters.hpp"
-#include "osrm/trip_parameters.hpp"
-
-#include "osrm/coordinate.hpp"
-#include "osrm/engine_config.hpp"
-#include "osrm/json_container.hpp"
-
-#include "osrm/osrm.hpp"
-#include "osrm/status.hpp"
-
-#include <exception>
-#include <iostream>
-#include <string>
-#include <utility>
-
-#include <cstdlib>
-
-int main(int argc, const char *argv[])
-{
-    if (argc < 2)
-    {
-        std::cerr << "Usage: " << argv[0] << " data.osrm\n";
-        return EXIT_FAILURE;
-    }
-
-    using namespace osrm;
-
-    // Configure based on a .osrm base path, and no datasets in shared mem from osrm-datastore
-    EngineConfig config;
-
-    config.storage_config = {argv[1]};
-    config.use_shared_memory = false;
-
-    // We support two routing speed up techniques:
-    // - Contraction Hierarchies (CH): requires extract+contract pre-processing
-    // - Multi-Level Dijkstra (MLD): requires extract+partition+customize pre-processing
-    //
-    // config.algorithm = EngineConfig::Algorithm::CH;
-    config.algorithm = EngineConfig::Algorithm::MLD;
-
-    // Routing machine with several services (such as Route, Table, Nearest, Trip, Match)
-    const OSRM osrm{config};
-
-    // The following shows how to use the Route service; configure this service
-    RouteParameters params;
-
-    // Route in monaco
-    params.coordinates.push_back({util::FloatLongitude{7.419758}, util::FloatLatitude{43.731142}});
-    params.coordinates.push_back({util::FloatLongitude{7.419505}, util::FloatLatitude{43.736825}});
-
-    // Response is in JSON format
-    engine::api::ResultT result = json::Object();
-
-    // Execute routing request, this does the heavy lifting
-    const auto status = osrm.Route(params, result);
-
-    auto &json_result = result.get<json::Object>();
-    if (status == Status::Ok)
-    {
-        auto &routes = json_result.values["routes"].get<json::Array>();
-
-        // Let's just use the first route
-        auto &route = routes.values.at(0).get<json::Object>();
-        const auto distance = route.values["distance"].get<json::Number>().value;
-        const auto duration = route.values["duration"].get<json::Number>().value;
-
-        // Warn users if extract does not contain the default coordinates from above
-        if (distance == 0 || duration == 0)
-        {
-            std::cout << "Note: distance or duration is zero. ";
-            std::cout << "You are probably doing a query outside of the OSM extract.\n\n";
-        }
-
-        std::cout << "Distance: " << distance << " meter\n";
-        std::cout << "Duration: " << duration << " seconds\n";
-        return EXIT_SUCCESS;
-    }
-    else if (status == Status::Error)
-    {
-        const auto code = json_result.values["code"].get<json::String>().value;
-        const auto message = json_result.values["message"].get<json::String>().value;
-
-        std::cout << "Code: " << code << "\n";
-        std::cout << "Message: " << code << "\n";
-        return EXIT_FAILURE;
-    }
-}
@@ -42,7 +42,7 @@ module.exports = function () {
        this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
        this.OSRM_IP = process.env.OSRM_IP || '127.0.0.1';
        this.OSRM_CONNECTION_RETRIES = process.env.OSRM_CONNECTION_RETRIES && parseInt(process.env.OSRM_CONNECTION_RETRIES) || 10;
-        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.0;
+        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.1;

        this.HOST = `http://${this.OSRM_IP}:${this.OSRM_PORT}`;

@@ -31,8 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/io_config.hpp"
 #include "updater/updater_config.hpp"

-#include <boost/filesystem/path.hpp>
-
+#include <filesystem>
 #include <string>

 namespace osrm::contractor
@@ -47,7 +46,7 @@ struct ContractorConfig final : storage::IOConfig
    }

    // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
@@ -1,128 +0,0 @@
-#ifndef ITERATOR_BASED_CRC32_H
-#define ITERATOR_BASED_CRC32_H
-
-#if defined(__x86_64__) && !defined(__MINGW64__)
-#include <cpuid.h>
-#endif
-
-#include <boost/crc.hpp> // for boost::crc_32_type
-
-#include <iterator>
-
-namespace osrm::contractor
-{
-
-class IteratorbasedCRC32
-{
-  public:
-    bool UsingHardware() const { return use_hardware_implementation; }
-
-    IteratorbasedCRC32() : crc(0) { use_hardware_implementation = DetectHardwareSupport(); }
-
-    template <class Iterator> unsigned operator()(Iterator iter, const Iterator end)
-    {
-        unsigned crc = 0;
-        while (iter != end)
-        {
-            using value_type = typename std::iterator_traits<Iterator>::value_type;
-            const char *data = reinterpret_cast<const char *>(&(*iter));
-
-            if (use_hardware_implementation)
-            {
-                crc = ComputeInHardware(data, sizeof(value_type));
-            }
-            else
-            {
-                crc = ComputeInSoftware(data, sizeof(value_type));
-            }
-            ++iter;
-        }
-        return crc;
-    }
-
-  private:
-    bool DetectHardwareSupport() const
-    {
-        static const int sse42_bit = 0x00100000;
-        const unsigned ecx = cpuid();
-        const bool sse42_found = (ecx & sse42_bit) != 0;
-        return sse42_found;
-    }
-
-    unsigned ComputeInSoftware(const char *str, unsigned len)
-    {
-        crc_processor.process_bytes(str, len);
-        return crc_processor.checksum();
-    }
-
-    // adapted from http://byteworm.com/2010/10/13/crc32/
-    unsigned ComputeInHardware(const char *str, unsigned len)
-    {
-#if defined(__x86_64__)
-        unsigned q = len / sizeof(unsigned);
-        unsigned r = len % sizeof(unsigned);
-        unsigned *p = (unsigned *)str;
-
-        // crc=0;
-        while (q--)
-        {
-            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
-                                 : "=S"(crc)
-                                 : "0"(crc), "c"(*p));
-            ++p;
-        }
-
-        str = reinterpret_cast<char *>(p);
-        while (r--)
-        {
-            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
-                                 : "=S"(crc)
-                                 : "0"(crc), "c"(*str));
-            ++str;
-        }
-#else
-        (void)str;
-        (void)len;
-#endif
-        return crc;
-    }
-
-    inline unsigned cpuid() const
-    {
-        unsigned eax = 0, ebx = 0, ecx = 0, edx = 0;
-        // on X64 this calls hardware cpuid(.) instr. otherwise a dummy impl.
-        __get_cpuid(1, &eax, &ebx, &ecx, &edx);
-        return ecx;
-    }
-
-#if defined(__MINGW64__) || defined(_MSC_VER) || !defined(__x86_64__)
-    inline void __get_cpuid(int /*param*/,
-                            unsigned * /*eax*/,
-                            unsigned * /*ebx*/,
-                            unsigned *ecx,
-                            unsigned * /*edx*/) const
-    {
-        *ecx = 0;
-    }
-#endif
-
-    boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> crc_processor;
-    unsigned crc;
-    bool use_hardware_implementation;
-};
-
-struct RangebasedCRC32
-{
-    template <typename Iteratable> unsigned operator()(const Iteratable &iterable)
-    {
-        return crc32(std::begin(iterable), std::end(iterable));
-    }
-
-    bool UsingHardware() const { return crc32.UsingHardware(); }
-
-  private:
-    IteratorbasedCRC32 crc32;
-};
-} // namespace osrm::contractor
-
-#endif /* ITERATOR_BASED_CRC32_H */
@@ -9,7 +9,7 @@ namespace osrm::contractor::files
 {
 // reads .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                      std::unordered_map<std::string, ContractedMetricT> &metrics,
                      std::uint32_t &connectivity_checksum)
 {
@@ -30,7 +30,7 @@ inline void readGraph(const boost::filesystem::path &path,

 // writes .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                       const std::unordered_map<std::string, ContractedMetricT> &metrics,
                       const std::uint32_t connectivity_checksum)
 {
@@ -1,9 +1,8 @@
 #ifndef OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 #define OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP

-#include <boost/filesystem/path.hpp>
-
 #include <array>
+#include <filesystem>
 #include <string>

 #include "storage/io_config.hpp"
@@ -27,7 +26,7 @@ struct CustomizationConfig final : storage::IOConfig
    {
    }

-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
@@ -9,7 +9,7 @@

 #include "storage/shared_memory_ownership.hpp"

-#include <boost/filesystem/path.hpp>
+#include <filesystem>

 namespace osrm::customizer
 {
@@ -14,7 +14,7 @@ namespace osrm::customizer::files

 // reads .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void readCellMetrics(const boost::filesystem::path &path,
+inline void readCellMetrics(const std::filesystem::path &path,
                            std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@@ -44,7 +44,7 @@ inline void readCellMetrics(const boost::filesystem::path &path,
 // writes .osrm.cell_metrics file
 template <typename CellMetricT>
 inline void
-writeCellMetrics(const boost::filesystem::path &path,
+writeCellMetrics(const std::filesystem::path &path,
                 const std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@@ -72,7 +72,7 @@ writeCellMetrics(const boost::filesystem::path &path,

 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                      MultiLevelGraphT &graph,
                      std::uint32_t &connectivity_checksum)
 {
@@ -88,7 +88,7 @@ inline void readGraph(const boost::filesystem::path &path,

 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                       const MultiLevelGraphT &graph,
                       const std::uint32_t connectivity_checksum)
 {
@@ -33,7 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "engine/hint.hpp"
 #include "util/coordinate.hpp"

-#include <boost/optional.hpp>
+#include <optional>

 #include <algorithm>
 #include <vector>
@@ -74,12 +74,12 @@ struct BaseParameters
    };

    std::vector<util::Coordinate> coordinates;
-    std::vector<boost::optional<Hint>> hints;
-    std::vector<boost::optional<double>> radiuses;
-    std::vector<boost::optional<Bearing>> bearings;
-    std::vector<boost::optional<Approach>> approaches;
+    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<std::string> exclude;
-    boost::optional<OutputFormatType> format = OutputFormatType::JSON;
+    std::optional<OutputFormatType> format = OutputFormatType::JSON;

    // Adds hints to response which can be included in subsequent requests, see `hints` above.
    bool generate_hints = true;
@@ -90,10 +90,10 @@ struct BaseParameters
    SnappingType snapping = SnappingType::Default;

    BaseParameters(std::vector<util::Coordinate> coordinates_ = {},
-                   std::vector<boost::optional<Hint>> hints_ = {},
-                   std::vector<boost::optional<double>> radiuses_ = {},
-                   std::vector<boost::optional<Bearing>> bearings_ = {},
-                   std::vector<boost::optional<Approach>> approaches_ = {},
+                   std::vector<std::optional<Hint>> hints_ = {},
+                   std::vector<std::optional<double>> radiuses_ = {},
+                   std::vector<std::optional<Bearing>> bearings_ = {},
+                   std::vector<std::optional<Approach>> approaches_ = {},
                   bool generate_hints_ = true,
                   std::vector<std::string> exclude = {},
                   const SnappingType snapping_ = SnappingType::Default)
@@ -112,7 +112,7 @@ struct BaseParameters
               (approaches.empty() || approaches.size() == coordinates.size()) &&
               std::all_of(bearings.begin(),
                           bearings.end(),
-                           [](const boost::optional<Bearing> &bearing_and_range)
+                           [](const std::optional<Bearing> &bearing_and_range)
                           {
                               if (bearing_and_range)
                               {
@@ -2,7 +2,7 @@
 #define ENGINE_API_BASE_RESULT_HPP

 #include <flatbuffers/flatbuffers.h>
-#include <mapbox/variant.hpp>
+#include <variant>

 #include <string>

@@ -10,8 +10,7 @@

 namespace osrm::engine::api
 {
-using ResultT =
-    mapbox::util::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
+using ResultT = std::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
 } // namespace osrm::engine::api

 #endif
@@ -12,7 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"

-#include <boost/optional.hpp>
+#include <optional>

 #include <algorithm>
 #include <iterator>
@@ -41,7 +41,7 @@ inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection
    return intersection.lanes.lanes_in_turn > 0;
 }

-util::json::Array coordinateToLonLat(const util::Coordinate &coordinate);
+util::json::Value coordinateToLonLat(const util::Coordinate &coordinate);

 /**
 * Ensures that a bearing value is a whole number, and clamped to the range 0-359
@@ -79,7 +79,7 @@ util::json::Object makeGeoJSONGeometry(ForwardIter begin, ForwardIter end)
        coordinates.values.push_back(location);
        coordinates.values.push_back(location);
    }
-    geojson.values["coordinates"] = std::move(coordinates);
+    geojson.values["coordinates"] = util::json::Value{std::move(coordinates)};

    return geojson;
 }
@@ -90,7 +90,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo

 util::json::Object makeRoute(const guidance::Route &route,
                             util::json::Array legs,
-                             boost::optional<util::json::Value> geometry,
+                             std::optional<util::json::Value> geometry,
                             const char *weight_name);

 // Creates a Waypoint without Hint, see the Hint overload below
@@ -30,14 +30,14 @@ class MatchAPI final : public RouteAPI
                      osrm::engine::api::ResultT &response) const
    {
        BOOST_ASSERT(sub_matchings.size() == sub_routes.size());
-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(sub_matchings, sub_routes, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(sub_matchings, sub_routes, json_result);
        }
    }
@@ -77,19 +77,19 @@ class MatchAPI final : public RouteAPI
                                   sub_routes[index].unpacked_path_segments,
                                   sub_routes[index].source_traversed_in_reverse,
                                   sub_routes[index].target_traversed_in_reverse);
-            route.values["confidence"] = sub_matchings[index].confidence;
-            routes.values.push_back(std::move(route));
+            route.values.emplace("confidence", sub_matchings[index].confidence);
+            routes.values.emplace_back(std::move(route));
        }
        if (!parameters.skip_waypoints)
        {
-            response.values["tracepoints"] = MakeTracepoints(sub_matchings);
+            response.values.emplace("tracepoints", MakeTracepoints(sub_matchings));
        }
-        response.values["matchings"] = std::move(routes);
-        response.values["code"] = "Ok";
+        response.values.emplace("matchings", std::move(routes));
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -132,13 +132,13 @@ class MatchAPI final : public RouteAPI

            if (tidy_result.can_be_removed[trace_index])
            {
-                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
                continue;
            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
-                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
                continue;
            }
            const auto &phantom =
@@ -165,7 +165,7 @@ class MatchAPI final : public RouteAPI
            {
                waypoint->add_waypoint_index(matching_index.point_index);
            }
-            waypoints.push_back(waypoint->Finish());
+            waypoints.emplace_back(waypoint->Finish());
        }

        return fb_result.CreateVector(waypoints);
@@ -186,23 +186,23 @@ class MatchAPI final : public RouteAPI
        {
            if (tidy_result.can_be_removed[trace_index])
            {
-                waypoints.values.push_back(util::json::Null());
+                waypoints.values.emplace_back(util::json::Null());
                continue;
            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
-                waypoints.values.push_back(util::json::Null());
+                waypoints.values.emplace_back(util::json::Null());
                continue;
            }
            const auto &phantom =
                sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index];
            auto waypoint = BaseAPI::MakeWaypoint({phantom});
-            waypoint.values["matchings_index"] = matching_index.sub_matching_index;
-            waypoint.values["waypoint_index"] = matching_index.point_index;
-            waypoint.values["alternatives_count"] =
-                sub_matchings[matching_index.sub_matching_index]
-                    .alternatives_count[matching_index.point_index];
+            waypoint.values.emplace("matchings_index", matching_index.sub_matching_index);
+            waypoint.values.emplace("waypoint_index", matching_index.point_index);
+            waypoint.values.emplace("alternatives_count",
+                                    sub_matchings[matching_index.sub_matching_index]
+                                        .alternatives_count[matching_index.point_index]);
            // waypoint indices need to be adjusted if route legs were collapsed
            // waypoint parameter assumes there is only one match object
            if (!parameters.waypoints.empty())
@@ -217,7 +217,7 @@ class MatchAPI final : public RouteAPI
                    waypoint.values["waypoint_index"] = util::json::Null();
                }
            }
-            waypoints.values.push_back(std::move(waypoint));
+            waypoints.values.emplace_back(std::move(waypoint));
        }

        return waypoints;
@@ -29,14 +29,14 @@ class NearestAPI final : public BaseAPI
        BOOST_ASSERT(phantom_nodes.size() == 1);
        BOOST_ASSERT(parameters.coordinates.size() == 1);

-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(phantom_nodes, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(phantom_nodes, json_result);
        }
    }
@@ -45,7 +45,7 @@ class NearestAPI final : public BaseAPI
                      flatbuffers::FlatBufferBuilder &fb_result) const
    {
        auto data_timestamp = facade.GetTimestamp();
-        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
+        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
        if (!data_timestamp.empty())
        {
            data_version_string = fb_result.CreateString(data_timestamp);
@@ -100,23 +100,23 @@ class NearestAPI final : public BaseAPI
                               auto waypoint = MakeWaypoint({phantom_node});

                               util::json::Array nodes;
+                               nodes.values.reserve(2);

                               auto node_values = MakeNodes(phantom_node);

-                               nodes.values.push_back(node_values.first);
-                               nodes.values.push_back(node_values.second);
-                               waypoint.values["nodes"] = std::move(nodes);
-
+                               nodes.values.emplace_back(node_values.first);
+                               nodes.values.emplace_back(node_values.second);
+                               waypoint.values.emplace("nodes", std::move(nodes));
                               return waypoint;
                           });
-            response.values["waypoints"] = std::move(waypoints);
+            response.values.emplace("waypoints", std::move(waypoints));
        }

-        response.values["code"] = "Ok";
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -50,14 +50,14 @@ class RouteAPI : public BaseAPI
    {
        BOOST_ASSERT(!raw_routes.routes.empty());

-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(raw_routes, waypoint_candidates, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(raw_routes, waypoint_candidates, json_result);
        }
    }
@@ -110,14 +110,14 @@ class RouteAPI : public BaseAPI

        if (!parameters.skip_waypoints)
        {
-            response.values["waypoints"] = BaseAPI::MakeWaypoints(waypoint_candidates);
+            response.values.emplace("waypoints", BaseAPI::MakeWaypoints(waypoint_candidates));
        }
-        response.values["routes"] = std::move(jsRoutes);
-        response.values["code"] = "Ok";
+        response.values.emplace("routes", std::move(jsRoutes));
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -158,8 +158,8 @@ class RouteAPI : public BaseAPI
    }

    template <typename ForwardIter>
-    mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
-                          flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+    std::variant<flatbuffers::Offset<flatbuffers::String>,
+                 flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
    MakeGeometry(flatbuffers::FlatBufferBuilder &builder, ForwardIter begin, ForwardIter end) const
    {
        if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
@@ -184,10 +184,10 @@ class RouteAPI : public BaseAPI
        return builder.CreateVectorOfStructs(coordinates);
    }

-    boost::optional<util::json::Value>
-    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
+    std::optional<util::json::Value>
+    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
    {
-        boost::optional<util::json::Value> json_geometry;
+        std::optional<util::json::Value> json_geometry;
        if (annotations)
        {
            auto begin = annotations->begin();
@@ -340,8 +340,8 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
+        std::vector<guidance::RouteLeg> &legs = legs_info.first;
+        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
        auto route = guidance::assembleRoute(legs);

        // Fill legs
@@ -408,8 +408,8 @@ class RouteAPI : public BaseAPI

        // Fill geometry
        auto overview = MakeOverview(leg_geometries);
-        mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
-                              flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+        std::variant<flatbuffers::Offset<flatbuffers::String>,
+                     flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
            geometry;
        if (overview)
        {
@@ -426,8 +426,7 @@ class RouteAPI : public BaseAPI
        routeObject.add_legs(legs_vector);
        if (overview)
        {
-            mapbox::util::apply_visitor(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject),
-                                        geometry);
+            std::visit(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject), geometry);
        }

        return routeObject.Finish();
@@ -443,23 +442,22 @@ class RouteAPI : public BaseAPI
        if (requested_annotations & RouteParameters::AnnotationsType::Speed)
        {
            double prev_speed = 0;
-            speed =
-                GetAnnotations<float>(fb_result,
-                                      leg_geometry,
-                                      [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                                      {
-                                          if (anno.duration < std::numeric_limits<float>::min())
-                                          {
-                                              return prev_speed;
-                                          }
-                                          else
-                                          {
-                                              auto speed =
-                                                  round(anno.distance / anno.duration * 10.) / 10.;
-                                              prev_speed = speed;
-                                              return util::json::clamp_float(speed);
-                                          }
-                                      });
+            speed = GetAnnotations<float>(
+                fb_result,
+                leg_geometry,
+                [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                {
+                    if (anno.duration < std::numeric_limits<float>::min())
+                    {
+                        return prev_speed;
+                    }
+                    else
+                    {
+                        auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
+                        prev_speed = speed;
+                        return util::json::clamp_float(speed);
+                    }
+                });
        }

        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration;
@@ -645,7 +643,7 @@ class RouteAPI : public BaseAPI
        stepBuilder.add_rotary_pronunciation(rotary_pronunciation_string);
        stepBuilder.add_intersections(intersections_vector);
        stepBuilder.add_maneuver(maneuver_buffer);
-        mapbox::util::apply_visitor(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
+        std::visit(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
        return stepBuilder.Finish();
    };

@@ -718,12 +716,11 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
+        std::vector<guidance::RouteLeg> &legs = legs_info.first;
+        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;

        auto route = guidance::assembleRoute(legs);
-        boost::optional<util::json::Value> json_overview =
-            MakeGeometry(MakeOverview(leg_geometries));
+        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));

        std::vector<util::json::Value> step_geometries;
        const auto total_step_count =
@@ -786,49 +783,57 @@ class RouteAPI : public BaseAPI
                if (requested_annotations & RouteParameters::AnnotationsType::Speed)
                {
                    double prev_speed = 0;
-                    annotation.values["speed"] = GetAnnotations(
-                        leg_geometry,
-                        [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                        {
-                            if (anno.duration < std::numeric_limits<double>::min())
-                            {
-                                return prev_speed;
-                            }
-                            else
-                            {
-                                auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
-                                prev_speed = speed;
-                                return util::json::clamp_float(speed);
-                            }
-                        });
+                    annotation.values.emplace(
+                        "speed",
+                        GetAnnotations(leg_geometry,
+                                       [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                                       {
+                                           if (anno.duration < std::numeric_limits<double>::min())
+                                           {
+                                               return prev_speed;
+                                           }
+                                           else
+                                           {
+                                               auto speed =
+                                                   std::round(anno.distance / anno.duration * 10.) /
+                                                   10.;
+                                               prev_speed = speed;
+                                               return util::json::clamp_float(speed);
+                                           }
+                                       }));
                }

                if (requested_annotations & RouteParameters::AnnotationsType::Duration)
                {
-                    annotation.values["duration"] =
+                    annotation.values.emplace(
+                        "duration",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.duration; });
+                                       { return anno.duration; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Distance)
                {
-                    annotation.values["distance"] =
+                    annotation.values.emplace(
+                        "distance",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.distance; });
+                                       { return anno.distance; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Weight)
                {
-                    annotation.values["weight"] = GetAnnotations(
-                        leg_geometry,
-                        [](const guidance::LegGeometry::Annotation &anno) { return anno.weight; });
+                    annotation.values.emplace(
+                        "weight",
+                        GetAnnotations(leg_geometry,
+                                       [](const guidance::LegGeometry::Annotation &anno)
+                                       { return anno.weight; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
                {
-                    annotation.values["datasources"] =
+                    annotation.values.emplace(
+                        "datasources",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.datasource; });
+                                       { return anno.datasource; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
                {
@@ -839,7 +844,7 @@ class RouteAPI : public BaseAPI
                        nodes.values.push_back(
                            static_cast<std::uint64_t>(facade.GetOSMNodeIDOfNode(node_id)));
                    }
-                    annotation.values["nodes"] = std::move(nodes);
+                    annotation.values.emplace("nodes", std::move(nodes));
                }
                // Add any supporting metadata, if needed
                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
@@ -855,8 +860,8 @@ class RouteAPI : public BaseAPI
                            break;
                        datasource_names.values.push_back(std::string(facade.GetDatasourceName(i)));
                    }
-                    metadata.values["datasource_names"] = datasource_names;
-                    annotation.values["metadata"] = metadata;
+                    metadata.values.emplace("datasource_names", datasource_names);
+                    annotation.values.emplace("metadata", metadata);
                }

                annotations.push_back(std::move(annotation));
@@ -991,10 +996,10 @@ class RouteAPI : public BaseAPI
        return result;
    }

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

    bool IsValid() const
@@ -50,14 +50,14 @@ class TableAPI final : public BaseAPI
                 const std::vector<TableCellRef> &fallback_speed_cells,
                 osrm::engine::api::ResultT &response) const
    {
-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(tables, candidates, fallback_speed_cells, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(tables, candidates, fallback_speed_cells, json_result);
        }
    }
@@ -179,7 +179,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values["sources"] = MakeWaypoints(candidates);
+                response.values.emplace("sources", MakeWaypoints(candidates));
            }
            number_of_sources = candidates.size();
        }
@@ -187,7 +187,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values["sources"] = MakeWaypoints(candidates, parameters.sources);
+                response.values.emplace("sources", MakeWaypoints(candidates, parameters.sources));
            }
        }

@@ -195,7 +195,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values["destinations"] = MakeWaypoints(candidates);
+                response.values.emplace("destinations", MakeWaypoints(candidates));
            }
            number_of_destinations = candidates.size();
        }
@@ -203,34 +203,37 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values["destinations"] =
-                    MakeWaypoints(candidates, parameters.destinations);
+                response.values.emplace("destinations",
+                                        MakeWaypoints(candidates, parameters.destinations));
            }
        }

        if (parameters.annotations & TableParameters::AnnotationsType::Duration)
        {
-            response.values["durations"] =
-                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
+            response.values.emplace(
+                "durations",
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations));
        }

        if (parameters.annotations & TableParameters::AnnotationsType::Distance)
        {
-            response.values["distances"] =
-                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations);
+            response.values.emplace(
+                "distances",
+                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations));
        }

        if (parameters.fallback_speed != from_alias<double>(INVALID_FALLBACK_SPEED) &&
            parameters.fallback_speed > 0)
        {
-            response.values["fallback_speed_cells"] = MakeEstimatesTable(fallback_speed_cells);
+            response.values.emplace("fallback_speed_cells",
+                                    MakeEstimatesTable(fallback_speed_cells));
        }

-        response.values["code"] = "Ok";
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -377,7 +380,8 @@ class TableAPI final : public BaseAPI
                               return util::json::Value(
                                   util::json::Number(from_alias<double>(duration) / 10.));
                           });
-            json_table.values.push_back(std::move(json_row));
+
+            json_table.values.push_back(util::json::Value{json_row});
        }
        return json_table;
    }
@@ -406,7 +410,7 @@ class TableAPI final : public BaseAPI
                               return util::json::Value(util::json::Number(
                                   std::round(from_alias<double>(distance) * 10) / 10.));
                           });
-            json_table.values.push_back(std::move(json_row));
+            json_table.values.push_back(util::json::Value{json_row});
        }
        return json_table;
    }
@@ -415,15 +419,18 @@ class TableAPI final : public BaseAPI
    MakeEstimatesTable(const std::vector<TableCellRef> &fallback_speed_cells) const
    {
        util::json::Array json_table;
-        std::for_each(fallback_speed_cells.begin(),
-                      fallback_speed_cells.end(),
-                      [&](const auto &cell)
-                      {
-                          util::json::Array row;
-                          row.values.push_back(util::json::Number(cell.row));
-                          row.values.push_back(util::json::Number(cell.column));
-                          json_table.values.push_back(std::move(row));
-                      });
+        std::for_each(
+            fallback_speed_cells.begin(),
+            fallback_speed_cells.end(),
+            [&](const auto &cell)
+            {
+                util::json::Array row;
+                util::json::Value jCellRow{util::json::Number(static_cast<double>(cell.row))};
+                util::json::Value jCellColumn{util::json::Number(static_cast<double>(cell.column))};
+                row.values.push_back(jCellRow);
+                row.values.push_back(jCellColumn);
+                json_table.values.push_back(util::json::Value{row});
+            });
        return json_table;
    }

@@ -27,14 +27,14 @@ class TripAPI final : public RouteAPI
    {
        BOOST_ASSERT(sub_trips.size() == sub_routes.size());

-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(sub_trips, sub_routes, candidates, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(sub_trips, sub_routes, candidates, json_result);
        }
    }
@@ -79,14 +79,14 @@ class TripAPI final : public RouteAPI
        }
        if (!parameters.skip_waypoints)
        {
-            response.values["waypoints"] = MakeWaypoints(sub_trips, candidates);
+            response.values.emplace("waypoints", MakeWaypoints(sub_trips, candidates));
        }
-        response.values["trips"] = std::move(routes);
-        response.values["code"] = "Ok";
+        response.values.emplace("trips", std::move(routes));
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -151,8 +151,8 @@ class TripAPI final : public RouteAPI
            BOOST_ASSERT(!trip_index.NotUsed());

            auto waypoint = BaseAPI::MakeWaypoint(candidates[input_index]);
-            waypoint.values["trips_index"] = trip_index.sub_trip_index;
-            waypoint.values["waypoint_index"] = trip_index.point_index;
+            waypoint.values.emplace("trips_index", trip_index.sub_trip_index);
+            waypoint.values.emplace("waypoint_index", trip_index.point_index);
            waypoints.values.push_back(std::move(waypoint));
        }

@@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "engine/api/route_parameters.hpp"

-#include <boost/optional.hpp>
+#include <optional>
 #include <vector>

 namespace osrm::engine::api
@@ -47,24 +47,29 @@ namespace engine
 // Encodes a chunk of memory to Base64.
 inline std::string encodeBase64(const unsigned char *first, std::size_t size)
 {
-    std::vector<unsigned char> bytes{first, first + size};
-    BOOST_ASSERT(!bytes.empty());
+    BOOST_ASSERT(size > 0);

-    std::size_t bytes_to_pad{0};
+    std::string encoded;
+    encoded.reserve(((size + 2) / 3) * 4);

-    while (bytes.size() % 3 != 0)
+    auto padding = (3 - size % 3) % 3;
+
+    BOOST_ASSERT(padding == 0 || padding == 1 || padding == 2);
+
+    for (auto itr = detail::Base64FromBinary(first); itr != detail::Base64FromBinary(first + size);
+         ++itr)
    {
-        bytes_to_pad += 1;
-        bytes.push_back(0);
+        encoded.push_back(*itr);
    }

-    BOOST_ASSERT(bytes_to_pad == 0 || bytes_to_pad == 1 || bytes_to_pad == 2);
-    BOOST_ASSERT_MSG(0 == bytes.size() % 3, "base64 input data size is not a multiple of 3");
+    for (size_t index = 0; index < padding; ++index)
+    {
+        encoded.push_back('=');
+    }

-    std::string encoded{detail::Base64FromBinary{bytes.data()},
-                        detail::Base64FromBinary{bytes.data() + (bytes.size() - bytes_to_pad)}};
+    BOOST_ASSERT(encoded.size() == (size + 2) / 3 * 4);

-    return encoded.append(bytes_to_pad, '=');
+    return encoded;
 }

 // C++11 standard 3.9.1/1: Plain char, signed char, and unsigned char are three distinct types
@@ -55,7 +55,7 @@ template <> class AlgorithmDataFacade<CH>

    virtual EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
                                    const NodeID edge_based_node_to,
-                                    const std::function<bool(EdgeData)> filter) const = 0;
+                                    const std::function<bool(const EdgeData &)> &filter) const = 0;
 };

 template <> class AlgorithmDataFacade<MLD>
@@ -130,9 +130,10 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
            edge_based_node_from, edge_based_node_to, result);
    }

-    EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
-                            const NodeID edge_based_node_to,
-                            std::function<bool(EdgeData)> filter) const override final
+    EdgeID
+    FindSmallestEdge(const NodeID edge_based_node_from,
+                     const NodeID edge_based_node_to,
+                     const std::function<bool(const EdgeData &)> &filter) const override final
    {
        return m_query_graph.FindSmallestEdge(edge_based_node_from, edge_based_node_to, filter);
    }
@@ -176,7 +177,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade

    SharedRTree m_static_rtree;
    std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
-    boost::filesystem::path file_index_path;
+    std::filesystem::path file_index_path;

    std::optional<extractor::IntersectionBearingsView> intersection_bearings_view;

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

        return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, max_results, max_distance, bearing, boost::none);
+            input_coordinate, approach, max_results, max_distance, bearing, std::nullopt);
    }

    PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const boost::optional<double> max_distance,
-                                                     const boost::optional<Bearing> bearing,
+                                                     const std::optional<double> max_distance,
+                                                     const std::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const override final
    {
@@ -35,6 +35,7 @@
 #include <cstddef>

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

    virtual std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const size_t max_results,
-                        const boost::optional<double> max_distance,
-                        const boost::optional<Bearing> bearing,
+                        const std::optional<double> max_distance,
+                        const std::optional<Bearing> bearing,
                        const Approach approach) const = 0;

    virtual PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const boost::optional<double> max_distance,
-                                                     const boost::optional<Bearing> bearing,
+                                                     const std::optional<double> max_distance,
+                                                     const std::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const = 0;

@@ -31,8 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/storage_config.hpp"
 #include "osrm/datasets.hpp"

-#include <boost/filesystem/path.hpp>
-
+#include <filesystem>
 #include <set>
 #include <string>

@@ -54,14 +53,10 @@ namespace osrm::engine
 *
 * In addition, shared memory can be used for datasets loaded with osrm-datastore.
 *
- * You can chose between three algorithms:
+ * You can chose between two algorithms:
 *  - Algorithm::CH
 *      Contraction Hierarchies, extremely fast queries but slow pre-processing. The default right
 * now.
- *  - Algorithm::CoreCH
- *      Deprecated, to be removed in v6.0
- *      Contraction Hierachies with partial contraction for faster pre-processing but slower
- * queries.
 *  - Algorithm::MLD
 *      Multi Level Dijkstra, moderately fast in both pre-processing and query.
 *
@@ -74,7 +69,6 @@ struct EngineConfig final
    enum class Algorithm
    {
        CH,
-        CoreCH, // Deprecated, will be removed in v6.0
        MLD
    };

@@ -85,10 +79,10 @@ struct EngineConfig final
    int max_locations_map_matching = -1;
    double max_radius_map_matching = -1.0;
    int max_results_nearest = -1;
-    boost::optional<double> default_radius = -1.0;
+    double default_radius = -1.0;
    int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
    bool use_shared_memory = true;
-    boost::filesystem::path memory_file;
+    std::filesystem::path memory_file;
    bool use_mmap = true;
    Algorithm algorithm = Algorithm::CH;
    std::vector<storage::FeatureDataset> disable_feature_dataset;
@@ -12,6 +12,8 @@

 #include "osrm/coordinate.hpp"

+#include <optional>
+
 #include <algorithm>
 #include <cmath>
 #include <iterator>
@@ -51,8 +53,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
                        const double max_distance,
-                        const boost::optional<Bearing> bearing_with_range,
-                        const boost::optional<bool> use_all_edges) const
+                        const std::optional<Bearing> bearing_with_range,
+                        const std::optional<bool> use_all_edges) const
    {
        auto results = rtree.SearchInRange(
            input_coordinate,
@@ -83,9 +85,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
                        const size_t max_results,
-                        const boost::optional<double> max_distance,
-                        const boost::optional<Bearing> bearing_with_range,
-                        const boost::optional<bool> use_all_edges) const
+                        const std::optional<double> max_distance,
+                        const std::optional<Bearing> bearing_with_range,
+                        const std::optional<bool> use_all_edges) const
    {
        auto results = rtree.Nearest(
            input_coordinate,
@@ -119,9 +121,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
        const util::Coordinate input_coordinate,
        const Approach approach,
-        const boost::optional<double> max_distance,
-        const boost::optional<Bearing> bearing_with_range,
-        const boost::optional<bool> use_all_edges) const
+        const std::optional<double> max_distance,
+        const std::optional<Bearing> bearing_with_range,
+        const std::optional<bool> use_all_edges) const
    {
        bool has_nearest = false;
        bool has_big_component = false;
@@ -37,6 +37,14 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 {
    LegGeometry geometry;

+    // each container will at most have `leg_data.size()` + 1/2 elements in it
+    // these additional 1/2 elements come from processing of very first and very last segment
+    geometry.locations.reserve(leg_data.size() + 2);
+    geometry.segment_distances.reserve(leg_data.size() + 1);
+    geometry.segment_offsets.reserve(leg_data.size() + 1);
+    geometry.annotations.reserve(leg_data.size() + 1);
+    geometry.node_ids.reserve(leg_data.size() + 2);
+
    // segment 0 first and last
    geometry.segment_offsets.push_back(0);
    geometry.locations.push_back(source_node.location);
@@ -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
@@ -1,7 +1,6 @@
 #ifndef OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP

 #include "engine/guidance/route_step.hpp"
-#include "util/attributes.hpp"

 #include <type_traits>
 #include <vector>
@@ -12,16 +11,15 @@ namespace osrm::engine::guidance
 // Multiple possible reasons can result in unnecessary/confusing instructions
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);

 // Multiple possible reasons can result in unnecessary/confusing instructions
 // A prime example would be a segregated intersection. Turning around at this
 // intersection would result in two instructions to turn left.
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep>
+collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);

 // A combined turn is a set of two instructions that actually form a single turn, as far as we
 // perceive it. A u-turn consisting of two left turns is one such example. But there are also lots
@@ -3,7 +3,6 @@

 #include "guidance/turn_instruction.hpp"
 #include "engine/guidance/route_step.hpp"
-#include "util/attributes.hpp"
 #include "util/bearing.hpp"
 #include "util/guidance/name_announcements.hpp"

@@ -166,8 +165,7 @@ inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
 }

 // do this after invalidating any steps to compress the step array again
-OSRM_ATTR_WARN_UNUSED
-inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
+[[nodiscard]] inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
 {
    // finally clean up the post-processed instructions.
    // Remove all invalid instructions from the set of instructions.
@@ -204,8 +202,8 @@ inline double totalTurnAngle(const RouteStep &entry_step, const RouteStep &exit_
    if (entry_step.geometry_begin > exit_step.geometry_begin)
        return totalTurnAngle(exit_step, entry_step);

-    const auto exit_intersection = exit_step.intersections.front();
-    const auto entry_intersection = entry_step.intersections.front();
+    const auto &exit_intersection = exit_step.intersections.front();
+    const auto &entry_intersection = entry_step.intersections.front();
    if ((exit_intersection.out >= exit_intersection.bearings.size()) ||
        (entry_intersection.in >= entry_intersection.bearings.size()))
        return entry_intersection.bearings[entry_intersection.out];
@@ -1,10 +1,9 @@
 #ifndef OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
 #define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_

-#include <vector>
-
 #include "engine/guidance/route_step.hpp"
-#include "util/attributes.hpp"
+
+#include <vector>

 namespace osrm::engine::guidance
 {
@@ -14,9 +13,9 @@ namespace osrm::engine::guidance
 // we anticipate lane changes emitting only matching lanes early on.
 // the second parameter describes the duration that we feel two segments need to be apart to count
 // as separate maneuvers.
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
-                                            const double min_distance_needed_for_lane_change = 200);
+[[nodiscard]] std::vector<RouteStep>
+anticipateLaneChange(std::vector<RouteStep> steps,
+                     const double min_distance_needed_for_lane_change = 200);

 } // namespace osrm::engine::guidance

@@ -5,7 +5,6 @@
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/phantom_node.hpp"
-#include "util/attributes.hpp"

 #include <vector>

@@ -13,8 +12,7 @@ namespace osrm::engine::guidance
 {

 // passed as none-reference to modify in-place and move out again
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);

 // trim initial/final segment of very short length.
 // This function uses in/out parameter passing to modify both steps and geometry in place.
@@ -24,23 +22,21 @@ std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
 void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry);

 // assign relative locations to depart/arrive instructions
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
-                                               const LegGeometry &geometry,
-                                               const PhantomNode &source_node,
-                                               const PhantomNode &target_node);
+[[nodiscard]] std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
+                                                             const LegGeometry &geometry,
+                                                             const PhantomNode &source_node,
+                                                             const PhantomNode &target_node);

 // collapse suppressed instructions remaining into intersections array
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);

 // postProcess will break the connection between the leg geometry
 // for which a segment is supposed to represent exactly the coordinates
 // between routing maneuvers and the route steps itself.
 // If required, we can get both in sync again using this function.
 // Move in LegGeometry for modification in place.
-OSRM_ATTR_WARN_UNUSED
-LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps);
+[[nodiscard]] LegGeometry resyncGeometry(LegGeometry leg_geometry,
+                                         const std::vector<RouteStep> &steps);

 /**
 * Apply maneuver override relations to the selected route.
@@ -3,7 +3,7 @@

 #include "engine/guidance/route_step.hpp"

-#include <boost/optional.hpp>
+#include <optional>

 #include <string>
 #include <vector>
@@ -2,7 +2,6 @@
 #define OSRM_ENGINE_GUIDANCE_VERBOSITY_REDUCTION_HPP_

 #include "engine/guidance/route_step.hpp"
-#include "util/attributes.hpp"

 #include <vector>

@@ -13,8 +12,7 @@ namespace osrm::engine::guidance
 // to announce them. All these that are not collapsed into a single turn (think segregated
 // intersection) have to be checked for the length they are active in. If they are active for a
 // short distance only, we don't announce them
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);

 } // namespace osrm::engine::guidance

@@ -15,7 +15,7 @@
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"

-#include <boost/optional.hpp>
+#include <optional>
 #include <vector>

 namespace osrm::engine
@@ -42,7 +42,7 @@ struct PathData
    // Source of the speed value on this road segment
    DatasourceID datasource_id;
    // If segment precedes a turn, ID of the turn itself
-    boost::optional<EdgeID> turn_edge;
+    std::optional<EdgeID> turn_edge;
 };

 struct InternalRouteResult
@@ -6,7 +6,7 @@
 #include <utility>
 #include <vector>

-#include <boost/math/constants/constants.hpp>
+#include <numbers>

 namespace osrm::engine::map_matching
 {
@@ -21,10 +21,8 @@ struct NormalDistribution
    // FIXME implement log-probability version since it's faster
    double Density(const double val) const
    {
-        using namespace boost::math::constants;
-
        const double x = val - mean;
-        return 1.0 / (std::sqrt(two_pi<double>()) * standard_deviation) *
+        return 1.0 / (std::sqrt(2 * std::numbers::pi) * standard_deviation) *
               std::exp(-x * x / (standard_deviation * standard_deviation));
    }

@@ -4,7 +4,7 @@
 #include "util/integer_range.hpp"

 #include <boost/assert.hpp>
-#include <boost/math/constants/constants.hpp>
+#include <numbers>

 #include <cmath>

@@ -14,7 +14,7 @@
 namespace osrm::engine::map_matching
 {

-static const double log_2_pi = std::log(2. * boost::math::constants::pi<double>());
+static const double log_2_pi = std::log(2. * std::numbers::pi);
 static const double IMPOSSIBLE_LOG_PROB = -std::numeric_limits<double>::infinity();
 static const double MINIMAL_LOG_PROB = std::numeric_limits<double>::lowest();
 static const std::size_t INVALID_STATE = std::numeric_limits<std::size_t>::max();
@@ -2,7 +2,7 @@
 #define ENGINE_MAP_MATCHING_CONFIDENCE_HPP

 #include "engine/map_matching/bayes_classifier.hpp"
-
+#include <boost/assert.hpp>
 #include <cmath>

 namespace osrm::engine::map_matching
@@ -22,7 +22,7 @@ class MatchPlugin : public BasePlugin

    MatchPlugin(const int max_locations_map_matching,
                const double max_radius_map_matching,
-                const boost::optional<double> default_radius)
+                const std::optional<double> default_radius)
        : BasePlugin(default_radius), max_locations_map_matching(max_locations_map_matching),
          max_radius_map_matching(max_radius_map_matching)
    {
@@ -13,7 +13,7 @@ namespace osrm::engine::plugins
 class NearestPlugin final : public BasePlugin
 {
  public:
-    explicit NearestPlugin(const int max_results, const boost::optional<double> default_radius);
+    explicit NearestPlugin(const int max_results, const std::optional<double> default_radius);

    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::NearestParameters &params,
@@ -29,7 +29,7 @@ class BasePlugin
  protected:
    BasePlugin() = default;

-    BasePlugin(const boost::optional<double> default_radius_) : default_radius(default_radius_) {}
+    BasePlugin(const std::optional<double> default_radius_) : default_radius(default_radius_) {}

    bool CheckAllCoordinates(const std::vector<util::Coordinate> &coordinates) const
    {
@@ -95,7 +95,7 @@ class BasePlugin
                 const std::string &message,
                 osrm::engine::api::ResultT &result) const
    {
-        mapbox::util::apply_visitor(ErrorRenderer(code, message), result);
+        std::visit(ErrorRenderer(code, message), result);
        return Status::Error;
    }

@@ -200,8 +200,8 @@ class BasePlugin
            phantom_nodes[i] = facade.NearestPhantomNodesInRange(
                parameters.coordinates[i],
                radiuses[i],
-                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_bearings ? parameters.bearings[i] : std::nullopt,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                           : engine::Approach::UNRESTRICTED,
                use_all_edges);
        }
@@ -242,8 +242,8 @@ class BasePlugin
                parameters.coordinates[i],
                number_of_results,
                use_radiuses ? parameters.radiuses[i] : default_radius,
-                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_bearings ? parameters.bearings[i] : std::nullopt,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                           : engine::Approach::UNRESTRICTED);

            // we didn't find a fitting node, return error
@@ -284,8 +284,8 @@ class BasePlugin
            alternatives[i] = facade.NearestCandidatesWithAlternativeFromBigComponent(
                parameters.coordinates[i],
                use_radiuses ? parameters.radiuses[i] : default_radius,
-                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_bearings ? parameters.bearings[i] : std::nullopt,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                           : engine::Approach::UNRESTRICTED,
                use_all_edges);

@@ -325,7 +325,7 @@ class BasePlugin
               std::to_string(missing_index);
    }

-    const boost::optional<double> default_radius;
+    const std::optional<double> default_radius;
 };
 } // namespace osrm::engine::plugins

@@ -15,7 +15,7 @@ class TablePlugin final : public BasePlugin
 {
  public:
    explicit TablePlugin(const int max_locations_distance_table,
-                         const boost::optional<double> default_radius);
+                         const std::optional<double> default_radius);

    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::TableParameters &params,
@@ -32,7 +32,7 @@ class TripPlugin final : public BasePlugin
                                     const bool roundtrip) const;

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

    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::RouteParameters &route_parameters,
@@ -12,7 +12,7 @@ namespace osrm::engine
 {
 namespace detail
 {
-std::string encode(std::vector<int> &numbers);
+void encode(int number_to_encode, std::string &output);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                     std::string::const_iterator last);
 } // namespace detail
@@ -30,27 +30,24 @@ std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter
        return {};
    }

-    std::vector<int> delta_numbers;
-    BOOST_ASSERT(size > 0);
-    delta_numbers.reserve((size - 1) * 2);
+    std::string output;
+    // just a guess that we will need ~4 bytes per coordinate to avoid reallocations
+    output.reserve(size * 4);
+
    int current_lat = 0;
    int current_lon = 0;
-    std::for_each(
-        begin,
-        end,
-        [&delta_numbers, &current_lat, &current_lon, coordinate_to_polyline](
-            const util::Coordinate loc)
-        {
-            const int lat_diff =
-                std::round(static_cast<int>(loc.lat) * coordinate_to_polyline) - current_lat;
-            const int lon_diff =
-                std::round(static_cast<int>(loc.lon) * coordinate_to_polyline) - current_lon;
-            delta_numbers.emplace_back(lat_diff);
-            delta_numbers.emplace_back(lon_diff);
-            current_lat += lat_diff;
-            current_lon += lon_diff;
-        });
-    return detail::encode(delta_numbers);
+    for (auto it = begin; it != end; ++it)
+    {
+        const int lat_diff =
+            std::round(static_cast<int>(it->lat) * coordinate_to_polyline) - current_lat;
+        const int lon_diff =
+            std::round(static_cast<int>(it->lon) * coordinate_to_polyline) - current_lon;
+        detail::encode(lat_diff, output);
+        detail::encode(lon_diff, output);
+        current_lat += lat_diff;
+        current_lon += lon_diff;
+    }
+    return output;
 }

 // Decodes geometry from polyline format
@@ -25,7 +25,7 @@ class RoutingAlgorithmsInterface

    virtual InternalRouteResult
    ShortestPathSearch(const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                       const boost::optional<bool> continue_straight_at_waypoint) const = 0;
+                       const std::optional<bool> continue_straight_at_waypoint) const = 0;

    virtual InternalRouteResult
    DirectShortestPathSearch(const PhantomEndpointCandidates &endpoint_candidates) const = 0;
@@ -40,7 +40,7 @@ class RoutingAlgorithmsInterface
    MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                const std::vector<util::Coordinate> &trace_coordinates,
                const std::vector<unsigned> &trace_timestamps,
-                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const std::vector<std::optional<double>> &trace_gps_precision,
                const bool allow_splitting) const = 0;

    virtual std::vector<routing_algorithms::TurnData>
@@ -78,7 +78,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo

    InternalRouteResult ShortestPathSearch(
        const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-        const boost::optional<bool> continue_straight_at_waypoint) const final override;
+        const std::optional<bool> continue_straight_at_waypoint) const final override;

    InternalRouteResult DirectShortestPathSearch(
        const PhantomEndpointCandidates &endpoint_candidates) const final override;
@@ -93,7 +93,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
    MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                const std::vector<util::Coordinate> &trace_coordinates,
                const std::vector<unsigned> &trace_timestamps,
-                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const std::vector<std::optional<double>> &trace_gps_precision,
                const bool allow_splitting) const final override;

    std::vector<routing_algorithms::TurnData>
@@ -160,7 +160,7 @@ InternalManyRoutesResult RoutingAlgorithms<Algorithm>::AlternativePathSearch(
 template <typename Algorithm>
 InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
    const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-    const boost::optional<bool> continue_straight_at_waypoint) const
+    const std::optional<bool> continue_straight_at_waypoint) const
 {
    return routing_algorithms::shortestPathSearch(
        heaps, *facade, waypoint_candidates, continue_straight_at_waypoint);
@@ -178,7 +178,7 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatc
    const routing_algorithms::CandidateLists &candidates_list,
    const std::vector<util::Coordinate> &trace_coordinates,
    const std::vector<unsigned> &trace_timestamps,
-    const std::vector<boost::optional<double>> &trace_gps_precision,
+    const std::vector<std::optional<double>> &trace_gps_precision,
    const bool allow_splitting) const
 {
    return routing_algorithms::mapMatching(heaps,
@@ -24,7 +24,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                            const CandidateLists &candidates_list,
                            const std::vector<util::Coordinate> &trace_coordinates,
                            const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<boost::optional<double>> &trace_gps_precision,
+                            const std::vector<std::optional<double>> &trace_gps_precision,
                            const bool allow_splitting);

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

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

    if (!unpacked_path.empty())
@@ -11,6 +11,7 @@
 #include <boost/assert.hpp>

 #include <algorithm>
+#include <boost/core/ignore_unused.hpp>
 #include <iterator>
 #include <limits>
 #include <tuple>
@@ -269,10 +270,29 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
    return packed_path;
 }

-template <bool DIRECTION, typename Algorithm, typename... Args>
+template <typename Heap>
+void insertOrUpdate(Heap &heap,
+                    const NodeID node,
+                    const EdgeWeight weight,
+                    const typename Heap::DataType &data)
+{
+    const auto heapNode = heap.GetHeapNodeIfWasInserted(node);
+    if (!heapNode)
+    {
+        heap.Insert(node, weight, data);
+    }
+    else if (weight < heapNode->weight)
+    {
+        heapNode->data = data;
+        heapNode->weight = weight;
+        heap.DecreaseKey(*heapNode);
+    }
+}
+
+template <bool DIRECTION, typename Algorithm, typename Heap, typename... Args>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
-                        typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                        const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
+                        Heap &forward_heap,
+                        const typename Heap::HeapNode &heapNode,
                        const Args &...args)
 {
    const auto &partition = facade.GetMultiLevelPartition();
@@ -281,14 +301,31 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,

    const auto level = getNodeQueryLevel(partition, heapNode.node, args...);

+    static constexpr auto IS_MAP_MATCHING =
+        std::is_same_v<typename SearchEngineData<mld::Algorithm>::MapMatchingQueryHeap, Heap>;
+
    if (level >= 1 && !heapNode.data.from_clique_arc)
    {
-        if (DIRECTION == FORWARD_DIRECTION)
+        if constexpr (DIRECTION == FORWARD_DIRECTION)
        {
            // Shortcuts in forward direction
            const auto &cell =
                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
            auto destination = cell.GetDestinationNodes().begin();
+            auto distance = [&cell, node = heapNode.node ]() -> auto
+            {
+                if constexpr (IS_MAP_MATCHING)
+                {
+
+                    return cell.GetOutDistance(node).begin();
+                }
+                else
+                {
+                    boost::ignore_unused(cell, node);
+                    return 0;
+                }
+            }
+            ();
            for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))
            {
                BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
@@ -298,19 +335,23 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                {
                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
                    BOOST_ASSERT(to_weight >= heapNode.weight);
-                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
-                    if (!toHeapNode)
+
+                    if constexpr (IS_MAP_MATCHING)
                    {
-                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
+                        const EdgeDistance to_distance = heapNode.data.distance + *distance;
+                        insertOrUpdate(
+                            forward_heap, to, to_weight, {heapNode.node, true, to_distance});
                    }
-                    else if (to_weight < toHeapNode->weight)
+                    else
                    {
-                        toHeapNode->data = {heapNode.node, true};
-                        toHeapNode->weight = to_weight;
-                        forward_heap.DecreaseKey(*toHeapNode);
+                        insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, true});
                    }
                }
                ++destination;
+                if constexpr (IS_MAP_MATCHING)
+                {
+                    ++distance;
+                }
            }
        }
        else
@@ -319,6 +360,20 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
            const auto &cell =
                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
            auto source = cell.GetSourceNodes().begin();
+            auto distance = [&cell, node = heapNode.node ]() -> auto
+            {
+                if constexpr (IS_MAP_MATCHING)
+                {
+
+                    return cell.GetInDistance(node).begin();
+                }
+                else
+                {
+                    boost::ignore_unused(cell, node);
+                    return 0;
+                }
+            }
+            ();
            for (auto shortcut_weight : cell.GetInWeight(heapNode.node))
            {
                BOOST_ASSERT(source != cell.GetSourceNodes().end());
@@ -328,19 +383,22 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                {
                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
                    BOOST_ASSERT(to_weight >= heapNode.weight);
-                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
-                    if (!toHeapNode)
+                    if constexpr (IS_MAP_MATCHING)
                    {
-                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
+                        const EdgeDistance to_distance = heapNode.data.distance + *distance;
+                        insertOrUpdate(
+                            forward_heap, to, to_weight, {heapNode.node, true, to_distance});
                    }
-                    else if (to_weight < toHeapNode->weight)
+                    else
                    {
-                        toHeapNode->data = {heapNode.node, true};
-                        toHeapNode->weight = to_weight;
-                        forward_heap.DecreaseKey(*toHeapNode);
+                        insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, true});
                    }
                }
                ++source;
+                if constexpr (IS_MAP_MATCHING)
+                {
+                    ++distance;
+                }
            }
        }
    }
@@ -367,26 +425,28 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                const EdgeWeight to_weight =
                    heapNode.weight + node_weight + alias_cast<EdgeWeight>(turn_penalty);

-                const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
-                if (!toHeapNode)
+                if constexpr (IS_MAP_MATCHING)
                {
-                    forward_heap.Insert(to, to_weight, {heapNode.node, false});
+                    const auto node_distance =
+                        facade.GetNodeDistance(DIRECTION == FORWARD_DIRECTION ? heapNode.node : to);
+
+                    const EdgeDistance to_distance = heapNode.data.distance + node_distance;
+                    insertOrUpdate(
+                        forward_heap, to, to_weight, {heapNode.node, false, to_distance});
                }
-                else if (to_weight < toHeapNode->weight)
+                else
                {
-                    toHeapNode->data = {heapNode.node, false};
-                    toHeapNode->weight = to_weight;
-                    forward_heap.DecreaseKey(*toHeapNode);
+                    insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, false});
                }
            }
        }
    }
 }

-template <bool DIRECTION, typename Algorithm, typename... Args>
+template <bool DIRECTION, typename Algorithm, typename Heap, typename... Args>
 void routingStep(const DataFacade<Algorithm> &facade,
-                 typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                 typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                 Heap &forward_heap,
+                 Heap &reverse_heap,
                 NodeID &middle_node,
                 EdgeWeight &path_upper_bound,
                 const std::vector<NodeID> &force_step_nodes,
@@ -427,24 +487,27 @@ void routingStep(const DataFacade<Algorithm> &facade,

 using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
-using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;

-template <typename Algorithm, typename... Args>
-UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
-                    const DataFacade<Algorithm> &facade,
-                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                    const std::vector<NodeID> &force_step_nodes,
-                    EdgeWeight weight_upper_bound,
-                    const Args &...args)
+struct UnpackedPath
+{
+    EdgeWeight weight;
+    UnpackedNodes nodes;
+    UnpackedEdges edges;
+};
+
+template <typename Algorithm, typename Heap, typename... Args>
+std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
+                                                       Heap &forward_heap,
+                                                       Heap &reverse_heap,
+                                                       const std::vector<NodeID> &force_step_nodes,
+                                                       EdgeWeight weight_upper_bound,
+                                                       const Args &...args)
 {
    if (forward_heap.Empty() || reverse_heap.Empty())
    {
-        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
+        return {};
    }

-    const auto &partition = facade.GetMultiLevelPartition();
-
    BOOST_ASSERT(!forward_heap.Empty() && forward_heap.MinKey() < INVALID_EDGE_WEIGHT);
    BOOST_ASSERT(!reverse_heap.Empty() && reverse_heap.MinKey() < INVALID_EDGE_WEIGHT);

@@ -475,9 +538,32 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
    // No path found for both target nodes?
    if (weight >= weight_upper_bound || SPECIAL_NODEID == middle)
    {
-        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
+        return {};
    }

+    return {{middle, weight}};
+}
+
+template <typename Algorithm, typename... Args>
+UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
+                    const DataFacade<Algorithm> &facade,
+                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                    const std::vector<NodeID> &force_step_nodes,
+                    EdgeWeight weight_upper_bound,
+                    const Args &...args)
+{
+    auto searchResult = runSearch(
+        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
+    if (!searchResult)
+    {
+        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
+    }
+
+    auto [middle, weight] = *searchResult;
+
+    const auto &partition = facade.GetMultiLevelPartition();
+
    // Get packed path as edges {from node ID, to node ID, from_clique_arc}
    auto packed_path = retrievePackedPathFromHeap(forward_heap, reverse_heap, middle);

@@ -515,25 +601,52 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
            forward_heap.Insert(source, {0}, {source});
            reverse_heap.Insert(target, {0}, {target});

-            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
-                                                                         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());
+            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());
        }
    }

-    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
+    return {weight, std::move(unpacked_nodes), std::move(unpacked_edges)};
+}
+
+template <typename Algorithm, typename... Args>
+EdgeDistance
+searchDistance(SearchEngineData<Algorithm> &,
+               const DataFacade<Algorithm> &facade,
+               typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+               typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
+               const std::vector<NodeID> &force_step_nodes,
+               EdgeWeight weight_upper_bound,
+               const Args &...args)
+{
+
+    auto searchResult = runSearch(
+        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
+    if (!searchResult)
+    {
+        return INVALID_EDGE_DISTANCE;
+    }
+
+    auto [middle, _] = *searchResult;
+
+    auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance;
+
+    return distance;
 }

 // Alias to be compatible with the CH-based search
@@ -549,13 +662,15 @@ inline void search(SearchEngineData<Algorithm> &engine_working_data,
                   const EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
    // TODO: change search calling interface to use unpacked_edges result
-    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
-                                                           facade,
-                                                           forward_heap,
-                                                           reverse_heap,
-                                                           force_step_nodes,
-                                                           weight_upper_bound,
-                                                           endpoints);
+    auto unpacked_path = search(engine_working_data,
+                                facade,
+                                forward_heap,
+                                reverse_heap,
+                                force_step_nodes,
+                                weight_upper_bound,
+                                endpoints);
+    weight = unpacked_path.weight;
+    unpacked_nodes = std::move(unpacked_path.nodes);
 }

 // TODO: refactor CH-related stub to use unpacked_edges
@@ -593,8 +708,8 @@ void unpackPath(const FacadeT &facade,
 template <typename Algorithm>
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                          const DataFacade<Algorithm> &facade,
-                          typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                          typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                          typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+                          typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
                          const PhantomNode &source_phantom,
                          const PhantomNode &target_phantom,
                          EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
@@ -602,48 +717,49 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
    forward_heap.Clear();
    reverse_heap.Clear();

-    const PhantomEndpoints endpoints{source_phantom, target_phantom};
-    insertNodesInHeaps(forward_heap, reverse_heap, endpoints);
+    if (source_phantom.IsValidForwardSource())
+    {
+        forward_heap.Insert(source_phantom.forward_segment_id.id,
+                            EdgeWeight{0} - source_phantom.GetForwardWeightPlusOffset(),
+                            {source_phantom.forward_segment_id.id,
+                             false,
+                             EdgeDistance{0} - source_phantom.GetForwardDistance()});
+    }

-    auto [weight, unpacked_nodes, unpacked_edges] = search(
+    if (source_phantom.IsValidReverseSource())
+    {
+        forward_heap.Insert(source_phantom.reverse_segment_id.id,
+                            EdgeWeight{0} - source_phantom.GetReverseWeightPlusOffset(),
+                            {source_phantom.reverse_segment_id.id,
+                             false,
+                             EdgeDistance{0} - source_phantom.GetReverseDistance()});
+    }
+
+    if (target_phantom.IsValidForwardTarget())
+    {
+        reverse_heap.Insert(
+            target_phantom.forward_segment_id.id,
+            target_phantom.GetForwardWeightPlusOffset(),
+            {target_phantom.forward_segment_id.id, false, target_phantom.GetForwardDistance()});
+    }
+
+    if (target_phantom.IsValidReverseTarget())
+    {
+        reverse_heap.Insert(
+            target_phantom.reverse_segment_id.id,
+            target_phantom.GetReverseWeightPlusOffset(),
+            {target_phantom.reverse_segment_id.id, false, target_phantom.GetReverseDistance()});
+    }
+
+    const PhantomEndpoints endpoints{source_phantom, target_phantom};
+
+    auto distance = searchDistance(
        engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);

-    if (weight == INVALID_EDGE_WEIGHT)
+    if (distance == INVALID_EDGE_DISTANCE)
    {
        return std::numeric_limits<double>::max();
    }
-
-    BOOST_ASSERT(unpacked_nodes.size() >= 1);
-
-    EdgeDistance distance = {0.0};
-
-    if (source_phantom.forward_segment_id.id == unpacked_nodes.front())
-    {
-        BOOST_ASSERT(source_phantom.forward_segment_id.enabled);
-        distance = EdgeDistance{0} - source_phantom.GetForwardDistance();
-    }
-    else if (source_phantom.reverse_segment_id.id == unpacked_nodes.front())
-    {
-        BOOST_ASSERT(source_phantom.reverse_segment_id.enabled);
-        distance = EdgeDistance{0} - source_phantom.GetReverseDistance();
-    }
-
-    for (size_t index = 0; index < unpacked_nodes.size() - 1; ++index)
-    {
-        distance += facade.GetNodeDistance(unpacked_nodes[index]);
-    }
-
-    if (target_phantom.forward_segment_id.id == unpacked_nodes.back())
-    {
-        BOOST_ASSERT(target_phantom.forward_segment_id.enabled);
-        distance += target_phantom.GetForwardDistance();
-    }
-    else if (target_phantom.reverse_segment_id.id == unpacked_nodes.back())
-    {
-        BOOST_ASSERT(target_phantom.reverse_segment_id.enabled);
-        distance += target_phantom.GetReverseDistance();
-    }
-
    return from_alias<double>(distance);
 }

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

 } // namespace osrm::engine::routing_algorithms

@@ -4,7 +4,7 @@
 #include "engine/routing_algorithms/shortest_path.hpp"

 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
+#include <optional>

 namespace osrm::engine::routing_algorithms
 {
@@ -339,10 +339,10 @@ struct leg_connections
 {
    // X_to_Y = i can be read as
    // sources[i].X is the source of the shortest leg path to target.Y
-    boost::optional<size_t> forward_to_forward;
-    boost::optional<size_t> reverse_to_forward;
-    boost::optional<size_t> forward_to_reverse;
-    boost::optional<size_t> reverse_to_reverse;
+    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;
 };

 // Identify which of the source candidates segments is being used for paths to the
@@ -771,7 +771,7 @@ InternalRouteResult
 shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                   const DataFacade<Algorithm> &facade,
                   const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint)
+                   const std::optional<bool> continue_straight_at_waypoint)
 {
    const bool allow_uturn_at_waypoint =
        !(continue_straight_at_waypoint ? *continue_straight_at_waypoint
@@ -12,7 +12,6 @@ namespace osrm::engine

 // Algorithm-dependent heaps
 // - CH algorithms use CH heaps
-// - CoreCH algorithms use CH
 // - MLD algorithms use MLD heaps

 template <typename Algorithm> struct SearchEngineData
@@ -47,6 +46,7 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
                                                util::UnorderedMapStorage<NodeID, int>>;

    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
+
    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;

    static SearchEngineHeapPtr forward_heap_1;
@@ -56,6 +56,10 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
    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);

    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes);

@@ -74,6 +78,19 @@ struct MultiLayerDijkstraHeapData
    MultiLayerDijkstraHeapData(NodeID p, bool from) : parent(p), from_clique_arc(from) {}
 };

+struct MapMatchingMultiLayerDijkstraHeapData
+{
+    NodeID parent;
+    bool from_clique_arc;
+    EdgeDistance distance = {0};
+    MapMatchingMultiLayerDijkstraHeapData(NodeID p) : parent(p), from_clique_arc(false) {}
+    MapMatchingMultiLayerDijkstraHeapData(NodeID p, bool from) : parent(p), from_clique_arc(from) {}
+    MapMatchingMultiLayerDijkstraHeapData(NodeID p, bool from, EdgeDistance d)
+        : parent(p), from_clique_arc(from), distance(d)
+    {
+    }
+};
+
 struct ManyToManyMultiLayerDijkstraHeapData : MultiLayerDijkstraHeapData
 {
    EdgeDuration duration;
@@ -104,16 +121,27 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
                                                EdgeWeight,
                                                ManyToManyMultiLayerDijkstraHeapData,
                                                util::TwoLevelStorage<NodeID, int>>;
+    using MapMatchingQueryHeap = util::QueryHeap<NodeID,
+                                                 NodeID,
+                                                 EdgeWeight,
+                                                 MapMatchingMultiLayerDijkstraHeapData,
+                                                 util::TwoLevelStorage<NodeID, int>>;

    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
+    using MapMatchingHeapPtr = boost::thread_specific_ptr<MapMatchingQueryHeap>;

    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 ManyToManyHeapPtr many_to_many_heap;

    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes,
                                                  unsigned number_of_boundary_nodes);
+    void InitializeOrClearMapMatchingThreadLocalStorage(unsigned number_of_nodes,
+                                                        unsigned number_of_boundary_nodes);

    void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                       unsigned number_of_boundary_nodes);
@@ -3,11 +3,9 @@

 #include "extractor/class_data.hpp"
 #include "extractor/turn_lane_types.hpp"
+#include "util/std_hash.hpp"
 #include "util/typedefs.hpp"

-#include <boost/functional/hash.hpp>
-#include <boost/optional/optional_fwd.hpp>
-
 #include <string>
 #include <unordered_map>

@@ -18,25 +16,6 @@ class Way;
 class Relation;
 } // namespace osmium

-namespace std
-{
-template <> struct hash<std::tuple<std::string, std::string, std::string, std::string, std::string>>
-{
-    std::size_t operator()(
-        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk)
-        const noexcept
-    {
-        std::size_t seed = 0;
-        boost::hash_combine(seed, std::get<0>(mk));
-        boost::hash_combine(seed, std::get<1>(mk));
-        boost::hash_combine(seed, std::get<2>(mk));
-        boost::hash_combine(seed, std::get<3>(mk));
-        boost::hash_combine(seed, std::get<4>(mk));
-        return seed;
-    }
-};
-} // namespace std
-
 namespace osrm::extractor
 {

@@ -28,13 +28,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTOR_CONFIG_HPP
 #define EXTRACTOR_CONFIG_HPP

-#include <boost/filesystem/path.hpp>
+#include "storage/io_config.hpp"

 #include <array>
+#include <filesystem>
 #include <string>

-#include "storage/io_config.hpp"
-
 namespace osrm::extractor
 {

@@ -71,14 +70,14 @@ struct ExtractorConfig final : storage::IOConfig
    {
    }

-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
    }

-    boost::filesystem::path input_path;
-    boost::filesystem::path profile_path;
-    std::vector<boost::filesystem::path> location_dependent_data_paths;
+    std::filesystem::path input_path;
+    std::filesystem::path profile_path;
+    std::vector<std::filesystem::path> location_dependent_data_paths;
    std::string data_version;

    unsigned requested_num_threads = 0;
@@ -23,9 +23,9 @@ namespace osrm::extractor::files

 // writes the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-inline void writeIntersections(const boost::filesystem::path &path,
-                               const IntersectionBearingsT &intersection_bearings,
-                               const EntryClassVectorT &entry_classes)
+void writeIntersections(const std::filesystem::path &path,
+                        const IntersectionBearingsT &intersection_bearings,
+                        const EntryClassVectorT &entry_classes)
 {
    static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                      std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@@ -39,9 +39,9 @@ inline void writeIntersections(const boost::filesystem::path &path,

 // read the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-inline void readIntersections(const boost::filesystem::path &path,
-                              IntersectionBearingsT &intersection_bearings,
-                              EntryClassVectorT &entry_classes)
+void readIntersections(const std::filesystem::path &path,
+                       IntersectionBearingsT &intersection_bearings,
+                       EntryClassVectorT &entry_classes)
 {
    static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                      std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@@ -54,8 +54,7 @@ inline void readIntersections(const boost::filesystem::path &path,
 }

 // reads .osrm.properties
-inline void readProfileProperties(const boost::filesystem::path &path,
-                                  ProfileProperties &properties)
+inline void readProfileProperties(const std::filesystem::path &path, ProfileProperties &properties)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -64,7 +63,7 @@ inline void readProfileProperties(const boost::filesystem::path &path,
 }

 // writes .osrm.properties
-inline void writeProfileProperties(const boost::filesystem::path &path,
+inline void writeProfileProperties(const std::filesystem::path &path,
                                   const ProfileProperties &properties)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -74,7 +73,7 @@ inline void writeProfileProperties(const boost::filesystem::path &path,
 }

 template <typename EdgeBasedEdgeVector>
-void writeEdgeBasedGraph(const boost::filesystem::path &path,
+void writeEdgeBasedGraph(const std::filesystem::path &path,
                         EdgeID const number_of_edge_based_nodes,
                         const EdgeBasedEdgeVector &edge_based_edge_list,
                         const std::uint32_t connectivity_checksum)
@@ -92,7 +91,7 @@ void writeEdgeBasedGraph(const boost::filesystem::path &path,

 // reads .osrm.ebg file
 template <typename EdgeBasedEdgeVector>
-void readEdgeBasedGraph(const boost::filesystem::path &path,
+void readEdgeBasedGraph(const std::filesystem::path &path,
                        EdgeID &number_of_edge_based_nodes,
                        EdgeBasedEdgeVector &edge_based_edge_list,
                        std::uint32_t &connectivity_checksum)
@@ -108,9 +107,9 @@ void readEdgeBasedGraph(const boost::filesystem::path &path,

 // reads .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-inline void readNodes(const boost::filesystem::path &path,
-                      CoordinatesT &coordinates,
-                      PackedOSMIDsT &osm_node_ids)
+void readNodes(const std::filesystem::path &path,
+               CoordinatesT &coordinates,
+               PackedOSMIDsT &osm_node_ids)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
    static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
@@ -124,7 +123,7 @@ inline void readNodes(const boost::filesystem::path &path,

 // reads only coordinates from .osrm.nbg_nodes
 template <typename CoordinatesT>
-inline void readNodeCoordinates(const boost::filesystem::path &path, CoordinatesT &coordinates)
+void readNodeCoordinates(const std::filesystem::path &path, CoordinatesT &coordinates)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");

@@ -136,9 +135,9 @@ inline void readNodeCoordinates(const boost::filesystem::path &path, Coordinates

 // writes .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-inline void writeNodes(const boost::filesystem::path &path,
-                       const CoordinatesT &coordinates,
-                       const PackedOSMIDsT &osm_node_ids)
+void writeNodes(const std::filesystem::path &path,
+                const CoordinatesT &coordinates,
+                const PackedOSMIDsT &osm_node_ids)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
    static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
@@ -151,7 +150,7 @@ inline void writeNodes(const boost::filesystem::path &path,
 }

 // reads .osrm.cnbg_to_ebg
-inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
+inline void readNBGMapping(const std::filesystem::path &path, std::vector<NBGToEBG> &mapping)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -160,8 +159,7 @@ inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGT
 }

 // writes .osrm.cnbg_to_ebg
-inline void writeNBGMapping(const boost::filesystem::path &path,
-                            const std::vector<NBGToEBG> &mapping)
+inline void writeNBGMapping(const std::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -170,7 +168,7 @@ inline void writeNBGMapping(const boost::filesystem::path &path,
 }

 // reads .osrm.datasource_names
-inline void readDatasources(const boost::filesystem::path &path, Datasources &sources)
+inline void readDatasources(const std::filesystem::path &path, Datasources &sources)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -179,7 +177,7 @@ inline void readDatasources(const boost::filesystem::path &path, Datasources &so
 }

 // writes .osrm.datasource_names
-inline void writeDatasources(const boost::filesystem::path &path, Datasources &sources)
+inline void writeDatasources(const std::filesystem::path &path, Datasources &sources)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -189,7 +187,7 @@ inline void writeDatasources(const boost::filesystem::path &path, Datasources &s

 // reads .osrm.geometry
 template <typename SegmentDataT>
-inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &segment_data)
+void readSegmentData(const std::filesystem::path &path, SegmentDataT &segment_data)
 {
    static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                      std::is_same<SegmentDataView, SegmentDataT>::value,
@@ -202,7 +200,7 @@ inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &s

 // writes .osrm.geometry
 template <typename SegmentDataT>
-inline void writeSegmentData(const boost::filesystem::path &path, const SegmentDataT &segment_data)
+void writeSegmentData(const std::filesystem::path &path, const SegmentDataT &segment_data)
 {
    static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                      std::is_same<SegmentDataView, SegmentDataT>::value,
@@ -215,7 +213,7 @@ inline void writeSegmentData(const boost::filesystem::path &path, const SegmentD

 // reads .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_data)
+inline void readNodeData(const std::filesystem::path &path, NodeDataT &node_data)
 {
    static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                      std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@@ -229,7 +227,7 @@ inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_da

 // writes .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &node_data)
+inline void writeNodeData(const std::filesystem::path &path, const NodeDataT &node_data)
 {
    static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                      std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@@ -243,7 +241,7 @@ inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &

 // reads .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
+inline void readTurnLaneDescriptions(const std::filesystem::path &path,
                                     OffsetsT &turn_offsets,
                                     MaskT &turn_masks)
 {
@@ -260,7 +258,7 @@ inline void readTurnLaneDescriptions(const boost::filesystem::path &path,

 // writes .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
+inline void writeTurnLaneDescriptions(const std::filesystem::path &path,
                                      const OffsetsT &turn_offsets,
                                      const MaskT &turn_masks)
 {
@@ -277,7 +275,7 @@ inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,

 // reads .osrm.tld
 template <typename TurnLaneDataT>
-inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT &turn_lane_data)
+inline void readTurnLaneData(const std::filesystem::path &path, TurnLaneDataT &turn_lane_data)
 {
    static_assert(
        std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value,
@@ -291,7 +289,7 @@ inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT

 // writes .osrm.tld
 template <typename TurnLaneDataT>
-inline void writeTurnLaneData(const boost::filesystem::path &path,
+inline void writeTurnLaneData(const std::filesystem::path &path,
                              const TurnLaneDataT &turn_lane_data)
 {
    static_assert(
@@ -306,7 +304,7 @@ inline void writeTurnLaneData(const boost::filesystem::path &path,

 // reads .osrm.timestamp
 template <typename TimestampDataT>
-inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &timestamp)
+inline void readTimestamp(const std::filesystem::path &path, TimestampDataT &timestamp)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -316,7 +314,7 @@ inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &t

 // writes .osrm.timestamp
 template <typename TimestampDataT>
-inline void writeTimestamp(const boost::filesystem::path &path, const TimestampDataT &timestamp)
+inline void writeTimestamp(const std::filesystem::path &path, const TimestampDataT &timestamp)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -326,7 +324,7 @@ inline void writeTimestamp(const boost::filesystem::path &path, const TimestampD

 // reads .osrm.maneuver_overrides
 template <typename StorageManeuverOverrideT, typename NodeSequencesT>
-inline void readManeuverOverrides(const boost::filesystem::path &path,
+inline void readManeuverOverrides(const std::filesystem::path &path,
                                  StorageManeuverOverrideT &maneuver_overrides,
                                  NodeSequencesT &node_sequences)
 {
@@ -340,7 +338,7 @@ inline void readManeuverOverrides(const boost::filesystem::path &path,
 }

 // writes .osrm.maneuver_overrides
-inline void writeManeuverOverrides(const boost::filesystem::path &path,
+inline void writeManeuverOverrides(const std::filesystem::path &path,
                                   const std::vector<StorageManeuverOverride> &maneuver_overrides,
                                   const std::vector<NodeID> &node_sequences)
 {
@@ -355,7 +353,7 @@ inline void writeManeuverOverrides(const boost::filesystem::path &path,

 // writes .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnWeightPenalty(const boost::filesystem::path &path,
+inline void writeTurnWeightPenalty(const std::filesystem::path &path,
                                   const TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -366,7 +364,7 @@ inline void writeTurnWeightPenalty(const boost::filesystem::path &path,

 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnWeightPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -376,7 +374,7 @@ inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenal

 // writes .osrm.turn_duration_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnDurationPenalty(const boost::filesystem::path &path,
+inline void writeTurnDurationPenalty(const std::filesystem::path &path,
                                     const TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -387,7 +385,7 @@ inline void writeTurnDurationPenalty(const boost::filesystem::path &path,

 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnDurationPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -397,7 +395,7 @@ inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPen

 // writes .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,
+inline void writeTurnPenaltiesIndex(const std::filesystem::path &path,
                                    const TurnIndexT &turn_penalties_index)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -408,7 +406,7 @@ inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,

 // read .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,
+inline void readTurnPenaltiesIndex(const std::filesystem::path &path,
                                   TurnIndexT &turn_penalties_index)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -419,7 +417,7 @@ inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,

 // writes .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void writeConditionalRestrictions(const boost::filesystem::path &path,
+inline void writeConditionalRestrictions(const std::filesystem::path &path,
                                         const ConditionalRestrictionsT &conditional_restrictions)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -430,7 +428,7 @@ inline void writeConditionalRestrictions(const boost::filesystem::path &path,

 // read .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void readConditionalRestrictions(const boost::filesystem::path &path,
+inline void readConditionalRestrictions(const std::filesystem::path &path,
                                        ConditionalRestrictionsT &conditional_restrictions)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -441,7 +439,7 @@ inline void readConditionalRestrictions(const boost::filesystem::path &path,

 // reads .osrm file which is a temporary file of osrm-extract
 template <typename PackedOSMIDsT>
-void readRawNBGraph(const boost::filesystem::path &path,
+void readRawNBGraph(const std::filesystem::path &path,
                    std::vector<util::Coordinate> &coordinates,
                    PackedOSMIDsT &osm_node_ids,
                    std::vector<extractor::NodeBasedEdge> &edge_list)
@@ -466,8 +464,7 @@ void readRawNBGraph(const boost::filesystem::path &path,
    storage::serialization::read(reader, "/extractor/edges", edge_list);
 }

-template <typename NameTableT>
-void readNames(const boost::filesystem::path &path, NameTableT &table)
+template <typename NameTableT> void readNames(const std::filesystem::path &path, NameTableT &table)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -476,7 +473,7 @@ void readNames(const boost::filesystem::path &path, NameTableT &table)
 }

 template <typename NameTableT>
-void writeNames(const boost::filesystem::path &path, const NameTableT &table)
+void writeNames(const std::filesystem::path &path, const NameTableT &table)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -485,7 +482,7 @@ void writeNames(const boost::filesystem::path &path, const NameTableT &table)
 }

 template <typename NodeWeightsVectorT>
-void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVectorT &weights)
+void readEdgeBasedNodeWeights(const std::filesystem::path &path, NodeWeightsVectorT &weights)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -494,8 +491,7 @@ void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVe
 }

 template <typename NodeDistancesVectorT>
-void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
-                                NodeDistancesVectorT &distances)
+void readEdgeBasedNodeDistances(const std::filesystem::path &path, NodeDistancesVectorT &distances)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -504,7 +500,7 @@ void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
 }

 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT, typename NodeDistancesVectorT>
-void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurationsDistances(const std::filesystem::path &path,
                                                 const NodeWeightsVectorT &weights,
                                                 const NodeDurationsVectorT &durations,
                                                 const NodeDistancesVectorT &distances)
@@ -518,7 +514,7 @@ void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &
 }

 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
+void readEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
                                       NodeWeightsVectorT &weights,
                                       NodeDurationsVectorT &durations)
 {
@@ -530,7 +526,7 @@ void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
 }

 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
                                        const NodeWeightsVectorT &weights,
                                        const NodeDurationsVectorT &durations)
 {
@@ -542,7 +538,7 @@ void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
 }

 template <typename RTreeT>
-void writeRamIndex(const boost::filesystem::path &path, const RTreeT &rtree)
+void writeRamIndex(const std::filesystem::path &path, const RTreeT &rtree)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -550,7 +546,7 @@ void writeRamIndex(const boost::filesystem::path &path, const RTreeT &rtree)
    util::serialization::write(writer, "/common/rtree", rtree);
 }

-template <typename RTreeT> void readRamIndex(const boost::filesystem::path &path, RTreeT &rtree)
+template <typename RTreeT> void readRamIndex(const std::filesystem::path &path, RTreeT &rtree)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -559,7 +555,7 @@ template <typename RTreeT> void readRamIndex(const boost::filesystem::path &path
 }

 template <typename EdgeListT>
-void writeCompressedNodeBasedGraph(const boost::filesystem::path &path, const EdgeListT &edge_list)
+void writeCompressedNodeBasedGraph(const std::filesystem::path &path, const EdgeListT &edge_list)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -568,7 +564,7 @@ void writeCompressedNodeBasedGraph(const boost::filesystem::path &path, const Ed
 }

 template <typename EdgeListT>
-void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT &edge_list)
+void readCompressedNodeBasedGraph(const std::filesystem::path &path, EdgeListT &edge_list)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -7,8 +7,8 @@
 #include "util/typedefs.hpp"

 #include <boost/assert.hpp>
-#include <mapbox/variant.hpp>
 #include <utility>
+#include <variant>

 namespace osrm::extractor
 {
@@ -1,16 +1,15 @@
 #ifndef OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
 #define OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_

-#include <utility>
-#include <vector>
-
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/query_node.hpp"

-#include "util/attributes.hpp"
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"

+#include <utility>
+#include <vector>
+
 namespace osrm::extractor::intersection
 {

@@ -27,17 +26,16 @@ class CoordinateExtractor
     * Note: The segment between intersection and turn coordinate can be zero, if the OSM modelling
     * is unfortunate. See https://github.com/Project-OSRM/osrm-backend/issues/3470
     */
-    OSRM_ATTR_WARN_UNUSED
-    util::Coordinate GetCoordinateAlongRoad(const NodeID intersection_node,
-                                            const EdgeID turn_edge,
-                                            const bool traversed_in_reverse,
-                                            const NodeID to_node,
-                                            const std::uint8_t number_of_in_lanes) const;
+    [[nodiscard]] util::Coordinate
+    GetCoordinateAlongRoad(const NodeID intersection_node,
+                           const EdgeID turn_edge,
+                           const bool traversed_in_reverse,
+                           const NodeID to_node,
+                           const std::uint8_t number_of_in_lanes) const;

    // Given a set of precomputed coordinates, select the representative coordinate along the road
    // that best describes the turn
-    OSRM_ATTR_WARN_UNUSED
-    util::Coordinate
+    [[nodiscard]] util::Coordinate
    ExtractRepresentativeCoordinate(const NodeID intersection_node,
                                    const EdgeID turn_edge,
                                    const bool traversed_in_reverse,
@@ -47,7 +45,7 @@ class CoordinateExtractor

    // instead of finding only a single coordinate, we can also list all coordinates along a
    // road.
-    OSRM_ATTR_WARN_UNUSED std::vector<util::Coordinate>
+    [[nodiscard]] std::vector<util::Coordinate>
    GetCoordinatesAlongRoad(const NodeID intersection_node,
                            const EdgeID turn_edge,
                            const bool traversed_in_reverse,
@@ -55,20 +53,18 @@ class CoordinateExtractor

    // wrapper in case of normal forward edges (traversed_in_reverse = false, to_node =
    // node_based_graph.GetTarget(turn_edge)
-    OSRM_ATTR_WARN_UNUSED
-    std::vector<util::Coordinate> GetForwardCoordinatesAlongRoad(const NodeID from,
-                                                                 const EdgeID turn_edge) const;
+    [[nodiscard]] std::vector<util::Coordinate>
+    GetForwardCoordinatesAlongRoad(const NodeID from, const EdgeID turn_edge) const;

    // a less precise way to compute coordinates along a route. Due to the heavy interaction of
    // graph traversal and turn instructions, we often don't care for high precision. We only want
    // to check for available connections in order, or find (with room for error) the straightmost
    // turn. This function will offer a bit more error potential but allow for much higher
    // performance
-    OSRM_ATTR_WARN_UNUSED
-    util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
-                                              const EdgeID turn_edge,
-                                              const bool traversed_in_reverse,
-                                              const NodeID to_node) const;
+    [[nodiscard]] util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
+                                                            const EdgeID turn_edge,
+                                                            const bool traversed_in_reverse,
+                                                            const NodeID to_node) const;

    /* When extracting the coordinates, we first extract all coordinates. We don't care about most
     * of them, though.
@@ -90,22 +86,19 @@ class CoordinateExtractor
     * The optional length cache needs to store the accumulated distance up to the respective
     * coordinate index [0,d(0,1),...]
     */
-    OSRM_ATTR_WARN_UNUSED
-    std::vector<util::Coordinate>
+    [[nodiscard]] std::vector<util::Coordinate>
    TrimCoordinatesToLength(std::vector<util::Coordinate> coordinates,
                            const double desired_length,
                            const std::vector<double> &length_cache = {}) const;

-    OSRM_ATTR_WARN_UNUSED
-    std::vector<double> PrepareLengthCache(const std::vector<util::Coordinate> &coordinates,
-                                           const double limit) const;
+    [[nodiscard]] std::vector<double>
+    PrepareLengthCache(const std::vector<util::Coordinate> &coordinates, const double limit) const;

    /* when looking at a set of coordinates, this function allows trimming the vector to a smaller,
     * only containing coordinates up to a given distance along the path. The last coordinate might
     * be interpolated
     */
-    OSRM_ATTR_WARN_UNUSED
-    std::vector<util::Coordinate>
+    [[nodiscard]] std::vector<util::Coordinate>
    TrimCoordinatesByLengthFront(std::vector<util::Coordinate> coordinates,
                                 const double desired_length) const;

@@ -130,10 +123,9 @@ class CoordinateExtractor
     *
     * for fixpoint `b`, vector_base `d` and vector_head `e`
     */
-    OSRM_ATTR_WARN_UNUSED
-    util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
-                                            const util::Coordinate vector_base,
-                                            const util::Coordinate vector_head) const;
+    [[nodiscard]] util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
+                                                          const util::Coordinate vector_base,
+                                                          const util::Coordinate vector_head) const;

    /* generate a uniform vector of coordinates in same range distances
     *
@@ -143,8 +135,7 @@ class CoordinateExtractor
     * Into:
     * x -- x -- x -- x -- x - x
     */
-    OSRM_ATTR_WARN_UNUSED
-    std::vector<util::Coordinate>
+    [[nodiscard]] std::vector<util::Coordinate>
    SampleCoordinates(const std::vector<util::Coordinate> &coordinates,
                      const double length,
                      const double rate) const;
@@ -1,13 +1,13 @@
 #ifndef OSRM_LOCATION_DEPENDENT_DATA_HPP
 #define OSRM_LOCATION_DEPENDENT_DATA_HPP

-#include <boost/filesystem/path.hpp>
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
 #include <boost/geometry/index/rtree.hpp>

 #include <osmium/osm/way.hpp>

+#include <filesystem>
 #include <string>
 #include <unordered_map>

@@ -30,7 +30,7 @@ struct LocationDependentData
    using property_t = boost::variant<boost::blank, double, std::string, bool>;
    using properties_t = std::unordered_map<std::string, property_t>;

-    LocationDependentData(const std::vector<boost::filesystem::path> &file_paths);
+    LocationDependentData(const std::vector<std::filesystem::path> &file_paths);

    bool empty() const { return rtree.empty(); }

@@ -39,7 +39,7 @@ struct LocationDependentData
    property_t FindByKey(const std::vector<std::size_t> &property_indexes, const char *key) const;

  private:
-    void loadLocationDependentData(const boost::filesystem::path &file_path,
+    void loadLocationDependentData(const std::filesystem::path &file_path,
                                   std::vector<rtree_t::value_type> &bounding_boxes);

    rtree_t rtree;
@@ -8,10 +8,12 @@
 #include "turn_path.hpp"
 #include "util/integer_range.hpp"
 #include "util/log.hpp"
+#include "util/std_hash.hpp"
 #include "util/vector_view.hpp"
+
+#include <variant>
+
 #include <algorithm>
-#include <boost/functional/hash.hpp>
-#include <mapbox/variant.hpp>

 namespace osrm::extractor
 {
@@ -147,7 +149,6 @@ struct UnresolvedManeuverOverride
 namespace std
 {
 template <> struct hash<osrm::extractor::NodeBasedTurn>
-
 {
    using argument_type = osrm::extractor::NodeBasedTurn;
    using result_type = std::size_t;
@@ -155,9 +156,9 @@ template <> struct hash<osrm::extractor::NodeBasedTurn>
    {

        std::size_t seed = 0;
-        boost::hash_combine(seed, s.from);
-        boost::hash_combine(seed, s.via);
-        boost::hash_combine(seed, s.to);
+        hash_combine(seed, s.from);
+        hash_combine(seed, s.via);
+        hash_combine(seed, s.to);

        return seed;
    }
@@ -12,8 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"

-#include <boost/filesystem/path.hpp>
-
+#include <filesystem>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -7,14 +7,13 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/foreach.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/qi_int.hpp>

 #include <storage/io.hpp>

+#include <filesystem>
 #include <iterator>
 #include <string>
 #include <unordered_map>
@@ -40,7 +39,7 @@ struct RasterDatum
 class RasterGrid
 {
  public:
-    RasterGrid(const boost::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
+    RasterGrid(const std::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
    {
        xdim = _xdim;
        ydim = _ydim;
@@ -1,12 +1,10 @@
 #ifndef RESTRICTION_HPP
 #define RESTRICTION_HPP

+#include "turn_path.hpp"
 #include "util/coordinate.hpp"
 #include "util/opening_hours.hpp"
 #include "util/typedefs.hpp"
-
-#include "mapbox/variant.hpp"
-#include "turn_path.hpp"
 #include <limits>

 namespace osrm::extractor
@@ -70,7 +70,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment

    explicit Sol2ScriptingEnvironment(
        const std::string &file_name,
-        const std::vector<boost::filesystem::path> &location_dependent_data_paths);
+        const std::vector<std::filesystem::path> &location_dependent_data_paths);
    ~Sol2ScriptingEnvironment() override = default;

    const ProfileProperties &GetProfileProperties() override;
@@ -8,13 +8,12 @@
 #include "storage/shared_memory_ownership.hpp"
 #include "storage/tar_fwd.hpp"

-#include <boost/filesystem/path.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/iterator_range.hpp>

-#include <unordered_map>
-
+#include <filesystem>
 #include <string>
+#include <unordered_map>
 #include <vector>

 namespace osrm::extractor
@@ -215,7 +215,6 @@ inline void read(storage::tar::FileReader &reader,
                 const std::string &name,
                 detail::NameTableImpl<Ownership> &name_table)
 {
-    std::string buffer;
    util::serialization::read(reader, name, name_table.indexed_data);
 }
 } // namespace osrm::extractor::serialization
@@ -1,10 +1,11 @@
 #ifndef OSRM_EXTRACTOR_TRAFFIC_SIGNALS_HPP
 #define OSRM_EXTRACTOR_TRAFFIC_SIGNALS_HPP

+#include "util/std_hash.hpp"
 #include "util/typedefs.hpp"

-#include <boost/functional/hash.hpp>
 #include <unordered_set>
+#include <utility>

 namespace osrm::extractor
 {
@@ -12,23 +13,22 @@ namespace osrm::extractor
 struct TrafficSignals
 {
    std::unordered_set<NodeID> bidirectional_nodes;
-    std::unordered_set<std::pair<NodeID, NodeID>, boost::hash<std::pair<NodeID, NodeID>>>
-        unidirectional_segments;
+    std::unordered_set<std::pair<NodeID, NodeID>> unidirectional_segments;

    inline bool HasSignal(NodeID from, NodeID to) const
    {
-        return bidirectional_nodes.count(to) > 0 || unidirectional_segments.count({from, to}) > 0;
+        return bidirectional_nodes.contains(to) || unidirectional_segments.contains({from, to});
    }

    void Compress(NodeID from, NodeID via, NodeID to)
    {
        bidirectional_nodes.erase(via);
-        if (unidirectional_segments.count({via, to}))
+        if (unidirectional_segments.contains({via, to}))
        {
            unidirectional_segments.erase({via, to});
            unidirectional_segments.insert({from, to});
        }
-        if (unidirectional_segments.count({via, from}))
+        if (unidirectional_segments.contains({via, from}))
        {
            unidirectional_segments.erase({via, from});
            unidirectional_segments.insert({to, from});
@@ -3,10 +3,9 @@

 #include "util/concurrent_id_map.hpp"
 #include "util/integer_range.hpp"
+#include "util/std_hash.hpp"
 #include "util/typedefs.hpp"

-#include <boost/functional/hash.hpp>
-
 #include <bitset>
 #include <cstddef>
 #include <cstdint>
@@ -54,19 +53,7 @@ const constexpr Mask merge_to_right = 1u << 10u;

 using TurnLaneDescription = std::vector<TurnLaneType::Mask>;

-// hash function for TurnLaneDescription
-struct TurnLaneDescription_hash
-{
-    std::size_t operator()(const TurnLaneDescription &lane_description) const
-    {
-        std::size_t seed = 0;
-        boost::hash_range(seed, lane_description.begin(), lane_description.end());
-        return seed;
-    }
-};
-
-using LaneDescriptionMap =
-    util::ConcurrentIDMap<TurnLaneDescription, LaneDescriptionID, TurnLaneDescription_hash>;
+using LaneDescriptionMap = util::ConcurrentIDMap<TurnLaneDescription, LaneDescriptionID>;

 using TurnLanesIndexedArray =
    std::tuple<std::vector<std::uint32_t>, std::vector<TurnLaneType::Mask>>;
@@ -4,7 +4,7 @@
 #include "util/typedefs.hpp"

 #include <algorithm>
-#include <mapbox/variant.hpp>
+#include <variant>
 #include <vector>

 namespace osrm::extractor
@@ -61,50 +61,50 @@ struct InputViaWayPath

 struct InputTurnPath
 {
-    mapbox::util::variant<InputViaNodePath, InputViaWayPath> node_or_way;
+    std::variant<InputViaNodePath, InputViaWayPath> node_or_way;

    TurnPathType Type() const
    {
-        BOOST_ASSERT(node_or_way.which() < TurnPathType::NUM_TURN_PATH_TYPES);
-        return static_cast<TurnPathType>(node_or_way.which());
+        BOOST_ASSERT(node_or_way.index() < TurnPathType::NUM_TURN_PATH_TYPES);
+        return static_cast<TurnPathType>(node_or_way.index());
    }

    OSMWayID From() const
    {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<InputViaNodePath>(node_or_way).from
-                   : mapbox::util::get<InputViaWayPath>(node_or_way).from;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<InputViaNodePath>(node_or_way).from
+                   : std::get<InputViaWayPath>(node_or_way).from;
    }

    OSMWayID To() const
    {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<InputViaNodePath>(node_or_way).to
-                   : mapbox::util::get<InputViaWayPath>(node_or_way).to;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<InputViaNodePath>(node_or_way).to
+                   : std::get<InputViaWayPath>(node_or_way).to;
    }

    InputViaWayPath &AsViaWayPath()
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<InputViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<InputViaWayPath>(node_or_way);
    }

    const InputViaWayPath &AsViaWayPath() const
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<InputViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<InputViaWayPath>(node_or_way);
    }

    InputViaNodePath &AsViaNodePath()
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<InputViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<InputViaNodePath>(node_or_way);
    }

    const InputViaNodePath &AsViaNodePath() const
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<InputViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<InputViaNodePath>(node_or_way);
    }
 };

@@ -175,63 +175,63 @@ struct ViaWayPath
 // between node/way paths
 struct TurnPath
 {
-    mapbox::util::variant<ViaNodePath, ViaWayPath> node_or_way;
+    std::variant<ViaNodePath, ViaWayPath> node_or_way;

    NodeID To() const
    {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<ViaNodePath>(node_or_way).to
-                   : mapbox::util::get<ViaWayPath>(node_or_way).to;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<ViaNodePath>(node_or_way).to
+                   : std::get<ViaWayPath>(node_or_way).to;
    }

    NodeID From() const
    {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<ViaNodePath>(node_or_way).from
-                   : mapbox::util::get<ViaWayPath>(node_or_way).from;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<ViaNodePath>(node_or_way).from
+                   : std::get<ViaWayPath>(node_or_way).from;
    }

    NodeID FirstVia() const
    {
-        if (node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH)
+        if (node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH)
        {
-            return mapbox::util::get<ViaNodePath>(node_or_way).via;
+            return std::get<ViaNodePath>(node_or_way).via;
        }
        else
        {
-            BOOST_ASSERT(!mapbox::util::get<ViaWayPath>(node_or_way).via.empty());
-            return mapbox::util::get<ViaWayPath>(node_or_way).via[0];
+            BOOST_ASSERT(!std::get<ViaWayPath>(node_or_way).via.empty());
+            return std::get<ViaWayPath>(node_or_way).via[0];
        }
    }

    ViaWayPath &AsViaWayPath()
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<ViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<ViaWayPath>(node_or_way);
    }

    const ViaWayPath &AsViaWayPath() const
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<ViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<ViaWayPath>(node_or_way);
    }

    ViaNodePath &AsViaNodePath()
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<ViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<ViaNodePath>(node_or_way);
    }

    const ViaNodePath &AsViaNodePath() const
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<ViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<ViaNodePath>(node_or_way);
    }

    TurnPathType Type() const
    {
-        BOOST_ASSERT(node_or_way.which() < TurnPathType::NUM_TURN_PATH_TYPES);
-        return static_cast<TurnPathType>(node_or_way.which());
+        BOOST_ASSERT(node_or_way.index() < TurnPathType::NUM_TURN_PATH_TYPES);
+        return static_cast<TurnPathType>(node_or_way.index());
    }

    bool operator==(const TurnPath &other) const
@@ -10,12 +10,16 @@

 #include <boost/assert.hpp>

+#include <cstdint>
+#include <filesystem>
+#include <type_traits>
+
 namespace osrm::guidance::files
 {

 // reads .osrm.edges
 template <typename TurnDataT>
-inline void readTurnData(const boost::filesystem::path &path,
+inline void readTurnData(const std::filesystem::path &path,
                         TurnDataT &turn_data,
                         std::uint32_t &connectivity_checksum)
 {
@@ -32,7 +36,7 @@ inline void readTurnData(const boost::filesystem::path &path,

 // writes .osrm.edges
 template <typename TurnDataT>
-inline void writeTurnData(const boost::filesystem::path &path,
+inline void writeTurnData(const std::filesystem::path &path,
                          const TurnDataT &turn_data,
                          const std::uint32_t connectivity_checksum)
 {
@@ -7,7 +7,6 @@
 #include "guidance/intersection_handler.hpp"
 #include "guidance/is_through_street.hpp"

-#include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"

 #include <vector>
@@ -42,18 +41,14 @@ class MotorwayHandler final : public IntersectionHandler
                            Intersection intersection) const override final;

  private:
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleSliproads(const NodeID intersection_node_id,
-                                 Intersection intersection) const;
+    [[nodiscard]] Intersection handleSliproads(const NodeID intersection_node_id,
+                                               Intersection intersection) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection fromMotorway(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection fromMotorway(const EdgeID via_edge, Intersection intersection) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection fromRamp(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection fromRamp(const EdgeID via_edge, Intersection intersection) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection fallback(Intersection intersection) const;
+    [[nodiscard]] Intersection fallback(Intersection intersection) const;
 };

 } // namespace osrm::guidance
@@ -7,8 +7,6 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/tokenizer.hpp>

-#include "util/attributes.hpp"
-
 namespace osrm::extractor::guidance
 {

@@ -21,8 +19,7 @@ namespace osrm::extractor::guidance
 // will be corrected to left|throught, since the final lane is not drivable.
 // This is in contrast to a situation with lanes:psv:forward=0 (or not set) where left|through|
 // represents left|through|through
-OSRM_ATTR_WARN_UNUSED
-inline std::string
+[[nodiscard]] inline std::string
 trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t count_right)
 {
    if (count_left)
@@ -68,8 +65,8 @@ trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t co
 // turn:lanes=left|through|through|right
 // vehicle:lanes=yes|yes|no|yes
 // bicycle:lanes=yes|no|designated|yes
-OSRM_ATTR_WARN_UNUSED
-inline std::string applyAccessTokens(std::string lane_string, const std::string &access_tokens)
+[[nodiscard]] inline std::string applyAccessTokens(std::string lane_string,
+                                                   const std::string &access_tokens)
 {
    using tokenizer = boost::tokenizer<boost::char_separator<char>>;
    boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
@@ -17,7 +17,6 @@
 #include "guidance/turn_classification.hpp"
 #include "guidance/turn_handler.hpp"

-#include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"

 #include <cstdint>
@@ -47,13 +46,11 @@ class TurnAnalysis

    /* Full Analysis Process for a single node/edge combination. Use with caution, as the process is
     * relatively expensive */
-    OSRM_ATTR_WARN_UNUSED
-    Intersection operator()(const NodeID node_prior_to_intersection,
-                            const EdgeID entering_via_edge) const;
+    [[nodiscard]] Intersection operator()(const NodeID node_prior_to_intersection,
+                                          const EdgeID entering_via_edge) const;

    // Select turn types based on the intersection shape
-    OSRM_ATTR_WARN_UNUSED
-    Intersection
+    [[nodiscard]] Intersection
    AssignTurnTypes(const NodeID from_node,
                    const EdgeID via_eid,
                    const extractor::intersection::IntersectionView &intersection) const;
@@ -8,7 +8,6 @@
 #include "guidance/intersection_handler.hpp"
 #include "guidance/is_through_street.hpp"

-#include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"

 #include <cstddef>
@@ -76,20 +75,19 @@ class TurnHandler final : public IntersectionHandler
    bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;

    // Dead end.
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleOneWayTurn(Intersection intersection) const;
+    [[nodiscard]] Intersection handleOneWayTurn(Intersection intersection) const;

    // Mode Changes, new names...
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleTwoWayTurn(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection handleTwoWayTurn(const EdgeID via_edge,
+                                                Intersection intersection) const;

    // Forks, T intersections and similar
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleThreeWayTurn(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection handleThreeWayTurn(const EdgeID via_edge,
+                                                  Intersection intersection) const;

    // Handling of turns larger then degree three
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleComplexTurn(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection handleComplexTurn(const EdgeID via_edge,
+                                                 Intersection intersection) const;

    void
    handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const;
@@ -97,15 +95,13 @@ class TurnHandler final : public IntersectionHandler
    // Classification
    std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection assignLeftTurns(const EdgeID via_edge,
-                                 Intersection intersection,
-                                 const std::size_t starting_at) const;
+    [[nodiscard]] Intersection assignLeftTurns(const EdgeID via_edge,
+                                               Intersection intersection,
+                                               const std::size_t starting_at) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection assignRightTurns(const EdgeID via_edge,
-                                  Intersection intersection,
-                                  const std::size_t up_to) const;
+    [[nodiscard]] Intersection assignRightTurns(const EdgeID via_edge,
+                                                Intersection intersection,
+                                                const std::size_t up_to) const;
 };

 } // namespace osrm::guidance
@@ -2,7 +2,6 @@
 #define OSRM_GUIDANCE_TURN_INSTRUCTION_HPP_

 #include "guidance/roundabout_type.hpp"
-#include "util/attributes.hpp"
 #include "util/typedefs.hpp"

 #include <algorithm>
@@ -243,8 +242,7 @@ inline guidance::DirectionModifier::Enum getTurnDirection(const double angle)
 }

 // swaps left <-> right modifier types
-OSRM_ATTR_WARN_UNUSED
-inline guidance::DirectionModifier::Enum
+[[nodiscard]] inline guidance::DirectionModifier::Enum
 mirrorDirectionModifier(const guidance::DirectionModifier::Enum modifier)
 {
    const constexpr guidance::DirectionModifier::Enum results[] = {
@@ -3,14 +3,12 @@

 #include "guidance/intersection.hpp"
 #include "guidance/turn_lane_data.hpp"
-#include "util/attributes.hpp"

 namespace osrm::guidance::lanes
 {

-OSRM_ATTR_WARN_UNUSED
-LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
-                                           const Intersection &intersection);
+[[nodiscard]] LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
+                                                         const Intersection &intersection);

 } // namespace osrm::guidance::lanes

@@ -2,7 +2,6 @@
 #define OSRM_GUIDANCE_TURN_LANE_DATA_HPP_

 #include "extractor/turn_lane_types.hpp"
-#include "util/attributes.hpp"
 #include "util/typedefs.hpp"
 #include <vector>

@@ -23,8 +22,8 @@ struct TurnLaneData
 using LaneDataVector = std::vector<TurnLaneData>;

 // convertes a string given in the OSM format into a TurnLaneData vector
-OSRM_ATTR_WARN_UNUSED
-LaneDataVector laneDataFromDescription(const extractor::TurnLaneDescription &turn_lane_description);
+[[nodiscard]] LaneDataVector
+laneDataFromDescription(const extractor::TurnLaneDescription &turn_lane_description);

 // Locate A Tag in a lane data vector (if multiple tags are set, the first one found is returned)
 LaneDataVector::const_iterator findTag(const extractor::TurnLaneType::Mask tag,
@@ -9,7 +9,6 @@
 #include "guidance/turn_analysis.hpp"
 #include "guidance/turn_lane_data.hpp"

-#include "util/attributes.hpp"
 #include "util/guidance/turn_lanes.hpp"
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
@@ -68,8 +67,8 @@ class TurnLaneHandler

    ~TurnLaneHandler();

-    OSRM_ATTR_WARN_UNUSED
-    Intersection assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection);
+    [[nodiscard]] Intersection
+    assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection);

  private:
    mutable std::atomic<std::size_t> count_handled;
@@ -108,24 +107,23 @@ class TurnLaneHandler
                              const Intersection &intersection) const;

    // in case of a simple intersection, assign the lane entries
-    OSRM_ATTR_WARN_UNUSED
-    Intersection simpleMatchTuplesToTurns(Intersection intersection,
-                                          const LaneDataVector &lane_data,
-                                          const LaneDescriptionID lane_string_id);
+    [[nodiscard]] Intersection simpleMatchTuplesToTurns(Intersection intersection,
+                                                        const LaneDataVector &lane_data,
+                                                        const LaneDescriptionID lane_string_id);

    // partition lane data into lane data relevant at current turn and at next turn
-    OSRM_ATTR_WARN_UNUSED
-    std::pair<TurnLaneHandler::LaneDataVector, TurnLaneHandler::LaneDataVector> partitionLaneData(
-        const NodeID at, LaneDataVector turn_lane_data, const Intersection &intersection) const;
+    [[nodiscard]] std::pair<TurnLaneHandler::LaneDataVector, TurnLaneHandler::LaneDataVector>
+    partitionLaneData(const NodeID at,
+                      LaneDataVector turn_lane_data,
+                      const Intersection &intersection) const;

    // Sliproad turns have a separated lane to the right/left of other depicted lanes. These lanes
    // are not necessarily separated clearly from the rest of the way. As a result, we combine both
    // lane entries for our output, while performing the matching with the separated lanes only.
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleSliproadTurn(Intersection intersection,
-                                    const LaneDescriptionID lane_description_id,
-                                    LaneDataVector lane_data,
-                                    const Intersection &previous_intersection);
+    [[nodiscard]] Intersection handleSliproadTurn(Intersection intersection,
+                                                  const LaneDescriptionID lane_description_id,
+                                                  LaneDataVector lane_data,
+                                                  const Intersection &previous_intersection);

    // get the lane data for an intersection
    void extractLaneData(const EdgeID via_edge,
@@ -5,7 +5,6 @@
 #include "guidance/turn_instruction.hpp"
 #include "guidance/turn_lane_data.hpp"

-#include "util/attributes.hpp"
 #include "util/guidance/turn_lanes.hpp"
 #include "util/node_based_graph.hpp"

@@ -34,12 +33,12 @@ findBestMatchForReverse(const extractor::TurnLaneType::Mask leftmost_tag,
 bool canMatchTrivially(const Intersection &intersection, const LaneDataVector &lane_data);

 // perform a trivial match on the turn lanes
-OSRM_ATTR_WARN_UNUSED
-Intersection triviallyMatchLanesToTurns(Intersection intersection,
-                                        const LaneDataVector &lane_data,
-                                        const util::NodeBasedDynamicGraph &node_based_graph,
-                                        const LaneDescriptionID lane_string_id,
-                                        util::guidance::LaneDataIdMap &lane_data_to_id);
+[[nodiscard]] Intersection
+triviallyMatchLanesToTurns(Intersection intersection,
+                           const LaneDataVector &lane_data,
+                           const util::NodeBasedDynamicGraph &node_based_graph,
+                           const LaneDescriptionID lane_string_id,
+                           util::guidance::LaneDataIdMap &lane_data_to_id);

 } // namespace osrm::guidance::lanes

@@ -29,7 +29,7 @@ struct V8Renderer
        for (const auto &keyValue : object.values)
        {
            Napi::Value child;
-            mapbox::util::apply_visitor(V8Renderer(env, child), keyValue.second);
+            std::visit(V8Renderer(env, child), keyValue.second);
            obj.Set(keyValue.first, child);
        }
        out = obj;
@@ -41,7 +41,7 @@ struct V8Renderer
        for (auto i = 0u; i < array.values.size(); ++i)
        {
            Napi::Value child;
-            mapbox::util::apply_visitor(V8Renderer(env, child), array.values[i]);
+            std::visit(V8Renderer(env, child), array.values[i]);
            a.Set(i, child);
        }
        out = a;
@@ -21,14 +21,14 @@
 #include <napi.h>

 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
+#include <optional>

 #include <algorithm>
-#include <iostream>
 #include <iterator>
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <variant>
 #include <vector>

 #include <exception>
@@ -51,7 +51,7 @@ struct PluginParameters
    bool renderToBuffer = false;
 };

-using ObjectOrString = typename mapbox::util::variant<osrm::json::Object, std::string>;
+using ObjectOrString = typename std::variant<osrm::json::Object, std::string>;

 template <typename ResultT> inline Napi::Value render(const Napi::Env &env, const ResultT &result);

@@ -62,18 +62,18 @@ template <> Napi::Value inline render(const Napi::Env &env, const std::string &r

 template <> Napi::Value inline render(const Napi::Env &env, const ObjectOrString &result)
 {
-    if (result.is<osrm::json::Object>())
+    if (std::holds_alternative<osrm::json::Object>(result))
    {
        // Convert osrm::json object tree into matching v8 object tree
        Napi::Value value;
-        renderToV8(env, value, result.get<osrm::json::Object>());
+        renderToV8(env, value, std::get<osrm::json::Object>(result));
        return value;
    }
    else
    {
        // Return the string object as a node Buffer
        return Napi::Buffer<char>::Copy(
-            env, result.get<std::string>().data(), result.get<std::string>().size());
+            env, std::get<std::string>(result).data(), std::get<std::string>(result).size());
    }
 }

@@ -96,7 +96,7 @@ inline void ParseResult(const osrm::Status &result_status, osrm::json::Object &r

    if (result_status == osrm::Status::Error)
    {
-        throw std::logic_error(code_iter->second.get<osrm::json::String>().value.c_str());
+        throw std::logic_error(std::get<osrm::json::String>(code_iter->second).value.c_str());
    }

    result.values.erase(code_iter);
@@ -296,24 +296,19 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
        {
            engine_config->algorithm = osrm::EngineConfig::Algorithm::CH;
        }
-        else if (algorithm_str == "CoreCH")
-        {
-            engine_config->algorithm = osrm::EngineConfig::Algorithm::CH;
-        }
        else if (algorithm_str == "MLD")
        {
            engine_config->algorithm = osrm::EngineConfig::Algorithm::MLD;
        }
        else
        {
-            ThrowError(args.Env(), "algorithm option must be one of 'CH', 'CoreCH', or 'MLD'.");
+            ThrowError(args.Env(), "algorithm option must be one of 'CH', or 'MLD'.");
            return engine_config_ptr();
        }
    }
    else if (!algorithm.IsUndefined())
    {
-        ThrowError(args.Env(),
-                   "algorithm option must be a string and one of 'CH', 'CoreCH', or 'MLD'.");
+        ThrowError(args.Env(), "algorithm option must be a string and one of 'CH', or 'MLD'.");
        return engine_config_ptr();
    }

@@ -400,11 +395,11 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
    return engine_config;
 }

-inline boost::optional<std::vector<osrm::Coordinate>>
+inline std::optional<std::vector<osrm::Coordinate>>
 parseCoordinateArray(const Napi::Array &coordinates_array)
 {
    Napi::HandleScope scope(coordinates_array.Env());
-    boost::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
+    std::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
    std::vector<osrm::Coordinate> temp_coordinates;

    for (uint32_t i = 0; i < coordinates_array.Length(); ++i)
@@ -455,7 +450,7 @@ parseCoordinateArray(const Napi::Array &coordinates_array)
                                      osrm::util::FloatLatitude{std::move(lat)});
    }

-    resulting_coordinates = boost::make_optional(std::move(temp_coordinates));
+    resulting_coordinates = std::make_optional(std::move(temp_coordinates));
    return resulting_coordinates;
 }

@@ -1028,7 +1023,7 @@ inline bool parseCommonParameters(const Napi::Object &obj, ParamType &params)

 inline PluginParameters argumentsToPluginParameters(
    const Napi::CallbackInfo &args,
-    const boost::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
+    const std::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
 {
    if (args.Length() < 3 || !args[1].IsObject())
    {
@@ -173,8 +173,8 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
                for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
                {
                    const auto &data = edge_based_graph.GetEdgeData(edge);
-                    // we only need to save the forward edges, since the read method will
-                    // convert from forward to bi-directional edges again
+                    // we only need to save the forward edges, since the read method
+                    // will convert from forward to bi-directional edges again
                    if (data.forward)
                    {
                        auto target = edge_based_graph.GetTarget(edge);
@@ -191,7 +191,7 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
    return edges;
 }

-inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &path)
+inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const std::filesystem::path &path)
 {
    EdgeID number_of_edge_based_nodes;
    std::vector<extractor::EdgeBasedEdge> edges;
@@ -10,7 +10,7 @@ namespace osrm::partitioner::files

 // read .osrm.partition file
 template <typename MultiLevelPartitionT>
-inline void readPartition(const boost::filesystem::path &path, MultiLevelPartitionT &mlp)
+inline void readPartition(const std::filesystem::path &path, MultiLevelPartitionT &mlp)
 {
    static_assert(std::is_same<MultiLevelPartitionView, MultiLevelPartitionT>::value ||
                      std::is_same<MultiLevelPartition, MultiLevelPartitionT>::value,
@@ -24,7 +24,7 @@ inline void readPartition(const boost::filesystem::path &path, MultiLevelPartiti

 // writes .osrm.partition file
 template <typename MultiLevelPartitionT>
-inline void writePartition(const boost::filesystem::path &path, const MultiLevelPartitionT &mlp)
+inline void writePartition(const std::filesystem::path &path, const MultiLevelPartitionT &mlp)
 {
    static_assert(std::is_same<MultiLevelPartitionView, MultiLevelPartitionT>::value ||
                      std::is_same<MultiLevelPartition, MultiLevelPartitionT>::value,
@@ -38,7 +38,7 @@ inline void writePartition(const boost::filesystem::path &path, const MultiLevel

 // reads .osrm.cells file
 template <typename CellStorageT>
-inline void readCells(const boost::filesystem::path &path, CellStorageT &storage)
+inline void readCells(const std::filesystem::path &path, CellStorageT &storage)
 {
    static_assert(std::is_same<CellStorageView, CellStorageT>::value ||
                      std::is_same<CellStorage, CellStorageT>::value,
@@ -52,7 +52,7 @@ inline void readCells(const boost::filesystem::path &path, CellStorageT &storage

 // writes .osrm.cells file
 template <typename CellStorageT>
-inline void writeCells(const boost::filesystem::path &path, CellStorageT &storage)
+inline void writeCells(const std::filesystem::path &path, CellStorageT &storage)
 {
    static_assert(std::is_same<CellStorageView, CellStorageT>::value ||
                      std::is_same<CellStorage, CellStorageT>::value,
@@ -66,7 +66,7 @@ inline void writeCells(const boost::filesystem::path &path, CellStorageT &storag

 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                      MultiLevelGraphT &graph,
                      std::uint32_t &connectivity_checksum)
 {
@@ -80,7 +80,7 @@ inline void readGraph(const boost::filesystem::path &path,

 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                       const MultiLevelGraphT &graph,
                       const std::uint32_t connectivity_checksum)
 {
@@ -1,9 +1,8 @@
 #ifndef OSRM_PARTITIONER_CONFIG_HPP
 #define OSRM_PARTITIONER_CONFIG_HPP

-#include <boost/filesystem/path.hpp>
-
 #include <array>
+#include <filesystem>
 #include <string>

 #include "storage/io_config.hpp"
@@ -29,7 +28,7 @@ struct PartitionerConfig final : storage::IOConfig
    {
    }

-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
    }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dennis	4ec1652781	Remove example (no one uses this)	2024-07-10 13:25:25 +02:00
Dennis	3cdcba165b	Simplify CMakeLists.txt	2024-07-10 12:51:46 +02:00
Siarhei Fedartsou	5e6fdda16b	Add NOTE: label to comment in stale.yml (#6987 )	2024-07-09 21:27:46 +02:00
Siarhei Fedartsou	f5598efcff	Add .reserve(...) to assembleGeometry function (#6983 )	2024-07-09 20:12:47 +02:00
Siarhei Fedartsou	ab771c6142	Do not trigger stale bot on each PR (#6986 )	2024-07-09 19:58:03 +02:00
Siarhei Fedartsou	f1510b758d	Increase number of GitHub operations allowed in stale bot (#6985 )	2024-07-09 19:32:03 +02:00
Siarhei Fedartsou	4930d2ef05	Use clang 18/17/16 instead of 15/14/13 (#6978 )	2024-07-03 20:02:44 +02:00
Siarhei Fedartsou	57b792c768	Get rid of boost::optional leftovers (#6977 )	2024-07-02 22:37:09 +02:00
Siarhei Fedartsou	d0ed29adb7	Use Link Time Optimisation whenever possible (#6967 )	2024-06-30 21:07:49 +02:00
Siarhei Fedartsou	bdc6ed8a53	Use struct instead of tuple to define UnpackedPath (#6974 )	2024-06-29 21:34:43 +02:00
Siarhei Fedartsou	93c0e1dab3	Micro performance optimisation in map matching (#6976 )	2024-06-29 19:59:08 +02:00
Siarhei Fedartsou	cacb1b23f9	Fix calculation of best ops/sec in benchmarks (#6973 )	2024-06-29 10:31:23 +02:00
Siarhei Fedartsou	0e17869e21	Re-use priority queue in StaticRTree (#6952 )	2024-06-25 18:58:48 +02:00
Siarhei Fedartsou	5a48ce85b3	Use tmpfs for running benchmarks (#6966 )	2024-06-25 17:49:41 +02:00
Siarhei Fedartsou	7d72dfebf7	Optimise encodePolyline function (#6940 )	2024-06-22 20:04:32 +02:00
Siarhei Fedartsou	3d01d96036	Avoid reallocations in base64 encoding (#6951 )	2024-06-22 08:50:18 +02:00
Siarhei Fedartsou	e8da3d9231	Calculate confidence interval for benchmark measurements (#6950 )	2024-06-21 21:43:27 +02:00
Siarhei Fedartsou	d9ce9cf780	Get rid of unused Boost dependencies (#6960 )	2024-06-21 19:04:34 +02:00
Siarhei Fedartsou	3285ce3b2f	Configure stale bot (#6963 )	2024-06-21 08:51:56 +02:00
Dennis Luxen	f1eabc3ecc	Replace boost::filesystem with std (#6432 )	2024-06-20 21:44:28 +02:00
knowname	c3f2a6cdb9	Add CI job for building Alpine-based Docker image (#6959 )	2024-06-20 09:08:57 +02:00
knowname	97f676d5a3	add alpine dockerfile (#6958 )	2024-06-19 14:15:23 +02:00
Siarhei Fedartsou	7ffc08be28	Bump versions of TBB, Expat and Lua installed via Conan (#6957 )	2024-06-19 07:46:56 +02:00
Siarhei Fedartsou	feb9389436	Apply micro-optimisation for Table & Trip APIs (#6949 )	2024-06-15 18:57:26 +02:00
Siarhei Fedartsou	a0eda3e7d7	Apply micro-optimisation for Route API (#6948 )	2024-06-15 18:56:40 +02:00
Siarhei Fedartsou	7652f6ca6b	Apply micro-optimisation for Match API (#6945 )	2024-06-14 16:04:19 +02:00
Siarhei Fedartsou	aa4e6b1cf3	Apply micro-optimisation for Nearest API (#6944 )	2024-06-13 18:18:36 +02:00
Siarhei Fedartsou	de2f392960	Avoid copy of intersection in totalTurnAngle (#6938 )	2024-06-10 22:40:37 +02:00
Siarhei Fedartsou	0188d2bccd	Use std::unordered_map::emplace instead of operator[] when producing JSONs (#6936 )	2024-06-10 21:29:31 +02:00
Siarhei Fedartsou	054161fc7e	Avoid copy of vectors in MakeRoute function (#6939 )	2024-06-10 20:06:43 +02:00
Siarhei Fedartsou	89435aa87f	Add new randomized benchmarks (#6929 )	2024-06-09 17:03:24 +02:00
Siarhei Fedartsou	0cbb23abe1	Fix Windows CI: update conan.cmake and disable unit tests as temporary workaround for OOM issues (#6930 )	2024-06-09 09:24:02 +02:00
Siarhei Fedartsou	a2915f78c5	Make e2e benchmarks more stable (#6927 )	2024-06-08 22:27:12 +02:00
Siarhei Fedartsou	99cb17aed3	Fix bugprone-unused-return-value clang-tidy warning (#6934 )	2024-06-08 14:33:24 +02:00
Siarhei Fedartsou	8fd8d0c24a	Fix performance-noexcept-move-constructor clang-tidy warning (#6933 )	2024-06-08 08:33:54 +02:00
Siarhei Fedartsou	c57b0d28b0	Fix performance-noexcept-swap clang-tidy warning (#6931 )	2024-06-07 16:18:10 +02:00
Siarhei Fedartsou	523ee762f0	Upgrade to clang-tidy 18 (#6919 )	2024-06-06 22:20:38 +02:00
Siarhei Fedartsou	feeed75cf1	Add simple benchmarks for osrm-* tools (#6925 )	2024-06-06 21:01:34 +02:00
Siarhei Fedartsou	c7ee1a59eb	Implement end to end benchmark (#6910 )	2024-06-05 21:39:10 +02:00
Dennis Luxen	2725202771	Use Lemire's fast check whether to escape a JSON string (#6923 )	2024-05-31 19:58:57 +02:00
Siarhei Fedartsou	42fafdcdfe	Use custom struct instead of std::pair in QueryHeap (#6921 )	2024-05-31 07:06:58 +02:00
Siarhei Fedartsou	c8de759cd6	Use std::string_view::starts_with instead of boost::starts_with (#6918 )	2024-05-30 21:55:25 +02:00
Siarhei Fedartsou	fb9d1cefcc	Get rid of boost::math::constants::* and M_PI in favor of std::numbers (#6916 )	2024-05-30 19:40:56 +02:00
Dennis Luxen	a9b1bd88d3	Remove all core-CH left-overs (#6920 ) * Remove all core-CH left-overs * Fix formatting * Update CHANGELOG.md	2024-05-30 17:13:44 +02:00
Siarhei Fedartsou	1ff096ac5c	Make constants in PackedVector constexpr (#6917 )	2024-05-30 15:12:42 +02:00
Dennis Luxen	0ea757ed02	Remove unused header file (#6913 )	2024-05-29 09:13:13 +02:00
Dennis Luxen	42cbca0ff0	Move Sol2 to canonical path (#6912 )	2024-05-28 21:23:51 +02:00
Siarhei Fedartsou	c1ed73126d	Use std::variant instead of mapbox::util::variant (#6903 )	2024-05-28 18:52:49 +02:00
Siarhei Fedartsou	01b1673c8a	Fix CCache usage in GitHub Actions (#6911 )	2024-05-28 08:43:23 +02:00
Siarhei Fedartsou	d4dc297f75	Add CI job with GCC 14 (#6905 )	2024-05-27 09:31:13 +02:00
Siarhei Fedartsou	9aaab7a53f	Enable readability-container-contains clang-tidy check (#6909 )	2024-05-27 08:33:26 +02:00
Siarhei Fedartsou	1a6f4c44e7	Fix performance-type-promotion-in-math-fn clang-tidy warning (#6908 )	2024-05-27 08:33:05 +02:00
Siarhei Fedartsou	163a2cfe3c	Bump rapidjson version (#6906 )	2024-05-27 08:31:59 +02:00
Siarhei Fedartsou	667fd198ac	Use the latest Debian version in Dockerfile (#6904 )	2024-05-27 08:30:44 +02:00
Siarhei Fedartsou	b7a990d0b5	Use C++20 (#6877 )	2024-05-25 18:25:13 +02:00
Dennis Luxen	8306ed8ae3	Remove superflous iostreams include from header files (#6901 )	2024-05-25 09:17:45 +02:00
Dennis Luxen	640df69aa1	Remove dead CRC32 processor code (#6900 )	2024-05-24 22:43:03 +02:00
Siarhei Fedartsou	8b48e2ccc6	Bump mapbox/variant to version 1.2.0 (#6898 )	2024-05-24 20:39:45 +02:00
Dennis Luxen	babdced52f	Replace GCC-specific attribute with [[nodiscard]] attribute (#6899 )	2024-05-24 20:34:04 +02:00
Siarhei Fedartsou	21607e0cb2	Optimise getNetworkDistance in MLD even more (#6884 )	2024-05-23 20:46:13 +02:00
Dennis Luxen	24646aada9	Remove outdated warnings (#6894 )	2024-05-23 19:39:00 +02:00
Dennis Luxen	51b74a99aa	Avoid copy of std::function-based callback in path unpacking (#6895 ) * Avoid copy of std::function-based callback in path unpacking * Fix formatting * Update CHANGELOG.md	2024-05-23 18:51:51 +02:00
Dennis Luxen	ed5003b502	Upgrade CI actions to latest versions (#6893 ) * Upgrade actions * Update remaining actions * Update CHANGELOG.md * Update CHANGELOG.md	2024-05-23 14:40:47 +02:00
Dennis Luxen	46dc660801	Replace boost::hash by std::hash (#6892 ) * Replace boost::hash by std::hash * Fix formatting * Update CHANGELOG.md	2024-05-23 14:35:56 +02:00
Siarhei Fedartsou	73fb53cf36	Add benchmark for route (#6890 )	2024-05-23 14:27:43 +02:00
Mugr Rex	efe6840d08	Replace boost::optional with std::optional (#6611 )	2024-05-22 14:58:07 +02:00