wip

.clang-tidy

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

.gitea/workflows/publish-container.yaml

@@ -1,65 +0,0 @@
-name: Build and Publish Docker Image
-
-on:
-  release:
-    types: [published, prereleased]
-
-env:
-  IMAGE_NAME: openharbor/osrm-backend
-
-jobs:
-  publish:
-    strategy:
-      matrix:
-        docker-base-image: ["debian", "alpine"]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v3
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: ${{ env.IMAGE_NAME }}
-
-      - name: Docker meta - debug
-        id: metadebug
-        uses: docker/metadata-action@v4
-        with:
-          images: ${{ env.IMAGE_NAME }}
-          flavor: |
-            latest=true
-            suffix=-debug,onlatest=true
-
-      - name: Log in to DockerHub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_ACCESS_TOKEN }}
-
-      - name: Build and push debug image
-        uses: docker/build-push-action@v4
-        with:
-          push: true
-          platforms: linux/amd64,linux/arm64,linux/ppc64le,linux/riscv64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
-          tags: ${{ steps.metadebug.outputs.tags }}
-          build-args: |
-            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags) }}-${{ matrix.docker-base-image }}
-
-      - name: Build and push normal image
-        uses: docker/build-push-action@v4
-        with:
-          push: true
-          platforms: linux/amd64,linux/arm64,linux/ppc64le,linux/riscv64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
-          tags: ${{ steps.meta.outputs.tags }}
-          build-args: |
-            DOCKER_TAG=${{ join(steps.meta.outputs.tags) }}-${{ matrix.docker-base-image }}

.github/workflows/osrm-backend-docker.yml

@@ -6,9 +6,6 @@ on:
 
 jobs:
   publish:
-    strategy:
-      matrix:
-        docker-base-image: ["debian", "alpine"]
     runs-on: ubuntu-latest
     steps:       
       - name: Check out the repo
@@ -56,10 +53,10 @@ jobs:
         with:
           push: true
           platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          file: ./docker/Dockerfile
           tags: ${{ steps.metadebug.outputs.tags  }}
           build-args: |
-            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}
 
 
       - name: Build container image - assertions
@@ -67,10 +64,10 @@ jobs:
         with:
           push: true
           platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          file: ./docker/Dockerfile
           tags: ${{ steps.metaassertions.outputs.tags  }}
           build-args: |
-            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}
 
       # build and publish "normal" image as last to get it listed on top
       - name: Build container image - normal
@@ -78,7 +75,10 @@ jobs:
         with:
           push: true
           platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
-          tags: ${{ steps.meta.outputs.tags  }}
+          file: ./docker/Dockerfile
+          tags:  ${{ steps.meta.outputs.tags  }}
           build-args: |
-            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}            
+
+
+            

.github/workflows/osrm-backend.yml

@@ -116,10 +116,7 @@ jobs:
         npm run docs && ./scripts/error_on_dirty.sh
         npm audit --production
 
-  docker-image-matrix:
-    strategy:
-      matrix:
-        docker-base-image: ["debian", "alpine"]
+  docker-image:
     needs: format-taginfo-docs
     runs-on: ubuntu-22.04
     continue-on-error: false
@@ -135,7 +132,7 @@ jobs:
             v1-berlin-osm-pbf
       - name: Docker build
         run: |
-          docker build -t osrm-backend-local -f docker/Dockerfile-${{ matrix.docker-base-image }} .
+          docker build -t osrm-backend-local -f docker/Dockerfile .
       - name: Test Docker image
         run: |
           if [ ! -f "${PWD}/berlin-latest.osm.pbf" ]; then
@@ -152,6 +149,7 @@ 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"
 
@@ -177,41 +175,39 @@ jobs:
             CXXCOMPILER: g++-13
             ENABLE_COVERAGE: ON
 
-          - name: clang-18-debug-asan-ubsan
+          - name: clang-15-debug-asan-ubsan
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
             CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
             ENABLE_SANITIZER: ON
             TARGET_ARCH: x86_64-asan-ubsan
             OSRM_CONNECTION_RETRIES: 10
             OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
 
-          - name: clang-18-release
+          - name: clang-15-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
-          - name: clang-18-debug
+          - name: clang-15-debug
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
           - name: clang-18-debug-clang-tidy
             continue-on-error: false
@@ -225,50 +221,46 @@ jobs:
             ENABLE_CLANG_TIDY: ON
 
 
-          - name: clang-17-release
+          - name: clang-14-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-17
-            CXXCOMPILER: clang++-17
+            CCOMPILER: clang-14
+            CXXCOMPILER: clang++-14
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
-          - name: clang-16-release
+          - name: clang-13-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
           - name: conan-linux-debug-asan-ubsan
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             ENABLE_CONAN: ON
             ENABLE_SANITIZER: ON
-            ENABLE_LTO: OFF
 
           - name: conan-linux-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             ENABLE_CONAN: ON
-            ENABLE_LTO: OFF
 
           - name: gcc-14-release
             continue-on-error: false
@@ -304,10 +296,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -315,10 +307,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TYPE: Debug
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -367,7 +359,6 @@ jobs:
       TARGET_ARCH: ${{ matrix.TARGET_ARCH }}
       OSRM_CONNECTION_RETRIES: ${{ matrix.OSRM_CONNECTION_RETRIES }}
       OSRM_CONNECTION_EXP_BACKOFF_COEF: ${{ matrix.OSRM_CONNECTION_EXP_BACKOFF_COEF }}
-      ENABLE_LTO: ${{ matrix.ENABLE_LTO }}
     steps:
     - uses: actions/checkout@v4
     - name: Build machine architecture
@@ -446,14 +437,14 @@ jobs:
       if: steps.cache-boost.outputs.cache-hit != 'true' && runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
       run: |
         BOOST_VERSION="1.85.0"
-        BOOST_VERSION_FLAVOR="${BOOST_VERSION}-b2-nodocs"
-        wget -q https://github.com/boostorg/boost/releases/download/boost-${BOOST_VERSION}/boost-${BOOST_VERSION_FLAVOR}.tar.gz
-        tar xzf boost-${BOOST_VERSION_FLAVOR}.tar.gz
-        cd boost-${BOOST_VERSION}
+        BOOST_VERSION_UNDERSCORE="${BOOST_VERSION//./_}"
+        wget -q https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION}/source/boost_${BOOST_VERSION_UNDERSCORE}.tar.gz
+        tar xzf boost_${BOOST_VERSION_UNDERSCORE}.tar.gz
+        cd boost_${BOOST_VERSION_UNDERSCORE}
         sudo ./bootstrap.sh
         sudo ./b2 install
         cd ..
-        sudo rm -rf boost-${BOOST_VERSION}*
+        sudo rm -rf boost_${BOOST_VERSION_UNDERSCORE}*
     
     - name: Install dev dependencies
       run: |
@@ -495,20 +486,6 @@ jobs:
         tar zxvf onetbb.tgz
         sudo cp -a oneapi-tbb-${TBB_VERSION}/lib/. /usr/local/lib/
         sudo cp -a oneapi-tbb-${TBB_VERSION}/include/. /usr/local/include/
-    - name: Add Clang 18 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Clang 18
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.CCOMPILER == 'clang-18' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_linux_amd64 -O /usr/bin/yq && sudo chmod +x /usr/bin/yq
-
-        conan config init
-        yq eval '.compiler.clang.version += ["18"]' -i "$HOME/.conan/settings.yml"
-    - name: Add Apple-clang 16 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Apple-clang 16
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.runs-on == 'macos-14' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_darwin_arm64 -O /usr/local/bin/yq && sudo chmod +x /usr/local/bin/yq
-
-        conan config init
-        yq eval '.compiler.apple-clang.version += ["16.0"]' -i "$HOME/.conan/settings.yml"
     - name: Prepare build
       run: |
         mkdir ${OSRM_BUILD_DIR}
@@ -542,7 +519,6 @@ jobs:
                  -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
                  -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
                  -DENABLE_CCACHE=ON \
-                 -DENABLE_LTO=${ENABLE_LTO:-ON} \
                  -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
         make --jobs=${JOBS}
 
@@ -660,28 +636,48 @@ jobs:
   benchmarks:
     if: github.event_name == 'pull_request'
     needs: [format-taginfo-docs]
-    runs-on: self-hosted
+    runs-on: ubuntu-22.04
     env:
-      CCOMPILER: clang-16
-      CXXCOMPILER: clang++-16
-      CC: clang-16
-      CXX: clang++-16
+      CCOMPILER: clang-13
+      CXXCOMPILER: clang++-13
+      CC: clang-13
+      CXX: clang++-13
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       PR_NUMBER: ${{ github.event.pull_request.number }}
       GITHUB_REPOSITORY: ${{ github.repository }}
       RUN_BIG_BENCHMARK: ${{ contains(github.event.pull_request.labels.*.name, 'Performance') }}
     steps: 
+      - name: Enable data.osm.pbf cache
+        if: ${{ ! env.RUN_BIG_BENCHMARK }}        
+        uses: actions/cache@v4
+        with:
+          path: ~/data.osm.pbf
+          key: v1-data-osm-pbf
+          restore-keys: |
+            v1-data-osm-pbf
+      - name: Enable compiler cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.ccache
+          key: v1-ccache-benchmarks-${{ github.sha }}
+          restore-keys: |
+            v1-ccache-benchmarks-
+      - name: Enable Conan cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.conan
+          key: v1-conan-benchmarks-${{ github.sha }}
+          restore-keys: |
+            v1-conan-benchmarks-
       - name: Checkout PR Branch
         uses: actions/checkout@v4
         with:
           ref: ${{ github.head_ref }}
           path: pr
-      - name: Activate virtualenv
-        run: |
-          python3 -m venv .venv
-          source .venv/bin/activate
-          echo PATH=$PATH >> $GITHUB_ENV
-          pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
+      - name: Install dependencies
+        run: | 
+          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
+          sudo apt-get update -y && sudo apt-get install ccache
       - name: Prepare data
         run: |
           if [ "$RUN_BIG_BENCHMARK" = "true" ]; then
@@ -702,6 +698,15 @@ jobs:
           mkdir -p $HOME/.ccache
           ccache --zero-stats
           ccache --max-size=256M
+      - name: Build PR Branch
+        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 
       - name: Checkout Base Branch
         uses: actions/checkout@v4
         with:
@@ -709,67 +714,16 @@ jobs:
           path: base
       - name: Build Base Branch
         run: |
-          cd base
-          npm ci --ignore-scripts
-          cd ..
           mkdir base/build
           cd base/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
           make -j$(nproc)
           make -j$(nproc) benchmarks
           cd ..
           make -C test/data 
-      - name: Build PR Branch
+      - name: Run Benchmarks
         run: |
-          cd pr
-          npm ci --ignore-scripts
-          cd ..
-          mkdir -p pr/build
-          cd pr/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
-          make -j$(nproc) 
-          make -j$(nproc) benchmarks
-          cd ..
-          make -C test/data 
-      # we run benchmarks in tmpfs to avoid impact of disk IO
-      - name: Create folder for tmpfs 
-        run: |
-          # if by any chance it was mounted before(e.g. due to previous job failed), unmount it
-          sudo umount ~/benchmarks | true
-          rm -rf ~/benchmarks 
-          mkdir -p ~/benchmarks
-      # see https://llvm.org/docs/Benchmarking.html
-      - name: Run PR Benchmarks 
-        run: |
-          sudo cset shield -c 2-3 -k on
-          sudo mount -t tmpfs -o size=4g none ~/benchmarks
-          cp -rf pr/build ~/benchmarks/build
-          cp -rf pr/lib ~/benchmarks/lib
-          mkdir -p ~/benchmarks/test
-          cp -rf pr/test/data ~/benchmarks/test/data
-          cp -rf pr/profiles ~/benchmarks/profiles
-
-          sudo cset shield --exec -- ./pr/scripts/ci/run_benchmarks.sh -f ~/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b ~/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount ~/benchmarks
-          sudo cset shield --reset
-      - name: Run Base Benchmarks
-        run: |
-          sudo cset shield -c 2-3 -k on
-          sudo mount -t tmpfs -o size=4g none ~/benchmarks
-          cp -rf base/build ~/benchmarks/build
-          cp -rf base/lib ~/benchmarks/lib
-          mkdir -p ~/benchmarks/test
-          cp -rf base/test/data ~/benchmarks/test/data
-          cp -rf base/profiles ~/benchmarks/profiles
-
-          # TODO: remove it when base branch will have this file at needed location
-          if [ ! -f ~/benchmarks/test/data/portugal_to_korea.json ]; then
-            cp base/src/benchmarks/portugal_to_korea.json ~/benchmarks/test/data/portugal_to_korea.json
-          fi
-          # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
-          sudo cset shield --exec -- cset shield --exec -- ./pr/scripts/ci/run_benchmarks.sh -f ~/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b ~/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount ~/benchmarks
-          sudo cset shield --reset
+          ./pr/scripts/ci/run_benchmarks.sh base pr
       - name: Post Benchmark Results
         run: |
           python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
@@ -780,7 +734,6 @@ jobs:
 
   ci-complete:
     runs-on: ubuntu-22.04
-    needs: [build-test-publish, docker-image-matrix, windows-release-node, benchmarks]
+    needs: [build-test-publish, docker-image, windows-release-node, benchmarks]
     steps:
     - run: echo "CI complete"
-

.github/workflows/stale.yml

@@ -1,29 +0,0 @@
-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'
-
-  
-

.gitignore

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

CHANGELOG.md

@@ -1,7 +1,6 @@
 # Unreleased
   - Changes from 5.27.1
     - Features
-      - ADDED: Route pedestrians over highway=platform [#6993](https://github.com/Project-OSRM/osrm-backend/pull/6993)
       - REMOVED: Remove all core-CH left-overs [#6920](https://github.com/Project-OSRM/osrm-backend/pull/6920)
       - ADDED: Add support for a keepalive_timeout flag. [#6674](https://github.com/Project-OSRM/osrm-backend/pull/6674)
       - ADDED: Add support for a default_radius flag. [#6575](https://github.com/Project-OSRM/osrm-backend/pull/6575)
@@ -25,25 +24,6 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
-      - CHANGED: Use std::string_view for key type in json::Object. [#7062](https://github.com/Project-OSRM/osrm-backend/pull/7062)
-      - CHANGED: Use thread_local instead of boost::thread_specific_ptr. [#6991](https://github.com/Project-OSRM/osrm-backend/pull/6991)
-      - CHANGED: Bump flatbuffers to v24.3.25 version. [#6988](https://github.com/Project-OSRM/osrm-backend/pull/6988)
-      - CHANGED: Add .reserve(...) to assembleGeometry function. [#6983](https://github.com/Project-OSRM/osrm-backend/pull/6983)
-      - CHANGED: Get rid of boost::optional leftovers. [#6977](https://github.com/Project-OSRM/osrm-backend/pull/6977)
-      - CHANGED: Use Link Time Optimisation whenever possible. [#6967](https://github.com/Project-OSRM/osrm-backend/pull/6967)
-      - CHANGED: Use struct instead of tuple to define UnpackedPath. [#6974](https://github.com/Project-OSRM/osrm-backend/pull/6974)
-      - CHANGED: Micro performance optimisation in map matching. [#6976](https://github.com/Project-OSRM/osrm-backend/pull/6976)
-      - CHANGED: Re-use priority queue in StaticRTree. [#6952](https://github.com/Project-OSRM/osrm-backend/pull/6952)
-      - CHANGED: Optimise encodePolyline function. [#6940](https://github.com/Project-OSRM/osrm-backend/pull/6940)
-      - CHANGED: Avoid reallocations in base64 encoding. [#6951](https://github.com/Project-OSRM/osrm-backend/pull/6951)
-      - 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)
@@ -57,7 +37,6 @@
       - 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)
@@ -80,7 +59,6 @@
       - ADDED: Extract prerelease/build information from package semver [#6839](https://github.com/Project-OSRM/osrm-backend/pull/6839)
     - Profiles:
       - FIXED: Bicycle and foot profiles now don't route on proposed ways [#6615](https://github.com/Project-OSRM/osrm-backend/pull/6615)
-      - ADDED: Add optional support of cargo bike exclusion and width to bicyle profile [#7044](https://github.com/Project-OSRM/osrm-backend/pull/7044)
     - Routing:
       - FIXED: Fix adding traffic signal penalties during compression [#6419](https://github.com/Project-OSRM/osrm-backend/pull/6419)
       - FIXED: Correctly handle compressed traffic signals. [#6724](https://github.com/Project-OSRM/osrm-backend/pull/6724)

CMakeLists.txt

@@ -31,12 +31,11 @@ option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
 option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
 option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
-option(ENABLE_LTO "Use Link Time Optimisation" ON)
+option(ENABLE_LTO "Use LTO if available" OFF)
 option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
 option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
 option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
 
-
 if (ENABLE_CLANG_TIDY)
   find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
   if(NOT CLANG_TIDY_COMMAND)
@@ -56,23 +55,8 @@ endif()
 if (POLICY CMP0074)
   cmake_policy(SET CMP0074 NEW)
 endif()
-if (POLICY CMP0167)
-  cmake_policy(SET CMP0167 NEW)
-endif()
 project(OSRM C CXX)
 
-
-if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
-  if(LTO_SUPPORTED)
-      message(STATUS "IPO / LTO enabled")
-      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-  else()
-      message(FATAL_ERROR "IPO / LTO not supported: <${error}>")
-  endif()
-endif()
-
 # add @loader_path/$ORIGIN to rpath to make binaries relocatable
 if (APPLE)
   set(CMAKE_BUILD_RPATH "@loader_path")
@@ -136,10 +120,9 @@ endif()
 
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/generated/include/)
 include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)
 
-set(BOOST_COMPONENTS date_time iostreams program_options thread unit_test_framework)
+set(BOOST_COMPONENTS date_time chrono filesystem iostreams program_options regex system thread unit_test_framework)
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/include/util/version.hpp.in
@@ -225,6 +208,17 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -ggdb")
 endif()
 
+if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
+  if(LTO_SUPPORTED)
+      message(STATUS "IPO / LTO enabled")
+      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  else()
+      message(WARNING "IPO / LTO not supported: <${error}>")
+  endif()
+endif()
+
 set(MAYBE_COVERAGE_LIBRARIES "")
 if (ENABLE_COVERAGE)
   if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
@@ -296,7 +290,6 @@ include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})
 
 add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
 set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
-
 target_no_warning(MICROTAR unused-variable)
 target_no_warning(MICROTAR format)
 
@@ -337,12 +330,20 @@ if(ENABLE_CONAN)
 
   set(CONAN_BOOST_VERSION "1.85.0@#14265ec82b25d91305bbb3b30d3357f8")
   set(CONAN_BZIP2_VERSION "1.0.8@#d1b2d5816f25865acf978501dff1f897")
-  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_EXPAT_VERSION "2.2.10@#916908d4a570ad839edd25322c3268cd")
+  set(CONAN_LUA_VERSION "5.4.4@#3ec62efc37cd0a5d80b9e5cb35277360")
+  set(CONAN_TBB_VERSION "2021.3.0@#507ec17cbd51a84167e143b20d170eea")
 
   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
@@ -355,7 +356,9 @@ 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:without_stacktrace=True # Apple Silicon cross-compilation fails without it
+    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
     BUILD missing
   )
 
@@ -384,10 +387,14 @@ 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}")
 
 
@@ -460,6 +467,7 @@ 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_)
@@ -469,8 +477,11 @@ 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_THREAD_LIBRARY}
+   ${Boost_SYSTEM_LIBRARY})
 
 set(BOOST_ENGINE_LIBRARIES
   ${Boost_ZLIB_LIBRARY}
@@ -489,6 +500,7 @@ endif()
 
 set(EXTRACTOR_LIBRARIES
     ${BZIP2_LIBRARIES}
+    ${Boost_REGEX_LIBRARY}
     ${BOOST_BASE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     ${EXPAT_LIBRARIES}

cmake/warnings.cmake

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

docker/Dockerfile

@@ -1 +0,0 @@
-Dockerfile-debian

docker/Dockerfile

@@ -0,0 +1,68 @@
+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" && \
+    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: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-regex1.81.0 \
+        libboost-date-time1.81.0 libboost-chrono1.81.0 libboost-filesystem1.81.0 \
+        libboost-iostreams1.81.0 libboost-system1.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

docker/Dockerfile-alpine

@@ -1,79 +0,0 @@
-FROM alpine:3.21.2 AS alpine-mimalloc
-
-RUN apk update && \
-    apk upgrade && \
-    apk add --no-cache \
-        boost-iostreams \
-        boost-program_options \
-        boost-thread \
-        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 /opt && \
-    apk add --no-cache \
-    boost-dev \
-    boost-filesystem \
-    clang \
-    cmake \
-    expat-dev \
-    git \
-    libbz2 \
-    libxml2 \
-    lua5.4-dev \
-    make \
-    onetbb-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" && \
-    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=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/build/building/multi-stage/#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-date_time \
-    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
-

docker/Dockerfile-debian

@@ -1,76 +0,0 @@
-FROM debian:bookworm-slim AS builder
-ARG DOCKER_TAG
-ARG BUILD_CONCURRENCY
-
-RUN mkdir -p /src /opt && \
-    apt-get update && \
-    apt-get -y --no-install-recommends --no-install-suggests install \
-        ca-certificates \
-        cmake \
-        g++ \
-        gcc \
-        git \
-        libboost1.81-all-dev \
-        libbz2-dev \
-        liblua5.4-dev \
-        libtbb-dev \
-        libxml2-dev \
-        libzip-dev \
-        lua5.4 \
-        make \
-        pkg-config
-
-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" && \
-    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/build/building/multi-stage/#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 --no-install-suggests \
-        expat \
-        libboost-date-time1.81.0 \
-        libboost-iostreams1.81.0 \
-        libboost-program-options1.81.0 \
-        libboost-thread1.81.0 \
-        liblua5.4-0 \
-        libtbb12 && \
-    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
-

docker/hooks/build

@@ -6,8 +6,4 @@
 # 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="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 ..
+docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..

features/foot/access.feature

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

features/guidance/collapse.feature

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

features/guidance/roundabout-left-sided.feature

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

features/options/contract/help.feature

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

features/options/customize/help.feature

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

features/options/datastore/datastore.feature

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

features/options/extract/help.feature

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

features/options/partition/help.feature

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

features/options/routed/help.feature

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

features/support/env.js

@@ -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.1;
+        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.0;
 
         this.HOST = `http://${this.OSRM_IP}:${this.OSRM_PORT}`;
 

features/testbot/loop.feature

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

features/testbot/matching.feature

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

features/testbot/snap_intersection.feature

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

features/testbot/via.feature

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

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

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

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

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

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

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

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

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

include/contractor/contractor_config.hpp

@@ -31,7 +31,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/io_config.hpp"
 #include "updater/updater_config.hpp"
 
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
+
 #include <string>
 
 namespace osrm::contractor
@@ -46,7 +47,7 @@ struct ContractorConfig final : storage::IOConfig
     }
 
     // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
         updater_config.UseDefaultOutputNames(base);

include/contractor/files.hpp

@@ -9,7 +9,7 @@ namespace osrm::contractor::files
 {
 // reads .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void readGraph(const std::filesystem::path &path,
+inline void readGraph(const boost::filesystem::path &path,
                       std::unordered_map<std::string, ContractedMetricT> &metrics,
                       std::uint32_t &connectivity_checksum)
 {
@@ -30,7 +30,7 @@ inline void readGraph(const std::filesystem::path &path,
 
 // writes .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void writeGraph(const std::filesystem::path &path,
+inline void writeGraph(const boost::filesystem::path &path,
                        const std::unordered_map<std::string, ContractedMetricT> &metrics,
                        const std::uint32_t connectivity_checksum)
 {

include/customizer/customizer_config.hpp

@@ -1,8 +1,9 @@
 #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"
@@ -26,7 +27,7 @@ struct CustomizationConfig final : storage::IOConfig
     {
     }
 
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
         updater_config.UseDefaultOutputNames(base);

include/customizer/edge_based_graph.hpp

@@ -9,7 +9,7 @@
 
 #include "storage/shared_memory_ownership.hpp"
 
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
 
 namespace osrm::customizer
 {

include/customizer/files.hpp

@@ -14,7 +14,7 @@ namespace osrm::customizer::files
 
 // reads .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void readCellMetrics(const std::filesystem::path &path,
+inline void readCellMetrics(const boost::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 std::filesystem::path &path,
 // writes .osrm.cell_metrics file
 template <typename CellMetricT>
 inline void
-writeCellMetrics(const std::filesystem::path &path,
+writeCellMetrics(const boost::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 std::filesystem::path &path,
 
 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const std::filesystem::path &path,
+inline void readGraph(const boost::filesystem::path &path,
                       MultiLevelGraphT &graph,
                       std::uint32_t &connectivity_checksum)
 {
@@ -88,7 +88,7 @@ inline void readGraph(const std::filesystem::path &path,
 
 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const std::filesystem::path &path,
+inline void writeGraph(const boost::filesystem::path &path,
                        const MultiLevelGraphT &graph,
                        const std::uint32_t connectivity_checksum)
 {

include/engine/api/base_parameters.hpp

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

include/engine/api/flatbuffers/fbresult.fbs

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

include/engine/api/flatbuffers/table.fbs

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

include/engine/api/json_factory.hpp

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

include/engine/api/match_api.hpp

@@ -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.emplace("confidence", sub_matchings[index].confidence);
-            routes.values.emplace_back(std::move(route));
+            route.values["confidence"] = sub_matchings[index].confidence;
+            routes.values.push_back(std::move(route));
         }
         if (!parameters.skip_waypoints)
         {
-            response.values.emplace("tracepoints", MakeTracepoints(sub_matchings));
+            response.values["tracepoints"] = MakeTracepoints(sub_matchings);
         }
-        response.values.emplace("matchings", std::move(routes));
-        response.values.emplace("code", "Ok");
+        response.values["matchings"] = std::move(routes);
+        response.values["code"] = "Ok";
         auto data_timestamp = facade.GetTimestamp();
         if (!data_timestamp.empty())
         {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
         }
     }
 
@@ -132,13 +132,13 @@ class MatchAPI final : public RouteAPI
 
             if (tidy_result.can_be_removed[trace_index])
             {
-                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
                 continue;
             }
             auto matching_index = trace_idx_to_matching_idx[trace_index];
             if (matching_index.NotMatched())
             {
-                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.push_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.emplace_back(waypoint->Finish());
+            waypoints.push_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.emplace_back(util::json::Null());
+                waypoints.values.push_back(util::json::Null());
                 continue;
             }
             auto matching_index = trace_idx_to_matching_idx[trace_index];
             if (matching_index.NotMatched())
             {
-                waypoints.values.emplace_back(util::json::Null());
+                waypoints.values.push_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.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.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 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.emplace_back(std::move(waypoint));
+            waypoints.values.push_back(std::move(waypoint));
         }
 
         return waypoints;

include/engine/api/nearest_api.hpp

@@ -45,7 +45,7 @@ class NearestAPI final : public BaseAPI
                       flatbuffers::FlatBufferBuilder &fb_result) const
     {
         auto data_timestamp = facade.GetTimestamp();
-        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
+        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
         if (!data_timestamp.empty())
         {
             data_version_string = fb_result.CreateString(data_timestamp);
@@ -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.emplace_back(node_values.first);
-                               nodes.values.emplace_back(node_values.second);
-                               waypoint.values.emplace("nodes", std::move(nodes));
+                               nodes.values.push_back(node_values.first);
+                               nodes.values.push_back(node_values.second);
+                               waypoint.values["nodes"] = std::move(nodes);
+
                                return waypoint;
                            });
-            response.values.emplace("waypoints", std::move(waypoints));
+            response.values["waypoints"] = std::move(waypoints);
         }
 
-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
         auto data_timestamp = facade.GetTimestamp();
         if (!data_timestamp.empty())
         {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
         }
     }
 

include/engine/api/route_api.hpp

@@ -110,14 +110,14 @@ class RouteAPI : public BaseAPI
 
         if (!parameters.skip_waypoints)
         {
-            response.values.emplace("waypoints", BaseAPI::MakeWaypoints(waypoint_candidates));
+            response.values["waypoints"] = BaseAPI::MakeWaypoints(waypoint_candidates);
         }
-        response.values.emplace("routes", std::move(jsRoutes));
-        response.values.emplace("code", "Ok");
+        response.values["routes"] = std::move(jsRoutes);
+        response.values["code"] = "Ok";
         auto data_timestamp = facade.GetTimestamp();
         if (!data_timestamp.empty())
         {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
         }
     }
 
@@ -184,10 +184,10 @@ class RouteAPI : public BaseAPI
         return builder.CreateVectorOfStructs(coordinates);
     }
 
-    std::optional<util::json::Value>
-    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
+    boost::optional<util::json::Value>
+    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
     {
-        std::optional<util::json::Value> json_geometry;
+        boost::optional<util::json::Value> json_geometry;
         if (annotations)
         {
             auto begin = annotations->begin();
@@ -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
@@ -716,11 +716,12 @@ 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);
-        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));
+        boost::optional<util::json::Value> json_overview =
+            MakeGeometry(MakeOverview(leg_geometries));
 
         std::vector<util::json::Value> step_geometries;
         const auto total_step_count =
@@ -783,57 +784,49 @@ class RouteAPI : public BaseAPI
                 if (requested_annotations & RouteParameters::AnnotationsType::Speed)
                 {
                     double prev_speed = 0;
-                    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);
-                                           }
-                                       }));
+                    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);
+                            }
+                        });
                 }
 
                 if (requested_annotations & RouteParameters::AnnotationsType::Duration)
                 {
-                    annotation.values.emplace(
-                        "duration",
+                    annotation.values["duration"] =
                         GetAnnotations(leg_geometry,
                                        [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.duration; }));
+                                       { return anno.duration; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Distance)
                 {
-                    annotation.values.emplace(
-                        "distance",
+                    annotation.values["distance"] =
                         GetAnnotations(leg_geometry,
                                        [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.distance; }));
+                                       { return anno.distance; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Weight)
                 {
-                    annotation.values.emplace(
-                        "weight",
-                        GetAnnotations(leg_geometry,
-                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.weight; }));
+                    annotation.values["weight"] = GetAnnotations(
+                        leg_geometry,
+                        [](const guidance::LegGeometry::Annotation &anno) { return anno.weight; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
                 {
-                    annotation.values.emplace(
-                        "datasources",
+                    annotation.values["datasources"] =
                         GetAnnotations(leg_geometry,
                                        [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.datasource; }));
+                                       { return anno.datasource; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
                 {
@@ -844,7 +837,7 @@ class RouteAPI : public BaseAPI
                         nodes.values.push_back(
                             static_cast<std::uint64_t>(facade.GetOSMNodeIDOfNode(node_id)));
                     }
-                    annotation.values.emplace("nodes", std::move(nodes));
+                    annotation.values["nodes"] = std::move(nodes);
                 }
                 // Add any supporting metadata, if needed
                 if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
@@ -860,8 +853,8 @@ class RouteAPI : public BaseAPI
                             break;
                         datasource_names.values.push_back(std::string(facade.GetDatasourceName(i)));
                     }
-                    metadata.values.emplace("datasource_names", datasource_names);
-                    annotation.values.emplace("metadata", metadata);
+                    metadata.values["datasource_names"] = datasource_names;
+                    annotation.values["metadata"] = metadata;
                 }
 
                 annotations.push_back(std::move(annotation));
@@ -996,10 +989,10 @@ class RouteAPI : public BaseAPI
         return result;
     }
 
-    std::optional<std::vector<Coordinate>>
+    boost::optional<std::vector<Coordinate>>
     MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
     {
-        std::optional<std::vector<Coordinate>> overview;
+        boost::optional<std::vector<Coordinate>> overview;
         if (parameters.overview != RouteParameters::OverviewType::False)
         {
             const auto use_simplification =

include/engine/api/route_parameters.hpp

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

include/engine/api/table_api.hpp

@@ -137,7 +137,7 @@ class TableAPI final : public BaseAPI
             speed_cells = MakeEstimatesTable(fb_result, fallback_speed_cells);
         }
 
-        fbresult::TableResultBuilder table(fb_result);
+        fbresult::TableBuilder table(fb_result);
         table.add_destinations(destinations);
         table.add_rows(number_of_sources);
         table.add_cols(number_of_destinations);
@@ -179,7 +179,7 @@ class TableAPI final : public BaseAPI
         {
             if (!parameters.skip_waypoints)
             {
-                response.values.emplace("sources", MakeWaypoints(candidates));
+                response.values["sources"] = MakeWaypoints(candidates);
             }
             number_of_sources = candidates.size();
         }
@@ -187,7 +187,7 @@ class TableAPI final : public BaseAPI
         {
             if (!parameters.skip_waypoints)
             {
-                response.values.emplace("sources", MakeWaypoints(candidates, parameters.sources));
+                response.values["sources"] = MakeWaypoints(candidates, parameters.sources);
             }
         }
 
@@ -195,7 +195,7 @@ class TableAPI final : public BaseAPI
         {
             if (!parameters.skip_waypoints)
             {
-                response.values.emplace("destinations", MakeWaypoints(candidates));
+                response.values["destinations"] = MakeWaypoints(candidates);
             }
             number_of_destinations = candidates.size();
         }
@@ -203,37 +203,34 @@ class TableAPI final : public BaseAPI
         {
             if (!parameters.skip_waypoints)
             {
-                response.values.emplace("destinations",
-                                        MakeWaypoints(candidates, parameters.destinations));
+                response.values["destinations"] =
+                    MakeWaypoints(candidates, parameters.destinations);
             }
         }
 
         if (parameters.annotations & TableParameters::AnnotationsType::Duration)
         {
-            response.values.emplace(
-                "durations",
-                MakeDurationTable(tables.first, number_of_sources, number_of_destinations));
+            response.values["durations"] =
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
         }
 
         if (parameters.annotations & TableParameters::AnnotationsType::Distance)
         {
-            response.values.emplace(
-                "distances",
-                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations));
+            response.values["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.emplace("fallback_speed_cells",
-                                    MakeEstimatesTable(fallback_speed_cells));
+            response.values["fallback_speed_cells"] = MakeEstimatesTable(fallback_speed_cells);
         }
 
-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
         auto data_timestamp = facade.GetTimestamp();
         if (!data_timestamp.empty())
         {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
         }
     }
 

include/engine/api/trip_api.hpp

@@ -79,14 +79,14 @@ class TripAPI final : public RouteAPI
         }
         if (!parameters.skip_waypoints)
         {
-            response.values.emplace("waypoints", MakeWaypoints(sub_trips, candidates));
+            response.values["waypoints"] = MakeWaypoints(sub_trips, candidates);
         }
-        response.values.emplace("trips", std::move(routes));
-        response.values.emplace("code", "Ok");
+        response.values["trips"] = std::move(routes);
+        response.values["code"] = "Ok";
         auto data_timestamp = facade.GetTimestamp();
         if (!data_timestamp.empty())
         {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["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.emplace("trips_index", trip_index.sub_trip_index);
-            waypoint.values.emplace("waypoint_index", trip_index.point_index);
+            waypoint.values["trips_index"] = trip_index.sub_trip_index;
+            waypoint.values["waypoint_index"] = trip_index.point_index;
             waypoints.values.push_back(std::move(waypoint));
         }
 

include/engine/api/trip_parameters.hpp

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

include/engine/base64.hpp

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

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -177,7 +177,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     SharedRTree m_static_rtree;
     std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
-    std::filesystem::path file_index_path;
+    boost::filesystem::path file_index_path;
 
     std::optional<extractor::IntersectionBearingsView> intersection_bearings_view;
 
@@ -369,7 +369,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                                const double max_distance,
-                               const std::optional<Bearing> bearing,
+                               const boost::optional<Bearing> bearing,
                                const Approach approach,
                                const bool use_all_edges) const override final
     {
@@ -382,20 +382,20 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate input_coordinate,
                         const size_t max_results,
-                        const std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing,
                         const Approach approach) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
         return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, max_results, max_distance, bearing, std::nullopt);
+            input_coordinate, approach, max_results, max_distance, bearing, boost::none);
     }
 
     PhantomCandidateAlternatives
     NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<double> max_distance,
+                                                     const boost::optional<Bearing> bearing,
                                                      const Approach approach,
                                                      const bool use_all_edges) const override final
     {
@@ -603,8 +603,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         auto found_range = std::equal_range(
             m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});
 
-        results.reserve(std::distance(found_range.first, found_range.second));
-
         std::for_each(found_range.first,
                       found_range.second,
                       [&](const auto &override)

include/engine/datafacade/datafacade_base.hpp

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

include/engine/engine_config.hpp

@@ -31,7 +31,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/storage_config.hpp"
 #include "osrm/datasets.hpp"
 
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
+
 #include <set>
 #include <string>
 
@@ -79,10 +80,10 @@ struct EngineConfig final
     int max_locations_map_matching = -1;
     double max_radius_map_matching = -1.0;
     int max_results_nearest = -1;
-    double default_radius = -1.0;
+    boost::optional<double> default_radius = -1.0;
     int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
     bool use_shared_memory = true;
-    std::filesystem::path memory_file;
+    boost::filesystem::path memory_file;
     bool use_mmap = true;
     Algorithm algorithm = Algorithm::CH;
     std::vector<storage::FeatureDataset> disable_feature_dataset;

include/engine/geospatial_query.hpp

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

include/engine/guidance/assemble_geometry.hpp

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

include/engine/guidance/assemble_steps.hpp

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

include/engine/guidance/collapsing_utility.hpp

@@ -202,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];

include/engine/guidance/route_leg.hpp

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

include/engine/internal_route_result.hpp

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

include/engine/phantom_node.hpp

@@ -214,7 +214,7 @@ struct PhantomNode
     util::Coordinate input_location;
     unsigned short fwd_segment_position;
     // is phantom node valid to be used as source or target
-  private:
+    // private:
     unsigned short is_valid_forward_source : 1;
     unsigned short is_valid_forward_target : 1;
     unsigned short is_valid_reverse_source : 1;

include/engine/plugins/match.hpp

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

include/engine/plugins/nearest.hpp

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

include/engine/plugins/plugin_base.hpp

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

include/engine/plugins/table.hpp

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

include/engine/plugins/trip.hpp

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

include/engine/plugins/viaroute.hpp

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

include/engine/polyline_compressor.hpp

@@ -12,7 +12,7 @@ namespace osrm::engine
 {
 namespace detail
 {
-void encode(int number_to_encode, std::string &output);
+std::string encode(std::vector<int> &numbers);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                      std::string::const_iterator last);
 } // namespace detail
@@ -30,24 +30,27 @@ std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter
         return {};
     }
 
-    std::string output;
-    // just a guess that we will need ~4 bytes per coordinate to avoid reallocations
-    output.reserve(size * 4);
-
+    std::vector<int> delta_numbers;
+    BOOST_ASSERT(size > 0);
+    delta_numbers.reserve((size - 1) * 2);
     int current_lat = 0;
     int current_lon = 0;
-    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;
+    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);
 }
 
 // Decodes geometry from polyline format

include/engine/routing_algorithms.hpp

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

include/engine/routing_algorithms/map_matching.hpp

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

include/engine/routing_algorithms/routing_base.hpp

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

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -471,6 +471,23 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                           const PhantomNode &target_phantom,
                           EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT);
 
+inline double getNetworkDistanceOld(SearchEngineData<Algorithm> &engine_working_data,
+                                    const DataFacade<ch::Algorithm> &facade,
+                                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                                    const PhantomNode &source_phantom,
+                                    const PhantomNode &target_phantom,
+                                    EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT)
+{
+    return getNetworkDistance(engine_working_data,
+                              facade,
+                              forward_heap,
+                              reverse_heap,
+                              source_phantom,
+                              target_phantom,
+                              duration_upper_bound);
+}
+
 template <typename EdgeMetric>
 std::tuple<EdgeMetric, EdgeDistance> getLoopMetric(const DataFacade<Algorithm> &facade, NodeID node)
 {

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -487,13 +487,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
 
 using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
-
-struct UnpackedPath
-{
-    EdgeWeight weight;
-    UnpackedNodes nodes;
-    UnpackedEdges edges;
-};
+using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
 
 template <typename Algorithm, typename Heap, typename... Args>
 std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
@@ -503,7 +497,7 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
                                                        EdgeWeight weight_upper_bound,
                                                        const Args &...args)
 {
-    if (forward_heap.Empty() || reverse_heap.Empty())
+    if (forward_heap.Empty() && reverse_heap.Empty())
     {
         return {};
     }
@@ -516,9 +510,19 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
     EdgeWeight weight = weight_upper_bound;
     EdgeWeight forward_heap_min = forward_heap.MinKey();
     EdgeWeight reverse_heap_min = reverse_heap.MinKey();
+// if (!reverse_heap.Empty())
+//     reverse_heap_min = reverse_heap.MinKey();
+#if 0
+    while (forward_heap.Size() + reverse_heap.Size() > 0 && (
+           forward_heap_min < weight || reverse_heap_min < weight))
+#else
     while (forward_heap.Size() + reverse_heap.Size() > 0 &&
-           forward_heap_min + reverse_heap_min < weight)
+           (forward_heap_min + reverse_heap_min < weight))
+#endif
     {
+        // std::cerr << "F: " << forward_heap_min << " R: " << reverse_heap_min << " W: " << weight
+        // << std::endl;
+
         if (!forward_heap.Empty())
         {
             routingStep<FORWARD_DIRECTION>(
@@ -535,12 +539,21 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
         }
     };
 
+    // while (!reverse_heap.Empty() && (reverse_heap_min < weight)) {
+    //     routingStep<REVERSE_DIRECTION>(
+    //         facade, reverse_heap, forward_heap, middle, weight, force_step_nodes, args...);
+    //     if (!reverse_heap.Empty())
+    //         reverse_heap_min = reverse_heap.MinKey();
+    // }
+
     // No path found for both target nodes?
     if (weight >= weight_upper_bound || SPECIAL_NODEID == middle)
     {
         return {};
     }
 
+    std::cerr << "MIDDLE = " << middle << std::endl;
+
     return {{middle, weight}};
 }
 
@@ -557,7 +570,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
         facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
     if (!searchResult)
     {
-        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
+        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
     }
 
     auto [middle, weight] = *searchResult;
@@ -601,27 +614,25 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
             forward_heap.Insert(source, {0}, {source});
             reverse_heap.Insert(target, {0}, {target});
 
-            auto unpacked_subpath = search(engine_working_data,
-                                           facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           force_step_nodes,
-                                           INVALID_EDGE_WEIGHT,
-                                           sublevel,
-                                           parent_cell_id);
-            BOOST_ASSERT(!unpacked_subpath.edges.empty());
-            BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
-            BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
-            BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
-            unpacked_nodes.insert(unpacked_nodes.end(),
-                                  std::next(unpacked_subpath.nodes.begin()),
-                                  unpacked_subpath.nodes.end());
-            unpacked_edges.insert(
-                unpacked_edges.end(), unpacked_subpath.edges.begin(), unpacked_subpath.edges.end());
+            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
+                                                                         facade,
+                                                                         forward_heap,
+                                                                         reverse_heap,
+                                                                         force_step_nodes,
+                                                                         INVALID_EDGE_WEIGHT,
+                                                                         sublevel,
+                                                                         parent_cell_id);
+            BOOST_ASSERT(!subpath_edges.empty());
+            BOOST_ASSERT(subpath_nodes.size() > 1);
+            BOOST_ASSERT(subpath_nodes.front() == source);
+            BOOST_ASSERT(subpath_nodes.back() == target);
+            unpacked_nodes.insert(
+                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
+            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
         }
     }
 
-    return {weight, std::move(unpacked_nodes), std::move(unpacked_edges)};
+    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
 }
 
 template <typename Algorithm, typename... Args>
@@ -642,8 +653,8 @@ searchDistance(SearchEngineData<Algorithm> &,
         return INVALID_EDGE_DISTANCE;
     }
 
-    auto [middle, _] = *searchResult;
-
+    auto [middle, weight] = *searchResult;
+    // std::cerr << "W: " << weight << std::endl;
     auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance;
 
     return distance;
@@ -662,15 +673,13 @@ inline void search(SearchEngineData<Algorithm> &engine_working_data,
                    const EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
     // TODO: change search calling interface to use unpacked_edges result
-    auto unpacked_path = search(engine_working_data,
-                                facade,
-                                forward_heap,
-                                reverse_heap,
-                                force_step_nodes,
-                                weight_upper_bound,
-                                endpoints);
-    weight = unpacked_path.weight;
-    unpacked_nodes = std::move(unpacked_path.nodes);
+    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
+                                                           facade,
+                                                           forward_heap,
+                                                           reverse_heap,
+                                                           force_step_nodes,
+                                                           weight_upper_bound,
+                                                           endpoints);
 }
 
 // TODO: refactor CH-related stub to use unpacked_edges
@@ -714,41 +723,148 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                           const PhantomNode &target_phantom,
                           EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
-    forward_heap.Clear();
     reverse_heap.Clear();
+    // forward_heap.Clear();
+
+    // if (forward_heap.Empty())
+    // {
+    //     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()});
+    //     }
+
+    //     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()});
+    //     }
+    // } else {
+    //     const auto node =
+    //     forward_heap.GetHeapNodeIfWasInserted(target_phantom.forward_segment_id.id); if (node) {
+    //         std::cerr << "Found " << target_phantom.forward_segment_id.id << " in forward_heap "
+    //         << node->data.distance <<  std::endl;
+    //     }
+    // }
+
+    //  forward_heap.Clear();
+    if (forward_heap.Empty())
+    {
+        if (source_phantom.IsValidForwardSource())
+        {
+            forward_heap.Insert(source_phantom.forward_segment_id.id,
+                                EdgeWeight{0},
+                                {source_phantom.forward_segment_id.id, false, EdgeDistance{0}});
+        }
+
+        if (source_phantom.IsValidReverseSource())
+        {
+            forward_heap.Insert(source_phantom.reverse_segment_id.id,
+                                EdgeWeight{0},
+                                {source_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
+        }
+    }
+    else
+    {
+        if (target_phantom.IsValidForwardTarget())
+        {
+            if (forward_heap.WasInserted(target_phantom.forward_segment_id.id))
+            {
+                std::cerr << "Found " << target_phantom.forward_segment_id.id << " in forward_heap"
+                          << std::endl;
+            }
+            else
+            {
+                std::cerr << "Not found " << target_phantom.forward_segment_id.id
+                          << " in forward_heap" << std::endl;
+            }
+        }
+        if (target_phantom.IsValidReverseTarget())
+        {
+            if (forward_heap.WasInserted(target_phantom.reverse_segment_id.id))
+            {
+                std::cerr << "Found " << target_phantom.reverse_segment_id.id << " in forward_heap"
+                          << std::endl;
+            }
+            else
+            {
+                std::cerr << "Not found " << target_phantom.reverse_segment_id.id
+                          << " in forward_heap" << std::endl;
+            }
+        }
+    }
+
+    if (target_phantom.IsValidForwardTarget())
+    {
+        reverse_heap.Insert(target_phantom.forward_segment_id.id,
+                            EdgeWeight{0},
+                            {target_phantom.forward_segment_id.id, false, EdgeDistance{0}});
+    }
+
+    if (target_phantom.IsValidReverseTarget())
+    {
+        reverse_heap.Insert(target_phantom.reverse_segment_id.id,
+                            EdgeWeight{0},
+                            {target_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
+    }
+
+    const PhantomEndpoints endpoints{source_phantom, target_phantom};
+
+    auto distance = searchDistance(
+        engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);
+
+    if (distance == INVALID_EDGE_DISTANCE)
+    {
+        return std::numeric_limits<double>::max();
+    }
+    return from_alias<double>(distance);
+}
+
+template <typename Algorithm>
+double
+getNetworkDistanceOld(SearchEngineData<Algorithm> &engine_working_data,
+                      const DataFacade<Algorithm> &facade,
+                      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)
+{
+    reverse_heap.Clear();
+    forward_heap.Clear();
 
     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()});
+                            EdgeWeight{0},
+                            {source_phantom.forward_segment_id.id, false, EdgeDistance{0}});
     }
 
     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()});
+                            EdgeWeight{0},
+                            {source_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
     }
 
     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()});
+        reverse_heap.Insert(target_phantom.forward_segment_id.id,
+                            EdgeWeight{0},
+                            {target_phantom.forward_segment_id.id, false, EdgeDistance{0}});
     }
 
     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()});
+        reverse_heap.Insert(target_phantom.reverse_segment_id.id,
+                            EdgeWeight{0},
+                            {target_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
     }
 
     const PhantomEndpoints endpoints{source_phantom, target_phantom};

include/engine/routing_algorithms/shortest_path.hpp

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

include/engine/routing_algorithms/shortest_path_impl.hpp

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

include/engine/search_engine_data.hpp

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

include/extractor/extractor_config.hpp

@@ -28,12 +28,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTOR_CONFIG_HPP
 #define EXTRACTOR_CONFIG_HPP
 
-#include "storage/io_config.hpp"
+#include <boost/filesystem/path.hpp>
 
 #include <array>
-#include <filesystem>
 #include <string>
 
+#include "storage/io_config.hpp"
+
 namespace osrm::extractor
 {
 
@@ -70,14 +71,14 @@ struct ExtractorConfig final : storage::IOConfig
     {
     }
 
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
     }
 
-    std::filesystem::path input_path;
-    std::filesystem::path profile_path;
-    std::vector<std::filesystem::path> location_dependent_data_paths;
+    boost::filesystem::path input_path;
+    boost::filesystem::path profile_path;
+    std::vector<boost::filesystem::path> location_dependent_data_paths;
     std::string data_version;
 
     unsigned requested_num_threads = 0;

include/extractor/files.hpp

@@ -23,9 +23,9 @@ namespace osrm::extractor::files
 
 // writes the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-void writeIntersections(const std::filesystem::path &path,
-                        const IntersectionBearingsT &intersection_bearings,
-                        const EntryClassVectorT &entry_classes)
+inline void writeIntersections(const boost::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 @@ void writeIntersections(const std::filesystem::path &path,
 
 // read the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-void readIntersections(const std::filesystem::path &path,
-                       IntersectionBearingsT &intersection_bearings,
-                       EntryClassVectorT &entry_classes)
+inline void readIntersections(const boost::filesystem::path &path,
+                              IntersectionBearingsT &intersection_bearings,
+                              EntryClassVectorT &entry_classes)
 {
     static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                       std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@@ -54,7 +54,8 @@ void readIntersections(const std::filesystem::path &path,
 }
 
 // reads .osrm.properties
-inline void readProfileProperties(const std::filesystem::path &path, ProfileProperties &properties)
+inline void readProfileProperties(const boost::filesystem::path &path,
+                                  ProfileProperties &properties)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -63,7 +64,7 @@ inline void readProfileProperties(const std::filesystem::path &path, ProfileProp
 }
 
 // writes .osrm.properties
-inline void writeProfileProperties(const std::filesystem::path &path,
+inline void writeProfileProperties(const boost::filesystem::path &path,
                                    const ProfileProperties &properties)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -73,7 +74,7 @@ inline void writeProfileProperties(const std::filesystem::path &path,
 }
 
 template <typename EdgeBasedEdgeVector>
-void writeEdgeBasedGraph(const std::filesystem::path &path,
+void writeEdgeBasedGraph(const boost::filesystem::path &path,
                          EdgeID const number_of_edge_based_nodes,
                          const EdgeBasedEdgeVector &edge_based_edge_list,
                          const std::uint32_t connectivity_checksum)
@@ -91,7 +92,7 @@ void writeEdgeBasedGraph(const std::filesystem::path &path,
 
 // reads .osrm.ebg file
 template <typename EdgeBasedEdgeVector>
-void readEdgeBasedGraph(const std::filesystem::path &path,
+void readEdgeBasedGraph(const boost::filesystem::path &path,
                         EdgeID &number_of_edge_based_nodes,
                         EdgeBasedEdgeVector &edge_based_edge_list,
                         std::uint32_t &connectivity_checksum)
@@ -107,9 +108,9 @@ void readEdgeBasedGraph(const std::filesystem::path &path,
 
 // reads .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-void readNodes(const std::filesystem::path &path,
-               CoordinatesT &coordinates,
-               PackedOSMIDsT &osm_node_ids)
+inline void readNodes(const boost::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, "");
@@ -123,7 +124,7 @@ void readNodes(const std::filesystem::path &path,
 
 // reads only coordinates from .osrm.nbg_nodes
 template <typename CoordinatesT>
-void readNodeCoordinates(const std::filesystem::path &path, CoordinatesT &coordinates)
+inline void readNodeCoordinates(const boost::filesystem::path &path, CoordinatesT &coordinates)
 {
     static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
 
@@ -135,9 +136,9 @@ void readNodeCoordinates(const std::filesystem::path &path, CoordinatesT &coordi
 
 // writes .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-void writeNodes(const std::filesystem::path &path,
-                const CoordinatesT &coordinates,
-                const PackedOSMIDsT &osm_node_ids)
+inline void writeNodes(const boost::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, "");
@@ -150,7 +151,7 @@ void writeNodes(const std::filesystem::path &path,
 }
 
 // reads .osrm.cnbg_to_ebg
-inline void readNBGMapping(const std::filesystem::path &path, std::vector<NBGToEBG> &mapping)
+inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -159,7 +160,8 @@ inline void readNBGMapping(const std::filesystem::path &path, std::vector<NBGToE
 }
 
 // writes .osrm.cnbg_to_ebg
-inline void writeNBGMapping(const std::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
+inline void writeNBGMapping(const boost::filesystem::path &path,
+                            const std::vector<NBGToEBG> &mapping)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -168,7 +170,7 @@ inline void writeNBGMapping(const std::filesystem::path &path, const std::vector
 }
 
 // reads .osrm.datasource_names
-inline void readDatasources(const std::filesystem::path &path, Datasources &sources)
+inline void readDatasources(const boost::filesystem::path &path, Datasources &sources)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -177,7 +179,7 @@ inline void readDatasources(const std::filesystem::path &path, Datasources &sour
 }
 
 // writes .osrm.datasource_names
-inline void writeDatasources(const std::filesystem::path &path, Datasources &sources)
+inline void writeDatasources(const boost::filesystem::path &path, Datasources &sources)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -187,7 +189,7 @@ inline void writeDatasources(const std::filesystem::path &path, Datasources &sou
 
 // reads .osrm.geometry
 template <typename SegmentDataT>
-void readSegmentData(const std::filesystem::path &path, SegmentDataT &segment_data)
+inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &segment_data)
 {
     static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                       std::is_same<SegmentDataView, SegmentDataT>::value,
@@ -200,7 +202,7 @@ void readSegmentData(const std::filesystem::path &path, SegmentDataT &segment_da
 
 // writes .osrm.geometry
 template <typename SegmentDataT>
-void writeSegmentData(const std::filesystem::path &path, const SegmentDataT &segment_data)
+inline void writeSegmentData(const boost::filesystem::path &path, const SegmentDataT &segment_data)
 {
     static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                       std::is_same<SegmentDataView, SegmentDataT>::value,
@@ -213,7 +215,7 @@ void writeSegmentData(const std::filesystem::path &path, const SegmentDataT &seg
 
 // reads .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void readNodeData(const std::filesystem::path &path, NodeDataT &node_data)
+inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_data)
 {
     static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                       std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@@ -227,7 +229,7 @@ inline void readNodeData(const std::filesystem::path &path, NodeDataT &node_data
 
 // writes .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void writeNodeData(const std::filesystem::path &path, const NodeDataT &node_data)
+inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &node_data)
 {
     static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                       std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@@ -241,7 +243,7 @@ inline void writeNodeData(const std::filesystem::path &path, const NodeDataT &no
 
 // reads .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void readTurnLaneDescriptions(const std::filesystem::path &path,
+inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
                                      OffsetsT &turn_offsets,
                                      MaskT &turn_masks)
 {
@@ -258,7 +260,7 @@ inline void readTurnLaneDescriptions(const std::filesystem::path &path,
 
 // writes .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void writeTurnLaneDescriptions(const std::filesystem::path &path,
+inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
                                       const OffsetsT &turn_offsets,
                                       const MaskT &turn_masks)
 {
@@ -275,7 +277,7 @@ inline void writeTurnLaneDescriptions(const std::filesystem::path &path,
 
 // reads .osrm.tld
 template <typename TurnLaneDataT>
-inline void readTurnLaneData(const std::filesystem::path &path, TurnLaneDataT &turn_lane_data)
+inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT &turn_lane_data)
 {
     static_assert(
         std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value,
@@ -289,7 +291,7 @@ inline void readTurnLaneData(const std::filesystem::path &path, TurnLaneDataT &t
 
 // writes .osrm.tld
 template <typename TurnLaneDataT>
-inline void writeTurnLaneData(const std::filesystem::path &path,
+inline void writeTurnLaneData(const boost::filesystem::path &path,
                               const TurnLaneDataT &turn_lane_data)
 {
     static_assert(
@@ -304,7 +306,7 @@ inline void writeTurnLaneData(const std::filesystem::path &path,
 
 // reads .osrm.timestamp
 template <typename TimestampDataT>
-inline void readTimestamp(const std::filesystem::path &path, TimestampDataT &timestamp)
+inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &timestamp)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -314,7 +316,7 @@ inline void readTimestamp(const std::filesystem::path &path, TimestampDataT &tim
 
 // writes .osrm.timestamp
 template <typename TimestampDataT>
-inline void writeTimestamp(const std::filesystem::path &path, const TimestampDataT &timestamp)
+inline void writeTimestamp(const boost::filesystem::path &path, const TimestampDataT &timestamp)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -324,7 +326,7 @@ inline void writeTimestamp(const std::filesystem::path &path, const TimestampDat
 
 // reads .osrm.maneuver_overrides
 template <typename StorageManeuverOverrideT, typename NodeSequencesT>
-inline void readManeuverOverrides(const std::filesystem::path &path,
+inline void readManeuverOverrides(const boost::filesystem::path &path,
                                   StorageManeuverOverrideT &maneuver_overrides,
                                   NodeSequencesT &node_sequences)
 {
@@ -338,7 +340,7 @@ inline void readManeuverOverrides(const std::filesystem::path &path,
 }
 
 // writes .osrm.maneuver_overrides
-inline void writeManeuverOverrides(const std::filesystem::path &path,
+inline void writeManeuverOverrides(const boost::filesystem::path &path,
                                    const std::vector<StorageManeuverOverride> &maneuver_overrides,
                                    const std::vector<NodeID> &node_sequences)
 {
@@ -353,7 +355,7 @@ inline void writeManeuverOverrides(const std::filesystem::path &path,
 
 // writes .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnWeightPenalty(const std::filesystem::path &path,
+inline void writeTurnWeightPenalty(const boost::filesystem::path &path,
                                    const TurnPenaltyT &turn_penalty)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -364,7 +366,7 @@ inline void writeTurnWeightPenalty(const std::filesystem::path &path,
 
 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnWeightPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -374,7 +376,7 @@ inline void readTurnWeightPenalty(const std::filesystem::path &path, TurnPenalty
 
 // writes .osrm.turn_duration_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnDurationPenalty(const std::filesystem::path &path,
+inline void writeTurnDurationPenalty(const boost::filesystem::path &path,
                                      const TurnPenaltyT &turn_penalty)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -385,7 +387,7 @@ inline void writeTurnDurationPenalty(const std::filesystem::path &path,
 
 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnDurationPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -395,7 +397,7 @@ inline void readTurnDurationPenalty(const std::filesystem::path &path, TurnPenal
 
 // writes .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void writeTurnPenaltiesIndex(const std::filesystem::path &path,
+inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,
                                     const TurnIndexT &turn_penalties_index)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -406,7 +408,7 @@ inline void writeTurnPenaltiesIndex(const std::filesystem::path &path,
 
 // read .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void readTurnPenaltiesIndex(const std::filesystem::path &path,
+inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,
                                    TurnIndexT &turn_penalties_index)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -417,7 +419,7 @@ inline void readTurnPenaltiesIndex(const std::filesystem::path &path,
 
 // writes .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void writeConditionalRestrictions(const std::filesystem::path &path,
+inline void writeConditionalRestrictions(const boost::filesystem::path &path,
                                          const ConditionalRestrictionsT &conditional_restrictions)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -428,7 +430,7 @@ inline void writeConditionalRestrictions(const std::filesystem::path &path,
 
 // read .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void readConditionalRestrictions(const std::filesystem::path &path,
+inline void readConditionalRestrictions(const boost::filesystem::path &path,
                                         ConditionalRestrictionsT &conditional_restrictions)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -439,7 +441,7 @@ inline void readConditionalRestrictions(const std::filesystem::path &path,
 
 // reads .osrm file which is a temporary file of osrm-extract
 template <typename PackedOSMIDsT>
-void readRawNBGraph(const std::filesystem::path &path,
+void readRawNBGraph(const boost::filesystem::path &path,
                     std::vector<util::Coordinate> &coordinates,
                     PackedOSMIDsT &osm_node_ids,
                     std::vector<extractor::NodeBasedEdge> &edge_list)
@@ -464,7 +466,8 @@ void readRawNBGraph(const std::filesystem::path &path,
     storage::serialization::read(reader, "/extractor/edges", edge_list);
 }
 
-template <typename NameTableT> void readNames(const std::filesystem::path &path, NameTableT &table)
+template <typename NameTableT>
+void readNames(const boost::filesystem::path &path, NameTableT &table)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -473,7 +476,7 @@ template <typename NameTableT> void readNames(const std::filesystem::path &path,
 }
 
 template <typename NameTableT>
-void writeNames(const std::filesystem::path &path, const NameTableT &table)
+void writeNames(const boost::filesystem::path &path, const NameTableT &table)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -482,7 +485,7 @@ void writeNames(const std::filesystem::path &path, const NameTableT &table)
 }
 
 template <typename NodeWeightsVectorT>
-void readEdgeBasedNodeWeights(const std::filesystem::path &path, NodeWeightsVectorT &weights)
+void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVectorT &weights)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -491,7 +494,8 @@ void readEdgeBasedNodeWeights(const std::filesystem::path &path, NodeWeightsVect
 }
 
 template <typename NodeDistancesVectorT>
-void readEdgeBasedNodeDistances(const std::filesystem::path &path, NodeDistancesVectorT &distances)
+void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
+                                NodeDistancesVectorT &distances)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -500,7 +504,7 @@ void readEdgeBasedNodeDistances(const std::filesystem::path &path, NodeDistances
 }
 
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT, typename NodeDistancesVectorT>
-void writeEdgeBasedNodeWeightsDurationsDistances(const std::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &path,
                                                  const NodeWeightsVectorT &weights,
                                                  const NodeDurationsVectorT &durations,
                                                  const NodeDistancesVectorT &distances)
@@ -514,7 +518,7 @@ void writeEdgeBasedNodeWeightsDurationsDistances(const std::filesystem::path &pa
 }
 
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void readEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
+void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
                                        NodeWeightsVectorT &weights,
                                        NodeDurationsVectorT &durations)
 {
@@ -526,7 +530,7 @@ void readEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
 }
 
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void writeEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
                                         const NodeWeightsVectorT &weights,
                                         const NodeDurationsVectorT &durations)
 {
@@ -538,7 +542,7 @@ void writeEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
 }
 
 template <typename RTreeT>
-void writeRamIndex(const std::filesystem::path &path, const RTreeT &rtree)
+void writeRamIndex(const boost::filesystem::path &path, const RTreeT &rtree)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -546,7 +550,7 @@ void writeRamIndex(const std::filesystem::path &path, const RTreeT &rtree)
     util::serialization::write(writer, "/common/rtree", rtree);
 }
 
-template <typename RTreeT> void readRamIndex(const std::filesystem::path &path, RTreeT &rtree)
+template <typename RTreeT> void readRamIndex(const boost::filesystem::path &path, RTreeT &rtree)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -555,7 +559,7 @@ template <typename RTreeT> void readRamIndex(const std::filesystem::path &path,
 }
 
 template <typename EdgeListT>
-void writeCompressedNodeBasedGraph(const std::filesystem::path &path, const EdgeListT &edge_list)
+void writeCompressedNodeBasedGraph(const boost::filesystem::path &path, const EdgeListT &edge_list)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
@@ -564,7 +568,7 @@ void writeCompressedNodeBasedGraph(const std::filesystem::path &path, const Edge
 }
 
 template <typename EdgeListT>
-void readCompressedNodeBasedGraph(const std::filesystem::path &path, EdgeListT &edge_list)
+void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT &edge_list)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};

include/extractor/location_dependent_data.hpp

@@ -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<std::filesystem::path> &file_paths);
+    LocationDependentData(const std::vector<boost::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 std::filesystem::path &file_path,
+    void loadLocationDependentData(const boost::filesystem::path &file_path,
                                    std::vector<rtree_t::value_type> &bounding_boxes);
 
     rtree_t rtree;

include/extractor/node_based_graph_factory.hpp

@@ -12,7 +12,8 @@
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"
 
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
+
 #include <memory>
 #include <string>
 #include <unordered_set>

include/extractor/raster_source.hpp

@@ -7,13 +7,14 @@
 #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>
@@ -39,7 +40,7 @@ struct RasterDatum
 class RasterGrid
 {
   public:
-    RasterGrid(const std::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
+    RasterGrid(const boost::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
     {
         xdim = _xdim;
         ydim = _ydim;

include/extractor/scripting_environment_lua.hpp

@@ -70,7 +70,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment
 
     explicit Sol2ScriptingEnvironment(
         const std::string &file_name,
-        const std::vector<std::filesystem::path> &location_dependent_data_paths);
+        const std::vector<boost::filesystem::path> &location_dependent_data_paths);
     ~Sol2ScriptingEnvironment() override = default;
 
     const ProfileProperties &GetProfileProperties() override;

include/extractor/segment_data_container.hpp

@@ -8,12 +8,13 @@
 #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 <filesystem>
-#include <string>
 #include <unordered_map>
+
+#include <string>
 #include <vector>
 
 namespace osrm::extractor

include/guidance/files.hpp

@@ -10,16 +10,12 @@
 
 #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 std::filesystem::path &path,
+inline void readTurnData(const boost::filesystem::path &path,
                          TurnDataT &turn_data,
                          std::uint32_t &connectivity_checksum)
 {
@@ -36,7 +32,7 @@ inline void readTurnData(const std::filesystem::path &path,
 
 // writes .osrm.edges
 template <typename TurnDataT>
-inline void writeTurnData(const std::filesystem::path &path,
+inline void writeTurnData(const boost::filesystem::path &path,
                           const TurnDataT &turn_data,
                           const std::uint32_t connectivity_checksum)
 {

include/nodejs/json_v8_renderer.hpp

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

include/nodejs/node_osrm_support.hpp

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

include/partitioner/edge_based_graph_reader.hpp

@@ -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 std::filesystem::path &path)
+inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &path)
 {
     EdgeID number_of_edge_based_nodes;
     std::vector<extractor::EdgeBasedEdge> edges;

include/partitioner/files.hpp

@@ -10,7 +10,7 @@ namespace osrm::partitioner::files
 
 // read .osrm.partition file
 template <typename MultiLevelPartitionT>
-inline void readPartition(const std::filesystem::path &path, MultiLevelPartitionT &mlp)
+inline void readPartition(const boost::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 std::filesystem::path &path, MultiLevelPartition
 
 // writes .osrm.partition file
 template <typename MultiLevelPartitionT>
-inline void writePartition(const std::filesystem::path &path, const MultiLevelPartitionT &mlp)
+inline void writePartition(const boost::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 std::filesystem::path &path, const MultiLevelPa
 
 // reads .osrm.cells file
 template <typename CellStorageT>
-inline void readCells(const std::filesystem::path &path, CellStorageT &storage)
+inline void readCells(const boost::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 std::filesystem::path &path, CellStorageT &storage)
 
 // writes .osrm.cells file
 template <typename CellStorageT>
-inline void writeCells(const std::filesystem::path &path, CellStorageT &storage)
+inline void writeCells(const boost::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 std::filesystem::path &path, CellStorageT &storage)
 
 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const std::filesystem::path &path,
+inline void readGraph(const boost::filesystem::path &path,
                       MultiLevelGraphT &graph,
                       std::uint32_t &connectivity_checksum)
 {
@@ -80,7 +80,7 @@ inline void readGraph(const std::filesystem::path &path,
 
 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const std::filesystem::path &path,
+inline void writeGraph(const boost::filesystem::path &path,
                        const MultiLevelGraphT &graph,
                        const std::uint32_t connectivity_checksum)
 {

include/partitioner/partitioner_config.hpp

@@ -1,8 +1,9 @@
 #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"
@@ -28,7 +29,7 @@ struct PartitionerConfig final : storage::IOConfig
     {
     }
 
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
     {
         IOConfig::UseDefaultOutputNames(base);
     }

include/server/api/base_parameters_grammar.hpp

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

include/server/api/parameters_parser.hpp

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

include/server/api/url_parser.hpp

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

include/storage/io.hpp

@@ -10,13 +10,14 @@
 #include "util/log.hpp"
 #include "util/version.hpp"
 
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
 #include <boost/iostreams/device/array.hpp>
 #include <boost/iostreams/seek.hpp>
 #include <boost/iostreams/stream.hpp>
+
 #include <cerrno>
 #include <cstring>
-#include <filesystem>
-#include <fstream>
 #include <iostream>
 #include <tuple>
 #include <type_traits>
@@ -34,11 +35,11 @@ class FileReader
     };
 
     FileReader(const std::string &filename, const FingerprintFlag flag)
-        : FileReader(std::filesystem::path(filename), flag)
+        : FileReader(boost::filesystem::path(filename), flag)
     {
     }
 
-    FileReader(const std::filesystem::path &filepath_, const FingerprintFlag flag)
+    FileReader(const boost::filesystem::path &filepath_, const FingerprintFlag flag)
         : filepath(filepath_), fingerprint(flag)
     {
         input_stream.open(filepath, std::ios::binary);
@@ -57,14 +58,14 @@ class FileReader
 
     std::size_t GetSize()
     {
-        const std::filesystem::path path(filepath);
+        const boost::filesystem::path path(filepath);
         try
         {
-            return std::size_t(std::filesystem::file_size(path)) -
+            return std::size_t(boost::filesystem::file_size(path)) -
                    ((fingerprint == FingerprintFlag::VerifyFingerprint) ? sizeof(util::FingerPrint)
                                                                         : 0);
         }
-        catch (const std::filesystem::filesystem_error &ex)
+        catch (const boost::filesystem::filesystem_error &ex)
         {
             std::cout << ex.what() << std::endl;
             throw;
@@ -195,8 +196,8 @@ class FileReader
     }
 
   private:
-    const std::filesystem::path filepath;
-    std::ifstream input_stream;
+    const boost::filesystem::path filepath;
+    boost::filesystem::ifstream input_stream;
     FingerprintFlag fingerprint;
 };
 
@@ -210,11 +211,11 @@ class FileWriter
     };
 
     FileWriter(const std::string &filename, const FingerprintFlag flag)
-        : FileWriter(std::filesystem::path(filename), flag)
+        : FileWriter(boost::filesystem::path(filename), flag)
     {
     }
 
-    FileWriter(const std::filesystem::path &filepath_, const FingerprintFlag flag)
+    FileWriter(const boost::filesystem::path &filepath_, const FingerprintFlag flag)
         : filepath(filepath_), fingerprint(flag)
     {
         output_stream.open(filepath, std::ios::binary);
@@ -283,8 +284,8 @@ class FileWriter
     }
 
   private:
-    const std::filesystem::path filepath;
-    std::ofstream output_stream;
+    const boost::filesystem::path filepath;
+    boost::filesystem::ofstream output_stream;
     FingerprintFlag fingerprint;
 };
 

include/storage/io_config.hpp

@@ -3,19 +3,19 @@
 
 #include "util/exception.hpp"
 
-#include <boost/algorithm/string/predicate.hpp>
-
 #include <array>
-#include <filesystem>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/path.hpp>
 #include <string>
 
 namespace osrm::storage
 {
 struct IOConfig
 {
-    IOConfig(std::vector<std::filesystem::path> required_input_files_,
-             std::vector<std::filesystem::path> optional_input_files_,
-             std::vector<std::filesystem::path> output_files_)
+    IOConfig(std::vector<boost::filesystem::path> required_input_files_,
+             std::vector<boost::filesystem::path> optional_input_files_,
+             std::vector<boost::filesystem::path> output_files_)
         : required_input_files(std::move(required_input_files_)),
           optional_input_files(std::move(optional_input_files_)),
           output_files(std::move(output_files_))
@@ -24,7 +24,7 @@ struct IOConfig
 
     bool IsValid() const;
     std::vector<std::string> GetMissingFiles() const;
-    std::filesystem::path GetPath(const std::string &fileName) const
+    boost::filesystem::path GetPath(const std::string &fileName) const
     {
         if (!IsConfigured(fileName, required_input_files) &&
             !IsConfigured(fileName, optional_input_files) && !IsConfigured(fileName, output_files))
@@ -40,11 +40,11 @@ struct IOConfig
         return IsConfigured(fileName, required_input_files);
     }
 
-    std::filesystem::path base_path;
+    boost::filesystem::path base_path;
 
   protected:
     // Infer the base path from the path of the .osrm file
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
     {
         // potentially strip off the .osrm (or other) extensions for
         // determining the base path=
@@ -67,7 +67,7 @@ struct IOConfig
 
   private:
     static bool IsConfigured(const std::string &fileName,
-                             const std::vector<std::filesystem::path> &paths)
+                             const std::vector<boost::filesystem::path> &paths)
     {
         for (auto &path : paths)
         {
@@ -80,9 +80,9 @@ struct IOConfig
         return false;
     }
 
-    std::vector<std::filesystem::path> required_input_files;
-    std::vector<std::filesystem::path> optional_input_files;
-    std::vector<std::filesystem::path> output_files;
+    std::vector<boost::filesystem::path> required_input_files;
+    std::vector<boost::filesystem::path> optional_input_files;
+    std::vector<boost::filesystem::path> output_files;
 };
 } // namespace osrm::storage
 

include/storage/shared_memory.hpp

@@ -5,6 +5,8 @@
 #include "util/exception_utils.hpp"
 #include "util/log.hpp"
 
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
 #include <boost/interprocess/mapped_region.hpp>
 #ifndef _WIN32
 #include <boost/interprocess/xsi_shared_memory.hpp>
@@ -21,8 +23,6 @@
 
 #include <algorithm>
 #include <exception>
-#include <filesystem>
-#include <fstream>
 #include <thread>
 
 #include "storage/shared_memory_ownership.hpp"
@@ -32,10 +32,10 @@ namespace osrm::storage
 
 struct OSRMLockFile
 {
-    template <typename IdentifierT> std::filesystem::path operator()(const IdentifierT &id)
+    template <typename IdentifierT> boost::filesystem::path operator()(const IdentifierT &id)
     {
-        std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
-        std::filesystem::path lock_file = temp_dir / ("osrm-" + std::to_string(id) + ".lock");
+        boost::filesystem::path temp_dir = boost::filesystem::temp_directory_path();
+        boost::filesystem::path lock_file = temp_dir / ("osrm-" + std::to_string(id) + ".lock");
         return lock_file;
     }
 };
@@ -51,7 +51,7 @@ class SharedMemory
     SharedMemory &operator=(const SharedMemory &) = delete;
 
     template <typename IdentifierT>
-    SharedMemory(const std::filesystem::path &lock_file,
+    SharedMemory(const boost::filesystem::path &lock_file,
                  const IdentifierT id,
                  const uint64_t size = 0)
         : key(lock_file.string().c_str(), id)
@@ -202,7 +202,7 @@ class SharedMemory
     void *Ptr() const { return region.get_address(); }
     std::size_t Size() const { return region.get_size(); }
 
-    SharedMemory(const std::filesystem::path &lock_file, const int id, const uint64_t size = 0)
+    SharedMemory(const boost::filesystem::path &lock_file, const int id, const uint64_t size = 0)
     {
         sprintf(key, "%s.%d", "osrm.lock", id);
         if (0 == size)
@@ -290,7 +290,7 @@ std::unique_ptr<SharedMemory> makeSharedMemory(const IdentifierT &id, const uint
     try
     {
         LockFileT lock_file;
-        if (!std::filesystem::exists(lock_file(id)))
+        if (!boost::filesystem::exists(lock_file(id)))
         {
             if (0 == size)
             {
@@ -298,7 +298,7 @@ std::unique_ptr<SharedMemory> makeSharedMemory(const IdentifierT &id, const uint
             }
             else
             {
-                std::ofstream ofs(lock_file(id));
+                boost::filesystem::ofstream ofs(lock_file(id));
             }
         }
         return std::make_unique<SharedMemory>(lock_file(id), id, size);

include/storage/storage.hpp

@@ -32,14 +32,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/shared_datatype.hpp"
 #include "storage/storage_config.hpp"
 
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
+
 #include <string>
 #include <vector>
 
 namespace osrm::storage
 {
 
-void populateLayoutFromFile(const std::filesystem::path &path, storage::BaseDataLayout &layout);
+void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout);
 
 class Storage
 {
@@ -50,10 +51,10 @@ class Storage
     void PopulateStaticData(const SharedDataIndex &index);
     void PopulateUpdatableData(const SharedDataIndex &index);
     void PopulateLayout(storage::BaseDataLayout &layout,
-                        const std::vector<std::pair<bool, std::filesystem::path>> &files);
+                        const std::vector<std::pair<bool, boost::filesystem::path>> &files);
     std::string PopulateLayoutWithRTree(storage::BaseDataLayout &layout);
-    std::vector<std::pair<bool, std::filesystem::path>> GetUpdatableFiles();
-    std::vector<std::pair<bool, std::filesystem::path>> GetStaticFiles();
+    std::vector<std::pair<bool, boost::filesystem::path>> GetUpdatableFiles();
+    std::vector<std::pair<bool, boost::filesystem::path>> GetStaticFiles();
 
   private:
     StorageConfig config;

include/storage/storage_config.hpp

@@ -28,23 +28,22 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef STORAGE_CONFIG_HPP
 #define STORAGE_CONFIG_HPP
 
+#include <boost/filesystem/path.hpp>
+
 #include "storage/io_config.hpp"
 #include "osrm/datasets.hpp"
 
-#include <filesystem>
-#include <istream>
 #include <set>
-#include <vector>
 
 namespace osrm::storage
 {
 
 std::istream &operator>>(std::istream &in, FeatureDataset &datasets);
 
-static std::vector<std::filesystem::path>
+static std::vector<boost::filesystem::path>
 GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_dataset)
 {
-    std::set<std::filesystem::path> required{
+    std::set<boost::filesystem::path> required{
         ".osrm.datasource_names",
         ".osrm.ebg_nodes",
         ".osrm.edges",
@@ -83,7 +82,7 @@ GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_da
         }
     }
 
-    return std::vector<std::filesystem::path>(required.begin(), required.end());
+    return std::vector<boost::filesystem::path>(required.begin(), required.end());
     ;
 }
 
@@ -95,7 +94,7 @@ GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_da
 struct StorageConfig final : IOConfig
 {
 
-    StorageConfig(const std::filesystem::path &base,
+    StorageConfig(const boost::filesystem::path &base,
                   const std::vector<storage::FeatureDataset> &disabled_feature_datasets_ = {})
         : StorageConfig(disabled_feature_datasets_)
     {

include/storage/tar.hpp

@@ -7,7 +7,7 @@
 #include "util/integer_range.hpp"
 #include "util/version.hpp"
 
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
 
 extern "C"
 {
@@ -19,7 +19,7 @@ namespace osrm::storage::tar
 namespace detail
 {
 inline void
-checkMTarError(int error_code, const std::filesystem::path &filepath, const std::string &name)
+checkMTarError(int error_code, const boost::filesystem::path &filepath, const std::string &name)
 {
     switch (error_code)
     {
@@ -78,7 +78,7 @@ class FileReader
         HasNoFingerprint
     };
 
-    FileReader(const std::filesystem::path &path, FingerprintFlag flag) : path(path)
+    FileReader(const boost::filesystem::path &path, FingerprintFlag flag) : path(path)
     {
         auto ret = mtar_open(&handle, path.string().c_str(), "r");
         detail::checkMTarError(ret, path, "");
@@ -204,7 +204,7 @@ class FileReader
         return true;
     }
 
-    std::filesystem::path path;
+    boost::filesystem::path path;
     mtar_t handle;
 };
 
@@ -217,7 +217,7 @@ class FileWriter
         HasNoFingerprint
     };
 
-    FileWriter(const std::filesystem::path &path, FingerprintFlag flag) : path(path)
+    FileWriter(const boost::filesystem::path &path, FingerprintFlag flag) : path(path)
     {
         auto ret = mtar_open(&handle, path.string().c_str(), "w");
         detail::checkMTarError(ret, path, "");
@@ -305,7 +305,7 @@ class FileWriter
         WriteFrom("osrm_fingerprint.meta", fingerprint);
     }
 
-    std::filesystem::path path;
+    boost::filesystem::path path;
     mtar_t handle;
 };
 } // namespace osrm::storage::tar

include/storage/view_factory.hpp

@@ -202,7 +202,7 @@ inline auto make_search_tree_view(const SharedDataIndex &index, const std::strin
 
     const char *path = index.template GetBlockPtr<char>(name + "/file_index_path");
 
-    if (!std::filesystem::exists(std::filesystem::path{path}))
+    if (!boost::filesystem::exists(boost::filesystem::path{path}))
     {
         throw util::exception("Could not load " + std::string(path) + "Does the leaf file exist?" +
                               SOURCE_REF);