.clang-tidy

@@ -13,11 +13,6 @@ Checks: >
     -bugprone-forward-declaration-namespace,
     -bugprone-sizeof-expression,
     -bugprone-throw-keyword-missing,
-    -bugprone-chained-comparison,
-    -bugprone-incorrect-enable-if,
-    -bugprone-switch-missing-default-case,
-    -bugprone-empty-catch,
-    -bugprone-unchecked-optional-access,
     -clang-analyzer-*,
     -clang-diagnostic-deprecated-declarations,
     -clang-diagnostic-constant-conversion,
@@ -54,13 +49,11 @@ Checks: >
     -misc-misplaced-const,
     -misc-definitions-in-headers,
     -misc-unused-parameters,
-    -misc-include-cleaner,
     modernize-concat-nested-namespaces,
     modernize-use-using,
     performance-*,
+    -performance-noexcept-move-constructor,
     -performance-no-int-to-ptr,
-    -performance-enum-size,
-    -performance-avoid-endl,
     readability-*,
     -readability-avoid-const-params-in-decls,
     -readability-braces-around-statements,
@@ -89,10 +82,6 @@ Checks: >
     -readability-make-member-function-const,
     -readability-redundant-string-init,
     -readability-non-const-parameter,
-    -readability-redundant-inline-specifier,
-    -readability-avoid-nested-conditional-operator,
-    -readability-avoid-return-with-void-value,
-    -readability-redundant-casting,
     -readability-static-accessed-through-instance
     
 WarningsAsErrors: '*'

.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 }}
+          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

@@ -15,13 +15,10 @@ env:
   CCACHE_TEMPDIR: /tmp/.ccache-temp
   CCACHE_COMPRESS: 1
   CASHER_TIME_OUT: 599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
+  CCACHE_VERSION: 3.3.1
   CMAKE_VERSION: 3.21.2
   ENABLE_NODE_BINDINGS: "ON"
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
 jobs:
   windows-release-node:
     needs: format-taginfo-docs
@@ -29,12 +26,13 @@ jobs:
     continue-on-error: false
     env:
       BUILD_TYPE: Release
+      ENABLE_APPLE_SILICON: "OFF"
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
     - run: pip install "conan<2.0.0"
     - run: conan --version
     - run: cmake --version
-    - uses: actions/setup-node@v4
+    - uses: actions/setup-node@v3
       with:
         node-version: 18
     - run: node --version
@@ -46,32 +44,15 @@ jobs:
         echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
     - run: npm install --ignore-scripts
     - run: npm link --ignore-scripts
+    - uses: microsoft/setup-msbuild@v1.1
     - name: Build
+      run: |
+        .\scripts\ci\windows-build.bat
+    - name: Run node tests
       shell: bash
       run: |
-        mkdir build
+        ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
-        cd build
+        node test/nodejs/index.js
-        cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_CONAN=ON -DENABLE_NODE_BINDINGS=ON ..
-        cmake --build . --config Release
-        
-    # TODO: MSVC goes out of memory when building our tests
-    # - name: Run tests
-    #   shell: bash
-    #   run: |
-    #     cd build
-    #     cmake --build . --config Release --target tests
-    #     # TODO: run tests
-    # - name: Run node tests
-    #   shell: bash
-    #   run: |
-    #     ./lib/binding/osrm-extract.exe -p profiles/car.lua test/data/monaco.osm.pbf
-
-    #     mkdir -p test/data/ch
-    #     cp test/data/monaco.osrm* test/data/ch/
-    #     ./lib/binding/osrm-contract.exe test/data/ch/monaco.osrm
-
-    #     ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
-    #     node test/nodejs/index.js
     - name: Build Node package
       shell: bash
       run: ./scripts/ci/node_package.sh
@@ -90,15 +71,15 @@ jobs:
         token: ${{ secrets.GITHUB_TOKEN }}
 
   format-taginfo-docs:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
     - name: Use Node.js
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
       with:
         node-version: 18
     - name: Enable Node.js cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
       with:
         path: ~/.npm
         key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@@ -107,7 +88,7 @@ jobs:
     - name: Prepare environment
       run: |
         npm ci --ignore-scripts
-        clang-format-15 --version
+        clang-format-10 --version
     - name: Run checks
       run: |
         ./scripts/check_taginfo.py taginfo.json profiles/car.lua
@@ -116,18 +97,15 @@ jobs:
         npm run docs && ./scripts/error_on_dirty.sh
         npm audit --production
 
-  docker-image-matrix:
+  docker-image:
-    strategy:
-      matrix:
-        docker-base-image: ["debian", "alpine"]
     needs: format-taginfo-docs
     runs-on: ubuntu-22.04
     continue-on-error: false
     steps:
       - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
       - name: Enable osm.pbf cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: berlin-latest.osm.pbf
           key: v1-berlin-osm-pbf
@@ -135,7 +113,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 +130,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"
 
@@ -166,148 +145,144 @@ jobs:
     strategy:
       matrix:
         include:
-          - name: gcc-13-debug-cov
+          - name: gcc-9-debug-cov
             continue-on-error: false
-            node: 20
+            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-20.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: gcc-13
+            CCOMPILER: gcc-9
             CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: g++-13
+            CXXCOMPILER: g++-9
             ENABLE_COVERAGE: ON
 
-          - name: clang-18-debug-asan-ubsan
+          - name: gcc-9-debug-asan-ubsan
             continue-on-error: false
-            node: 20
+            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-20.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: gcc-9
             CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: g++-9
             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-6.0-debug
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-20.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
-
-          - name: clang-18-debug
-            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-6.0
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-6.0
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
-          - name: clang-18-debug-clang-tidy
+          - name: clang-15.0-debug-clang-tidy
             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
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
             CUCUMBER_TIMEOUT: 60000
             ENABLE_CLANG_TIDY: ON
 
-
-          - name: clang-17-release
-            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang-17
-            CXXCOMPILER: clang++-17
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
-
-          - name: clang-16-release
-            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
-
           - name: conan-linux-debug-asan-ubsan
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-20.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
+            CCOMPILER: clang-11
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-11
             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-20.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
+            CCOMPILER: clang-6.0
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-6.0
             ENABLE_CONAN: ON
-            ENABLE_LTO: OFF
-
-          - name: gcc-14-release
-            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-14
-            CXXCOMPILER: g++-14
-            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
-
-          - name: gcc-13-release
-            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-13
-            CXXCOMPILER: g++-13
-            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
 
           - name: gcc-12-release
             continue-on-error: false
-            node: 20
+            node: 18
             runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
             CCOMPILER: gcc-12
             CXXCOMPILER: g++-12
+            ENABLE_BENCHMARKS: ON
             CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
 
+          - name: gcc-11-release
+            continue-on-error: false
+            node: 18
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-11
+            CXXCOMPILER: g++-11
+            ENABLE_BENCHMARKS: ON
+
+          - name: gcc-10-release
+            continue-on-error: false
+            node: 18
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-10
+            CXXCOMPILER: g++-10
+
+          - name: gcc-9-release
+            continue-on-error: false
+            node: 18
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-9
+            CXXCOMPILER: g++-9
+            CXXFLAGS: -Wno-cast-function-type
+
+          - name: gcc-9-conan-release-i686
+            continue-on-error: false
+            node: 18
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-9
+            CFLAGS: "-m32 -msse2 -mfpmath=sse"
+            CXXCOMPILER: g++-9
+            CXXFLAGS: "-m32 -msse2 -mfpmath=sse"
+            TARGET_ARCH: i686
+            ENABLE_CONAN: ON
+
+          - name: gcc-8-release
+            continue-on-error: false
+            node: 18
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-8
+            CXXCOMPILER: g++-8
+            CXXFLAGS: -Wno-cast-function-type
+
           - name: conan-linux-release-node
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-20.04
             BUILD_TYPE: Release
-            CCOMPILER: clang-16
+            CCOMPILER: clang-6.0
-            CXXCOMPILER: clang++-16
+            CXXCOMPILER: clang++-6.0
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -315,10 +290,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-20.04
             BUILD_TYPE: Debug
-            CCOMPILER: clang-16
+            CCOMPILER: clang-6.0
-            CXXCOMPILER: clang++-16
+            CXXCOMPILER: clang++-6.0
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -326,7 +301,7 @@ jobs:
             build_node_package: true
             continue-on-error: true
             node: 20
-            runs-on: macos-13 # x86_64
+            runs-on: macos-11
             BUILD_TYPE: Release
             CCOMPILER: clang
             CXXCOMPILER: clang++
@@ -338,13 +313,14 @@ jobs:
             build_node_package: true
             continue-on-error: true
             node: 20
-            runs-on: macos-14 # arm64 
+            runs-on: macos-11
             BUILD_TYPE: Release
             CCOMPILER: clang
             CXXCOMPILER: clang++
             CUCUMBER_TIMEOUT: 60000
             ENABLE_ASSERTIONS: ON
             ENABLE_CONAN: ON
+            ENABLE_APPLE_SILICON: ON
 
     name: ${{ matrix.name}}
     continue-on-error: ${{ matrix.continue-on-error }}
@@ -364,51 +340,48 @@ jobs:
       ENABLE_CONAN: ${{ matrix.ENABLE_CONAN }}
       ENABLE_SANITIZER: ${{ matrix.ENABLE_SANITIZER }}
       NODE_PACKAGE_TESTS_ONLY: ${{ matrix.NODE_PACKAGE_TESTS_ONLY }}
+      ENABLE_APPLE_SILICON: ${{ matrix.ENABLE_APPLE_SILICON }}
       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
+    - uses: actions/checkout@v3
-    - name: Build machine architecture
+
-      run: uname -m
     - name: Use Node.js
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
       with:
         node-version: ${{ matrix.node }}
     - name: Enable Node.js cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
       with:
         path: ~/.npm
         key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
         restore-keys: |
           ${{ runner.os }}-node-
     - name: Enable compiler cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
       with:
         path: ~/.ccache
         key: ccache-${{ matrix.name }}-${{ github.sha }}
         restore-keys: |
           ccache-${{ matrix.name }}-
     - name: Enable Conan cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
       with:
         path: ~/.conan
-        key: v9-conan-${{ matrix.name }}-${{ github.sha }}
+        key: v7-conan-${{ matrix.name }}-${{ github.sha }}
         restore-keys: |
-          v9-conan-${{ matrix.name }}-
+          v7-conan-${{ matrix.name }}-
     - name: Enable test cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
       with:
         path: ${{github.workspace}}/test/cache
         key: v4-test-${{ matrix.name }}-${{ github.sha }}
         restore-keys: |
           v4-test-${{ matrix.name }}-
+
     - name: Prepare environment
       run: |
-        echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
-        mkdir -p $HOME/.ccache
-
         PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
         echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
         echo "OSRM_INSTALL_DIR=${GITHUB_WORKSPACE}/install-osrm" >> $GITHUB_ENV
@@ -417,7 +390,6 @@ jobs:
           # We can only set this after checkout once we know the workspace directory
           echo "LSAN_OPTIONS=print_suppressions=0:suppressions=${GITHUB_WORKSPACE}/scripts/ci/leaksanitizer.conf" >> $GITHUB_ENV
           echo "UBSAN_OPTIONS=symbolize=1:halt_on_error=1:print_stacktrace=1:suppressions=${GITHUB_WORKSPACE}/scripts/ci/undefinedsanitizer.conf" >> $GITHUB_ENV
-          echo "ASAN_OPTIONS=print_suppressions=0:suppressions=${GITHUB_WORKSPACE}/scripts/ci/addresssanitizer.conf" >> $GITHUB_ENV
         fi
 
         if [[ "${RUNNER_OS}" == "Linux" ]]; then
@@ -425,39 +397,10 @@ jobs:
         elif [[ "${RUNNER_OS}" == "macOS" ]]; then
           echo "JOBS=$((`sysctl -n hw.ncpu` + 1))" >>  $GITHUB_ENV
         fi
-    # See: https://github.com/actions/toolkit/issues/946#issuecomment-1590016041
-    # We need it to be able to access system folders while restoring cached Boost below
-    - name: Give tar root ownership 
-      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
-      run: sudo chown root /bin/tar && sudo chmod u+s /bin/tar
-    - name: Cache Boost
-      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
-      id: cache-boost
-      uses: actions/cache@v4
-      with:
-        path: |
-          /usr/local/include/boost
-          /usr/local/lib/libboost*
-        key: v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}
-        restore-keys: |
-          v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}
-
-    - name: Install Boost
-      if: steps.cache-boost.outputs.cache-hit != 'true' && runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
-      run: |
-        BOOST_VERSION="1.85.0"
-        BOOST_VERSION_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}
-        sudo ./bootstrap.sh
-        sudo ./b2 install
-        cd ..
-        sudo rm -rf boost-${BOOST_VERSION}*
 
     - name: Install dev dependencies
       run: |
-        python3 -m pip install "conan<2.0.0" || python3 -m pip install "conan<2.0.0" --break-system-packages
+        python3 -m pip install "conan<2.0.0"
 
         # workaround for issue that GitHub Actions seems to not adding it to PATH after https://github.com/actions/runner-images/pull/6499
         # and that's why CI cannot find conan executable installed above
@@ -472,20 +415,34 @@ jobs:
           brew install ccache
         fi
 
+        # clang
+        if [[ "${CCOMPILER}" == "clang-6.0" ]]; then
+          sudo apt-get update -y && sudo apt-get install clang++-6
+        elif [[ "${CCOMPILER}" == "clang-15" ]]; then
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+          sudo apt-get update -y && sudo apt-get install software-properties-common
+          sudo add-apt-repository 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main'
+          sudo apt-get update -y && sudo apt-get install clang++-15 clang-tidy-15
+          sudo update-alternatives --install /usr/bin/clang-tidy clang-tidy /usr/bin/clang-tidy-15 100000
+        fi
+
         # Linux dev packages
-        if [ "${ENABLE_CONAN}" != "ON" ]; then
+        if [ "${TARGET_ARCH}" != "i686" ] && [ "${ENABLE_CONAN}" != "ON" ]; then
           sudo apt-get update -y
-          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev
+          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev libboost-all-dev
           if [[ "${CCOMPILER}" != clang-* ]]; then
             sudo apt-get install -y ${CXXCOMPILER}
           fi
           if [[ "${ENABLE_COVERAGE}" == "ON" ]]; then
             sudo apt-get install -y lcov
           fi
+        elif [[ $TARGET_ARCH == "i686" ]]; then
+          source ./scripts/ci/before_install.${TARGET_ARCH}.sh
+          echo "PKG_CONFIG_PATH=/usr/lib/i386-linux-gnu/pkgconfig:${PKG_CONFIG_PATH}" >> $GITHUB_ENV
         fi
 
         # TBB
-        TBB_VERSION=2021.12.0
+        TBB_VERSION=2021.3.0
         if [[ "${RUNNER_OS}" == "Linux" ]]; then
           TBB_URL="https://github.com/oneapi-src/oneTBB/releases/download/v${TBB_VERSION}/oneapi-tbb-${TBB_VERSION}-lin.tgz"
         elif [[ "${RUNNER_OS}" == "macOS" ]]; then
@@ -495,20 +452,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}
@@ -531,7 +474,17 @@ jobs:
         echo "Using ${JOBS} jobs"
         pushd ${OSRM_BUILD_DIR}
 
-        ccache --zero-stats
+        # handle Apple Silicon cross compilation
+        if [[ "${ENABLE_APPLE_SILICON}" == "ON" ]]; then
+          ARCH=arm64
+          TARGET="${ARCH}-apple-darwin"
+          CFLAGS="$CFLAGS --target=$TARGET"
+          CXXFLAGS="$CXXFLAGS --target=$TARGET"
+          APPLE_SILICON_FLAGS=(-DCMAKE_C_COMPILER_TARGET="$TARGET" -DCMAKE_CXX_COMPILER_TARGET="$TARGET" -DCMAKE_SYSTEM_PROCESSOR="${ARCH}" -DCMAKE_SYSTEM_NAME="Darwin" -DCMAKE_C_FLAGS="$CFLAGS" -DCMAKE_CXX_FLAGS="$CXXFLAGS")
+        else
+          APPLE_SILICON_FLAGS=()
+        fi
+
         cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
                  -DENABLE_CONAN=${ENABLE_CONAN:-OFF} \
                  -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
@@ -542,14 +495,15 @@ 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} \
-                 -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
+                 "${APPLE_SILICON_FLAGS[@]}"
+
         make --jobs=${JOBS}
 
-        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
+        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" && "${ENABLE_APPLE_SILICON}" != "ON" ]]; then
           make tests --jobs=${JOBS}
           make benchmarks --jobs=${JOBS}
-
+          ccache -s
           sudo make install
           if [[ "${RUNNER_OS}" == "Linux" ]]; then
             echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib" >> $GITHUB_ENV
@@ -558,14 +512,14 @@ jobs:
         fi
         popd
     - name: Build example
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
       run: |
         mkdir example/build && pushd example/build
         cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
         make --jobs=${JOBS}
         popd
     - name: Run all tests
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
       run: |
         make -C test/data benchmark
 
@@ -576,66 +530,86 @@ jobs:
         # All tests assume to be run from the build directory
         pushd ${OSRM_BUILD_DIR}
         for i in ./unit_tests/*-tests ; do echo Running $i ; $i ; done
-        if [ -z "${ENABLE_SANITIZER}" ]; then
+        if [ -z "${ENABLE_SANITIZER}" ] && [ "$TARGET_ARCH" != "i686" ]; then
           npm run nodejs-tests
         fi
         popd
         npm test
+    - name: Run benchmarks
+      if: ${{ matrix.ENABLE_BENCHMARKS == 'ON' }}
+      run: |
+        pushd ${OSRM_BUILD_DIR}
+        make --jobs=${JOBS} benchmarks
+        ./src/benchmarks/alias-bench
+        ./src/benchmarks/json-render-bench ../src/benchmarks/portugal_to_korea.json
+        ./src/benchmarks/match-bench ../test/data/ch/monaco.osrm
+        ./src/benchmarks/packedvector-bench
+        ./src/benchmarks/rtree-bench ../test/data/monaco.osrm.ramIndex ../test/data/monaco.osrm.fileIndex ../test/data/monaco.osrm.nbg_nodes
+        popd
 
     - name: Use Node 18
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
       with:
         node-version: 18
     - name: Run Node package tests on Node 18
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
       run: |
         node --version
         npm run nodejs-tests
     - name: Use Node 20
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
       with:
         node-version: 20
     - name: Run Node package tests on Node 20
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
       run: |
         node --version
         npm run nodejs-tests
     - name: Use Node latest
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
       with:
         node-version: latest
     - name: Run Node package tests on Node-latest
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
       run: |
         node --version
         npm run nodejs-tests
 
     - name: Upload test logs
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
       if: failure()
       with:
         name: logs
         path: test/logs/
 
-    # - name: Generate code coverage
+    - name: Generate code coverage
-    #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
+      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-    #   run: |
+      run: |
-    #     lcov --directory . --capture --output-file coverage.info # capture coverage info
+        lcov --directory . --capture --output-file coverage.info # capture coverage info
-    #     lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
+        lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
-    #     lcov --list coverage.info #debug info
+        lcov --list coverage.info #debug info
     
     # # Uploading report to CodeCov
     # - name: Upload code coverage
     #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-    #   uses: codecov/codecov-action@v4
+    #   uses: codecov/codecov-action@v1
     #   with:
     #     files: coverage.info
     #     name: codecov-osrm-backend
     #     fail_ci_if_error: true
     #     verbose: true
+    - name: Check Apple Silicon binary
+      if: ${{  matrix.ENABLE_APPLE_SILICON == 'ON' }}
+      run: |
+        ARCH=$(file ./lib/binding/node_osrm.node | awk '{printf $NF}')
+        if [[ "$ARCH" != "arm64" ]]; then
+          file ./lib/binding/node_osrm.node
+          >&2 echo "Wrong architecture!"
+          exit 1
+        fi
     - name: Build Node package
       if: ${{ matrix.build_node_package }}
       run: ./scripts/ci/node_package.sh
@@ -652,135 +626,9 @@ jobs:
         omitNameDuringUpdate: true
         replacesArtifacts: true
         token: ${{ secrets.GITHUB_TOKEN }}
-    - name: Show CCache statistics
-      run: |
-        ccache -p
-        ccache -s
-
-  benchmarks:
-    if: github.event_name == 'pull_request'
-    needs: [format-taginfo-docs]
-    runs-on: self-hosted
-    env:
-      CCOMPILER: clang-16
-      CXXCOMPILER: clang++-16
-      CC: clang-16
-      CXX: clang++-16
-      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      PR_NUMBER: ${{ github.event.pull_request.number }}
-      GITHUB_REPOSITORY: ${{ github.repository }}
-      RUN_BIG_BENCHMARK: ${{ contains(github.event.pull_request.labels.*.name, 'Performance') }}
-    steps: 
-      - name: 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: Prepare data
-        run: |
-          if [ "$RUN_BIG_BENCHMARK" = "true" ]; then
-              rm -rf ~/data.osm.pbf
-              wget http://download.geofabrik.de/europe/poland-latest.osm.pbf -O ~/data.osm.pbf --quiet
-              gunzip -c ./pr/test/data/poland_gps_traces.csv.gz > ~/gps_traces.csv
-          else
-              if [ ! -f "~/data.osm.pbf" ]; then
-                wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf -O ~/data.osm.pbf
-              else
-                echo "Using cached data.osm.pbf"
-              fi
-              gunzip -c ./pr/test/data/berlin_gps_traces.csv.gz > ~/gps_traces.csv
-          fi
-      - name: Prepare environment
-        run: |
-          echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
-          mkdir -p $HOME/.ccache
-          ccache --zero-stats
-          ccache --max-size=256M
-      - name: Checkout Base Branch
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.base.ref }}
-          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 ..
-          make -j$(nproc)
-          make -j$(nproc) benchmarks
-          cd ..
-          make -C test/data 
-      - name: Build PR Branch
-        run: |
-          cd pr
-          npm ci --ignore-scripts
-          cd ..
-          mkdir -p pr/build
-          cd pr/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
-          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
-      - name: Post Benchmark Results
-        run: |
-          python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
-      - name: Show CCache statistics
-        run: |
-          ccache -p
-          ccache -s
 
   ci-complete:
     runs-on: ubuntu-22.04
-    needs: [build-test-publish, docker-image-matrix, windows-release-node, benchmarks]
+    needs: [build-test-publish, docker-image, windows-release-node]
     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,64 +1,21 @@
 # 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)
       - ADDED: Add support for disabling feature datasets. [#6666](https://github.com/Project-OSRM/osrm-backend/pull/6666)
       - ADDED: Add support for opposite approach request parameter. [#6842](https://github.com/Project-OSRM/osrm-backend/pull/6842)
       - ADDED: Add support for accessing edge flags in `process_segment` [#6658](https://github.com/Project-OSRM/osrm-backend/pull/6658)
     - Build:
-      - CHANGED: Upgrade clang-format to version 15. [#6919](https://github.com/Project-OSRM/osrm-backend/pull/6919)
-      - CHANGED: Use Debian Bookworm as base Docker image [#6904](https://github.com/Project-OSRM/osrm-backend/pull/6904)
-      - CHANGED: Upgrade CI actions to latest versions [#6893](https://github.com/Project-OSRM/osrm-backend/pull/6893)
-      - CHANGED:  Remove outdated warnings #6894 [#6894](https://github.com/Project-OSRM/osrm-backend/pull/6894)
       - ADDED: Add CI job which builds OSRM with gcc 12. [#6455](https://github.com/Project-OSRM/osrm-backend/pull/6455)
       - CHANGED: Upgrade to clang-tidy 15. [#6439](https://github.com/Project-OSRM/osrm-backend/pull/6439)
       - CHANGED: Update actions/cache to v3. [#6420](https://github.com/Project-OSRM/osrm-backend/pull/6420)
       - REMOVED: Drop support of Node 12 & 14. [#6431](https://github.com/Project-OSRM/osrm-backend/pull/6431)
       - ADDED: Add 'load directly' mode to default Cucumber test suite. [#6663](https://github.com/Project-OSRM/osrm-backend/pull/6663)
-      - CHANGED: Fix compilation for Boost 1.85.0 [#6856](https://github.com/Project-OSRM/osrm-backend/pull/6856)
       - CHANGED: Drop support for Node 16 [#6855](https://github.com/Project-OSRM/osrm-backend/pull/6855)
-      - REMOVED: Remove unused AppVeyor files [#6860](https://github.com/Project-OSRM/osrm-backend/pull/6860)
-      - CHANGED: Upgrade clang-format to version 15 [#6859](https://github.com/Project-OSRM/osrm-backend/pull/6859)
     - 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)
-      - CHANGED: Use custom struct instead of std::pair in QueryHeap. [#6921](https://github.com/Project-OSRM/osrm-backend/pull/6921)
-      - CHANGED: Use std::string_view::starts_with instead of boost::starts_with. [#6918](https://github.com/Project-OSRM/osrm-backend/pull/6918)
-      - CHANGED: Get rid of boost::math::constants::* and M_PI in favor of std::numbers. [#6916](https://github.com/Project-OSRM/osrm-backend/pull/6916)
-      - CHANGED: Make constants in PackedVector constexpr. [#6917](https://github.com/Project-OSRM/osrm-backend/pull/6917)
-      - CHANGED: Use std::variant instead of mapbox::util::variant. [#6903](https://github.com/Project-OSRM/osrm-backend/pull/6903)
-      - CHANGED: Bump rapidjson to version f9d53419e912910fd8fa57d5705fa41425428c35 [#6906](https://github.com/Project-OSRM/osrm-backend/pull/6906)
-      - CHANGED: Bump mapbox/variant to version 1.2.0 [#6898](https://github.com/Project-OSRM/osrm-backend/pull/6898)
-      - CHANGED: Avoid copy of std::function-based callback in path unpacking [#6895](https://github.com/Project-OSRM/osrm-backend/pull/6895)
-      - CHANGED: Replace boost::hash by std::hash [#6892](https://github.com/Project-OSRM/osrm-backend/pull/6892)
-      - CHANGED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551)
-      - CHANGED: Replace boost::filesystem with std::filesystem [#6432](https://github.com/Project-OSRM/osrm-backend/pull/6432)
-      - CHANGED: Update Conan Boost version to 1.85.0. [#6868](https://github.com/Project-OSRM/osrm-backend/pull/6868)
       - FIXED: Fix an error in a RouteParameters AnnotationsType operator overload. [#6646](https://github.com/Project-OSRM/osrm-backend/pull/6646)
       - ADDED: Add support for "unlimited" to be passed as a value for the default-radius and max-matching-radius flags. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
       - CHANGED: Allow -1.0 as unlimited for default_radius value. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
@@ -80,17 +37,10 @@
       - 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)
       - FIXED: Fix bug when searching for maneuver overrides [#6739](https://github.com/Project-OSRM/osrm-backend/pull/6739)
-      - FIXED: Remove force-loop checks for routes with u-turns [#6858](https://github.com/Project-OSRM/osrm-backend/pull/6858)
-      - FIXED: Correctly check runtime search conditions for forcing routing steps [#6866](https://github.com/Project-OSRM/osrm-backend/pull/6866)
-    - Map Matching:
-      - CHANGED: Optimise path distance calculation in MLD map matching even more. [#6884](https://github.com/Project-OSRM/osrm-backend/pull/6884)
-      - CHANGED: Optimise path distance calculation in MLD map matching. [#6876](https://github.com/Project-OSRM/osrm-backend/pull/6876)
-      - CHANGED: Optimise R-tree queries in the case of map matching. [#6881](https://github.com/Project-OSRM/osrm-backend/pull/6876)
     - Debug tiles:
       - FIXED: Ensure speed layer features have unique ids. [#6726](https://github.com/Project-OSRM/osrm-backend/pull/6726)
 

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.18)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
@@ -31,48 +31,35 @@ 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)
     message(FATAL_ERROR "ENABLE_CLANG_TIDY is ON but clang-tidy is not found!")
   else()
     message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
-    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
+    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*")
   endif()
 endif()
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 # be compatible with version handling before cmake 3.x
+if (POLICY CMP0048)
+  cmake_policy(SET CMP0048 OLD)
+endif()
 if (POLICY CMP0057)
   cmake_policy(SET CMP0057 NEW)
 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")
@@ -131,15 +118,15 @@ include(GNUInstallDirs)
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
   message(STATUS "Building on a 64 bit system")
 else()
-  message(FATAL_ERROR "Building on a 32 bit system is not supported")
+  message(STATUS "Building on a 32 bit system")
 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-3.3.0/include)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/variant/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,10 +212,21 @@ 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")
-    message(ERROR "ENABLE_COVERAGE=ON only makes sense with a Debug build")
+    message(ERROR "ENABLE_COVERAGE=ON only make sense with a Debug build")
   endif()
   message(STATUS "Enabling coverage")
   set(MAYBE_COVERAGE_LIBRARIES "-lgcov")
@@ -272,6 +270,7 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
   add_dependency_defines(-D_CRT_SECURE_NO_WARNINGS)
   add_dependency_defines(-DNOMINMAX) # avoid min and max macros that can break compilation
+  add_dependency_defines(-D_USE_MATH_DEFINES) #needed for M_PI with cmath.h
   add_dependency_defines(-D_WIN32_WINNT=0x0501)
   add_dependency_defines(-DXML_STATIC)
   find_library(ws2_32_LIBRARY_PATH ws2_32)
@@ -296,7 +295,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)
 
@@ -314,7 +312,7 @@ add_subdirectory(${FLATBUFFERS_SRC_DIR}
         ${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-build
         EXCLUDE_FROM_ALL)
 
-set(FMT_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/fmt/include")
+set(FMT_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/fmt-9.1.0/include")
 add_compile_definitions(FMT_HEADER_ONLY)
 include_directories(SYSTEM ${FMT_INCLUDE_DIR})
 
@@ -335,14 +333,22 @@ if(ENABLE_CONAN)
 
   conan_check(REQUIRED)
 
-  set(CONAN_BOOST_VERSION "1.85.0@#14265ec82b25d91305bbb3b30d3357f8")
+  set(CONAN_BOOST_VERSION "1.79.0@#96e4902111a2e343a8ba0aa95391bb58")
   set(CONAN_BZIP2_VERSION "1.0.8@#d1b2d5816f25865acf978501dff1f897")
-  set(CONAN_EXPAT_VERSION "2.6.2@#2d385d0d50eb5561006a7ff9e356656b")
+  set(CONAN_EXPAT_VERSION "2.2.10@#916908d4a570ad839edd25322c3268cd")
-  set(CONAN_LUA_VERSION "5.4.6@#658d6089093cf01992c2737ab2e96763")
+  set(CONAN_LUA_VERSION "5.4.4@#3ec62efc37cd0a5d80b9e5cb35277360")
-  set(CONAN_TBB_VERSION "2021.12.0@#e56e5b44be8d690530585dd3634c0106")
+  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 +361,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 +392,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 +472,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 +482,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 +505,7 @@ endif()
 
 set(EXTRACTOR_LIBRARIES
     ${BZIP2_LIBRARIES}
+    ${Boost_REGEX_LIBRARY}
     ${BOOST_BASE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     ${EXPAT_LIBRARIES}
@@ -593,6 +610,7 @@ if (BUILD_ROUTED)
   set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 endif()
 
+file(GLOB VariantGlob third_party/variant/include/mapbox/*.hpp)
 file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
 file(GLOB LibraryGlob include/osrm/*.hpp)
 file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
@@ -612,6 +630,7 @@ install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
 install(FILES ${LibraryGlob} DESTINATION include/osrm)
 install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
 install(FILES ${ApiHeader} DESTINATION include/osrm/engine/api)
+install(FILES ${VariantGlob} DESTINATION include/mapbox)
 install(FILES ${FlatbuffersGlob} DESTINATION include/flatbuffers)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)

CONTRIBUTING.md

@@ -10,7 +10,7 @@ You can add a :+1: emoji reaction to the issue if you want to express interest i
 
 # Developer
 
-We use `clang-format` version `15` to consistently format the code base. There is a helper script under `scripts/format.sh`.
+We use `clang-format` version `3.8` to consistently format the code base. There is a helper script under `scripts/format.sh`.
 The format is automatically checked by the `mason-linux-release` job of a Travis CI build.
 To save development time a local hook `.git/hooks/pre-push`
 ```

README.md

@@ -15,7 +15,7 @@ The following services are available via HTTP API, C++ library interface and Nod
 
 To quickly try OSRM use our [demo server](http://map.project-osrm.org) which comes with both the backend and a frontend on top.
 
-For a quick introduction about how the road network is represented in OpenStreetMap and how to map specific road network features have a look at [the OSM wiki on routing](https://wiki.openstreetmap.org/wiki/Routing) or [this guide about mapping for navigation](https://web.archive.org/web/20221206013651/https://labs.mapbox.com/mapping/mapping-for-navigation/).
+For a quick introduction about how the road network is represented in OpenStreetMap and how to map specific road network features have a look at [this guide about mapping for navigation](https://www.mapbox.com/mapping/mapping-for-navigation/).
 
 Related [Project-OSRM](https://github.com/Project-OSRM) repositories:
 - [osrm-frontend](https://github.com/Project-OSRM/osrm-frontend) - User-facing frontend with map. The demo server runs this on top of the backend

appveyor.yml

@@ -0,0 +1,15 @@
+os: Visual Studio 2019
+
+# clone directory
+clone_folder: c:\projects\osrm
+
+platform: x64
+
+# no-op for the time being until someone with access to GitHub checks settings will remove integration with AppVeyor
+# https://github.com/Project-OSRM/osrm-backend/pull/6312#issuecomment-1217237055 
+build_script:
+  - EXIT 0
+
+branches:
+  only:
+    - master

build-local.bat

@@ -0,0 +1,32 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+SET PLATFORM=x64
+SET CONFIGURATION=Release
+::SET LOCAL_DEV=1
+
+FOR /F "tokens=*" %%i in ('git rev-parse --abbrev-ref HEAD') do SET APPVEYOR_REPO_BRANCH=%%i
+ECHO APPVEYOR_REPO_BRANCH^: %APPVEYOR_REPO_BRANCH%
+
+SET PATH=C:\Program Files\7-Zip;%PATH%
+
+powershell Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted -Force
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+CALL appveyor-build.bat
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+GOTO DONE
+
+
+:ERROR
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ECHO ERRORLEVEL^: %ERRORLEVEL%
+SET EL=%ERRORLEVEL%
+
+:DONE
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+EXIT /b %EL%

cmake/conan.cmake

@@ -55,7 +55,7 @@ function(_get_msvc_ide_version result)
         set(${result} 15 PARENT_SCOPE)
     elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930)
         set(${result} 16 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1950)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940)
         set(${result} 17 PARENT_SCOPE)
     else()
         message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]")

cmake/warnings.cmake

@@ -50,7 +50,9 @@ add_warning(all)
 add_warning(extra)
 add_warning(pedantic)
 add_warning(error) # treat all warnings as errors
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    add_warning(strict-overflow=2)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
     add_warning(strict-overflow=1)
 endif()
 add_warning(suggest-override)
@@ -64,6 +66,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)
@@ -76,13 +79,15 @@ add_warning(sizeof-array-argument)
 add_warning(switch-bool)
 add_warning(tautological-compare)
 add_warning(trampolines)
-# these warnings are not enabled by default
+no_warning(c++17-extensions)
-# no_warning(name-of-warning)
+# TODO: these warnings are not enabled by default, but we consider them as useful and good to enable in the future
-no_warning(deprecated-comma-subscript)
+no_warning(implicit-int-conversion)
-no_warning(comma-subscript)
+no_warning(implicit-float-conversion)
-no_warning(ambiguous-reversed-operator)
+no_warning(unused-member-function)
-no_warning(restrict)
+no_warning(old-style-cast)
-no_warning(free-nonheap-object)
+no_warning(non-virtual-dtor)
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+no_warning(float-conversion)
-  no_warning(stringop-overflow)
+no_warning(sign-conversion)
-endif()
+no_warning(shorten-64-to-32)
+no_warning(padded)
+no_warning(missing-noreturn)

docker/Dockerfile

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

docker/Dockerfile

@@ -0,0 +1,67 @@
+FROM debian:bullseye-slim as builder
+ARG DOCKER_TAG
+ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
+
+RUN apt-get update && \
+    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
+    libzip-dev libboost1.74-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    ldconfig /usr/local/lib && \
+    git clone --branch v2021.3.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
+    cd oneTBB && \
+    mkdir build && \
+    cd build && \
+    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
+    cmake --build . && \
+    cmake --install .
+
+COPY . /src
+WORKDIR /src
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    echo "Building OSRM ${DOCKER_TAG}" && \
+    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
+    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
+    mkdir -p build && \
+    cd build && \
+    BUILD_TYPE="Release" && \
+    ENABLE_ASSERTIONS="Off" && \
+    BUILD_TOOLS="Off" && \
+    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
+    make -j${NPROC} install && \
+    cd ../profiles && \
+    cp -r * /opt && \
+    strip /usr/local/bin/* && \
+    rm -rf /src
+
+
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
+# Only the content below ends up in the image, this helps remove /src from the image (which is large)
+FROM debian:bullseye-slim as runstage
+
+COPY --from=builder /usr/local /usr/local
+COPY --from=builder /opt /opt
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends libboost-program-options1.74.0 libboost-regex1.74.0 \
+        libboost-date-time1.74.0 libboost-chrono1.74.0 libboost-filesystem1.74.0 \
+        libboost-iostreams1.74.0 libboost-system1.74.0 libboost-thread1.74.0 \
+        expat liblua5.4-0 && \
+    rm -rf /var/lib/apt/lists/* && \
+# add /usr/local/lib to ldconfig to allow loading libraries from there
+    ldconfig /usr/local/lib
+
+RUN /usr/local/bin/osrm-extract --help && \
+    /usr/local/bin/osrm-routed --help && \
+    /usr/local/bin/osrm-contract --help && \
+    /usr/local/bin/osrm-partition --help && \
+    /usr/local/bin/osrm-customize --help
+
+WORKDIR /opt
+
+EXPOSE 5000

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 --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..
-DOCKER_BUILD="docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY} --build-arg DOCKER_TAG=${DOCKER_TAG:?unset} -t ${IMAGE_NAME:?unset} -f"
-
-$DOCKER_BUILD Dockerfile ..
-$DOCKER_BUILD Dockerfile-alpine ..

docs/nodejs/api.md

@@ -21,7 +21,7 @@ var osrm = new OSRM('network.osrm');
 **Parameters**
 
 -   `options` **([Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String))** Options for creating an OSRM object or string to the `.osrm` file. (optional, default `{shared_memory:true}`)
-    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', or 'MLD'. Default is 'CH'.
+    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
                Make sure you prepared the dataset with the correct toolchain.
     -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
                This requires you to run `osrm-datastore` prior to creating an `OSRM` object.

example/example.cpp

@@ -57,15 +57,15 @@ int main(int argc, const char *argv[])
     // Execute routing request, this does the heavy lifting
     const auto status = osrm.Route(params, result);
 
-    auto &json_result = std::get<json::Object>(result);
+    auto &json_result = result.get<json::Object>();
     if (status == Status::Ok)
     {
-        auto &routes = std::get<json::Array>(json_result.values["routes"]);
+        auto &routes = json_result.values["routes"].get<json::Array>();
 
         // Let's just use the first route
-        auto &route = std::get<json::Object>(routes.values.at(0));
+        auto &route = routes.values.at(0).get<json::Object>();
-        const auto distance = std::get<json::Number>(route.values["distance"]).value;
+        const auto distance = route.values["distance"].get<json::Number>().value;
-        const auto duration = std::get<json::Number>(route.values["duration"]).value;
+        const auto duration = route.values["duration"].get<json::Number>().value;
 
         // Warn users if extract does not contain the default coordinates from above
         if (distance == 0 || duration == 0)
@@ -80,8 +80,8 @@ int main(int argc, const char *argv[])
     }
     else if (status == Status::Error)
     {
-        const auto code = std::get<json::String>(json_result.values["code"]).value;
+        const auto code = json_result.values["code"].get<json::String>().value;
-        const auto message = std::get<json::String>(json_result.values["message"]).value;
+        const auto message = json_result.values["message"].get<json::String>().value;
 
         std::cout << "Code: " << code << "\n";
         std::cout << "Message: " << code << "\n";

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/force_step.feature

@@ -1,101 +0,0 @@
-@routing @testbot @via
-Feature: Force routing steps
-    Background:
-        Given the profile "testbot"
-
-    Scenario: Direct routes with waypoints on same edge
-        Given the node map
-            """
-              1   2
-            a-------b
-            |       |
-            d-------c
-            |       |
-            e-------f
-              3   4
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | no     |
-            | ad    | no     |
-            | bc    | no     |
-            | cf    | no     |
-            | dc    | no     |
-            | de    | no     |
-            | ef    | yes    |
-
-        When I route I should get
-            | waypoints | approaches        | weight | route          |
-            | 1,2       |                   | 20     | ab,ab          |
-            | 1,2       | curb curb         | 100    | ab,ad,dc,bc,ab |
-            | 2,1       |                   | 20     | ab,ab          |
-            | 2,1       | opposite opposite | 100    | ab,bc,dc,ad,ab |
-            | 3,4       |                   | 20     | ef,ef          |
-            | 4,3       |                   | 100    | ef,cf,dc,de,ef |
-
-    Scenario: Via routes with waypoints on same edge
-        Given the node map
-            """
-              1   2
-            a-------b
-            |       |
-            d-5-----c
-            |       |
-            e-------f
-              3   4
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | no     |
-            | ad    | no     |
-            | bc    | no     |
-            | cf    | no     |
-            | dc    | no     |
-            | de    | no     |
-            | ef    | yes    |
-
-        When I route I should get
-            | waypoints | approaches                     | weight | route                      |
-            | 5,1,2     |                                | 59.8   | dc,ad,ab,ab,ab             |
-            | 5,1,2     | unrestricted curb curb         | 180.2  | dc,bc,ab,ab,ab,ad,dc,bc,ab |
-            | 5,2,1     |                                | 80.2   | dc,bc,ab,ab,ab             |
-            | 5,2,1     | unrestricted opposite opposite | 159.8  | dc,ad,ab,ab,ab,bc,dc,ad,ab |
-            | 5,3,4     |                                | 59.8   | dc,de,ef,ef,ef             |
-            | 5,4,3     |                                | 159.8  | dc,de,ef,ef,ef,cf,dc,de,ef |
-
-
-    Scenario: [U-turns allowed] Via routes with waypoints on same edge
-        Given the node map
-            """
-              1   2
-            a-------b
-            |       |
-            d-5-----c
-            |       |
-            e-------f
-              3   4
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | no     |
-            | ad    | no     |
-            | bc    | no     |
-            | cf    | no     |
-            | dc    | no     |
-            | de    | no     |
-            | ef    | yes    |
-
-        And the query options
-            | continue_straight | false |
-
-        When I route I should get
-            | waypoints | approaches                     | weight | route                      |
-            | 5,1,2     |                                | 59.8   | dc,ad,ab,ab,ab             |
-            | 5,1,2     | unrestricted curb curb         | 180.2  | dc,bc,ab,ab,ab,ad,dc,bc,ab |
-            | 5,2,1     |                                | 79.8   | dc,ad,ab,ab,ab,ab          |
-            | 5,2,1     | unrestricted opposite opposite | 159.8  | dc,ad,ab,ab,ab,bc,dc,ad,ab |
-            | 5,3,4     |                                | 59.8   | dc,de,ef,ef,ef             |
-            | 5,4,3     |                                | 159.8  | dc,de,ef,ef,ef,cf,dc,de,ef |

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  |
+            | nodes | oneway |
-            | ab    | no     |            |
+            | ab    | no     |
-            | bc    | no     |            |
+            | bc    | no     |
-            | cd    | no     |            |
+            | cd    | no     |
-            | fed   | no     |            |
+            | fed   | no     |
-            | bg    | yes    | small SCC  |
+            | 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 |
+            | nodes | oneway |
-            | ab    | no     |           |
+            | ab    | no     |
-            | bc    | no     |           |
+            | bc    | no     |
-            | cd    | no     |           |
+            | cd    | no     |
-            | fed   | no     |           |
+            | fed   | no     |
-            | ghi   | no     |           |
+            | ghi   | no     |
-            | jkl   | no     |           |
+            | jkl   | no     |
-            | bm    | yes    | small SCC |
+            | 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/contract_excludable_graph.hpp

@@ -61,11 +61,9 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
         // Add all non-core edges to container
         {
             auto non_core_edges = toEdges<QueryEdge>(contractor_graph);
-            auto new_end = std::remove_if(non_core_edges.begin(),
+            auto new_end =
-                                          non_core_edges.end(),
+                std::remove_if(non_core_edges.begin(), non_core_edges.end(), [&](const auto &edge) {
-                                          [&](const auto &edge) {
+                    return is_shared_core[edge.source] && is_shared_core[edge.target];
-                                              return is_shared_core[edge.source] &&
-                                                     is_shared_core[edge.target];
                 });
             non_core_edges.resize(new_end - non_core_edges.begin());
             edge_container.Insert(std::move(non_core_edges));
@@ -77,8 +75,8 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
         }
 
         // Extract core graph for further contraction
-        shared_core_graph = contractor_graph.Filter([&is_shared_core](const NodeID node)
+        shared_core_graph = contractor_graph.Filter(
-                                                    { return is_shared_core[node]; });
+            [&is_shared_core](const NodeID node) { return is_shared_core[node]; });
     }
 
     for (const auto &filter : filters)

include/contractor/contracted_edge_container.hpp

@@ -89,10 +89,7 @@ struct ContractedEdgeContainer
 
         // Remove all edges that are contained in the old set of edges and set the appropriate flag.
         auto new_end =
-            std::remove_if(new_edges.begin(),
+            std::remove_if(new_edges.begin(), new_edges.end(), [&](const QueryEdge &edge) {
-                           new_edges.end(),
-                           [&](const QueryEdge &edge)
-                           {
                 // check if the new edge would be sorted before the currend old edge
                 // if so it is not contained yet in the set of old edges
                 if (edge_iter == edge_end || mergeCompare(edge, *edge_iter))
@@ -135,10 +132,10 @@ struct ContractedEdgeContainer
         // enforce sorting for next merge step
         std::vector<unsigned> ordering(edges_size);
         std::iota(ordering.begin(), ordering.end(), 0);
-        tbb::parallel_sort(ordering.begin(),
+        tbb::parallel_sort(
-                           ordering.end(),
+            ordering.begin(), ordering.end(), [&](const auto lhs_idx, const auto rhs_idx) {
-                           [&](const auto lhs_idx, const auto rhs_idx)
+                return mergeCompare(edges[lhs_idx], edges[rhs_idx]);
-                           { return mergeCompare(edges[lhs_idx], edges[rhs_idx]); });
+            });
         auto permutation = util::orderingToPermutation(ordering);
 
         util::inplacePermutation(edges.begin(), edges.end(), permutation);

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

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

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

@@ -122,8 +122,7 @@ class CellCustomizer
         for (std::size_t level = 1; level < partition.GetNumberOfLevels(); ++level)
         {
             tbb::parallel_for(tbb::blocked_range<std::size_t>(0, partition.GetNumberOfCells(level)),
-                              [&](const tbb::blocked_range<std::size_t> &range)
+                              [&](const tbb::blocked_range<std::size_t> &range) {
-                              {
                                   auto &heap = heaps.local();
                                   for (auto id = range.begin(), end = range.end(); id != end; ++id)
                                   {

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

@@ -40,10 +40,10 @@ class BaseAPI
         util::json::Array waypoints;
         waypoints.values.resize(parameters.coordinates.size());
 
-        boost::range::transform(waypoint_candidates,
+        boost::range::transform(
+            waypoint_candidates,
             waypoints.values.begin(),
-                                [this](const PhantomNodeCandidates &candidates)
+            [this](const PhantomNodeCandidates &candidates) { return MakeWaypoint(candidates); });
-                                { return MakeWaypoint(candidates); });
         return waypoints;
     }
 
@@ -104,8 +104,9 @@ class BaseAPI
         std::transform(waypoint_candidates.begin(),
                        waypoint_candidates.end(),
                        waypoints.begin(),
-                       [this, builder](const PhantomNodeCandidates &candidates)
+                       [this, builder](const PhantomNodeCandidates &candidates) {
-                       { return MakeWaypoint(builder, candidates)->Finish(); });
+                           return MakeWaypoint(builder, candidates)->Finish();
+                       });
         return builder->CreateVector(waypoints);
     }
 

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<boost::optional<Hint>> hints;
-    std::vector<std::optional<double>> radiuses;
+    std::vector<boost::optional<double>> radiuses;
-    std::vector<std::optional<Bearing>> bearings;
+    std::vector<boost::optional<Bearing>> bearings;
-    std::vector<std::optional<Approach>> approaches;
+    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<boost::optional<Hint>> hints_ = {},
-                   std::vector<std::optional<double>> radiuses_ = {},
+                   std::vector<boost::optional<double>> radiuses_ = {},
-                   std::vector<std::optional<Bearing>> bearings_ = {},
+                   std::vector<boost::optional<Bearing>> bearings_ = {},
-                   std::vector<std::optional<Approach>> approaches_ = {},
+                   std::vector<boost::optional<Approach>> approaches_ = {},
                    bool generate_hints_ = true,
                    std::vector<std::string> exclude = {},
                    const SnappingType snapping_ = SnappingType::Default)
@@ -112,8 +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)
                                {
                                    return bearing_and_range->IsValid();

include/engine/api/base_result.hpp

@@ -2,7 +2,7 @@
 #define ENGINE_API_BASE_RESULT_HPP
 
 #include <flatbuffers/flatbuffers.h>
-#include <variant>
+#include <mapbox/variant.hpp>
 
 #include <string>
 
@@ -10,7 +10,8 @@
 
 namespace osrm::engine::api
 {
-using ResultT = std::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
+using ResultT =
+    mapbox::util::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
 } // namespace osrm::engine::api
 
 #endif

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>
@@ -41,7 +41,7 @@ inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection
     return intersection.lanes.lanes_in_turn > 0;
 }
 
-util::json::Value coordinateToLonLat(const util::Coordinate &coordinate);
+util::json::Array coordinateToLonLat(const util::Coordinate &coordinate);
 
 /**
  * Ensures that a bearing value is a whole number, and clamped to the range 0-359
@@ -79,7 +79,7 @@ util::json::Object makeGeoJSONGeometry(ForwardIter begin, ForwardIter end)
         coordinates.values.push_back(location);
         coordinates.values.push_back(location);
     }
-    geojson.values["coordinates"] = util::json::Value{std::move(coordinates)};
+    geojson.values["coordinates"] = std::move(coordinates);
 
     return geojson;
 }
@@ -90,7 +90,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo
 
 util::json::Object makeRoute(const guidance::Route &route,
                              util::json::Array legs,
-                             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

@@ -30,14 +30,14 @@ class MatchAPI final : public RouteAPI
                       osrm::engine::api::ResultT &response) const
     {
         BOOST_ASSERT(sub_matchings.size() == sub_routes.size());
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
         {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
             MakeResponse(sub_matchings, sub_routes, fb_result);
         }
         else
         {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
             MakeResponse(sub_matchings, sub_routes, json_result);
         }
     }
@@ -52,10 +52,9 @@ class MatchAPI final : public RouteAPI
             data_version_string = fb_result.CreateString(data_timestamp);
         }
 
-        auto response = MakeFBResponse(sub_routes,
+        auto response = MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_matchings]() {
-                                       fb_result,
+            return MakeTracepoints(fb_result, sub_matchings);
-                                       [this, &fb_result, &sub_matchings]()
+        });
-                                       { return MakeTracepoints(fb_result, sub_matchings); });
 
         if (!data_timestamp.empty())
         {
@@ -77,19 +76,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);
+            route.values["confidence"] = sub_matchings[index].confidence;
-            routes.values.emplace_back(std::move(route));
+            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["matchings"] = std::move(routes);
-        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;
         }
     }
 
@@ -132,13 +131,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 +164,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 +185,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["matchings_index"] = matching_index.sub_matching_index;
-            waypoint.values.emplace("waypoint_index", matching_index.point_index);
+            waypoint.values["waypoint_index"] = matching_index.point_index;
-            waypoint.values.emplace("alternatives_count",
+            waypoint.values["alternatives_count"] =
                 sub_matchings[matching_index.sub_matching_index]
-                                        .alternatives_count[matching_index.point_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 +216,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

@@ -29,14 +29,14 @@ class NearestAPI final : public BaseAPI
         BOOST_ASSERT(phantom_nodes.size() == 1);
         BOOST_ASSERT(parameters.coordinates.size() == 1);
 
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
         {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
             MakeResponse(phantom_nodes, fb_result);
         }
         else
         {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
             MakeResponse(phantom_nodes, json_result);
         }
     }
@@ -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);
@@ -57,11 +57,11 @@ class NearestAPI final : public BaseAPI
         {
             std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
             waypoints.resize(phantom_nodes.front().size());
-            std::transform(phantom_nodes.front().begin(),
+            std::transform(
+                phantom_nodes.front().begin(),
                 phantom_nodes.front().end(),
                 waypoints.begin(),
-                           [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance)
+                [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance) {
-                           {
                     auto &phantom_node = phantom_with_distance.phantom_node;
 
                     auto node_values = MakeNodes(phantom_node);
@@ -94,29 +94,28 @@ class NearestAPI final : public BaseAPI
             std::transform(phantom_nodes.front().begin(),
                            phantom_nodes.front().end(),
                            waypoints.values.begin(),
-                           [this](const PhantomNodeWithDistance &phantom_with_distance)
+                           [this](const PhantomNodeWithDistance &phantom_with_distance) {
-                           {
                                auto &phantom_node = phantom_with_distance.phantom_node;
                                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.push_back(node_values.first);
-                               nodes.values.emplace_back(node_values.second);
+                               nodes.values.push_back(node_values.second);
-                               waypoint.values.emplace("nodes", std::move(nodes));
+                               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

@@ -50,14 +50,14 @@ class RouteAPI : public BaseAPI
     {
         BOOST_ASSERT(!raw_routes.routes.empty());
 
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
         {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
             MakeResponse(raw_routes, waypoint_candidates, fb_result);
         }
         else
         {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
             MakeResponse(raw_routes, waypoint_candidates, json_result);
         }
     }
@@ -77,10 +77,9 @@ class RouteAPI : public BaseAPI
         }
 
         auto response =
-            MakeFBResponse(raw_routes,
+            MakeFBResponse(raw_routes, fb_result, [this, &waypoint_candidates, &fb_result]() {
-                           fb_result,
+                return BaseAPI::MakeWaypoints(&fb_result, waypoint_candidates);
-                           [this, &waypoint_candidates, &fb_result]()
+            });
-                           { return BaseAPI::MakeWaypoints(&fb_result, waypoint_candidates); });
 
         if (!data_timestamp.empty())
         {
@@ -110,14 +109,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["routes"] = std::move(jsRoutes);
-        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;
         }
     }
 
@@ -158,7 +157,7 @@ class RouteAPI : public BaseAPI
     }
 
     template <typename ForwardIter>
-    std::variant<flatbuffers::Offset<flatbuffers::String>,
+    mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
                           flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
     MakeGeometry(flatbuffers::FlatBufferBuilder &builder, ForwardIter begin, ForwardIter end) const
     {
@@ -172,22 +171,17 @@ class RouteAPI : public BaseAPI
         }
         std::vector<fbresult::Position> coordinates;
         coordinates.resize(std::distance(begin, end));
-        std::transform(begin,
+        std::transform(begin, end, coordinates.begin(), [](const Coordinate &c) {
-                       end,
+            return fbresult::Position{static_cast<float>(util::toFloating(c.lon).__value),
-                       coordinates.begin(),
-                       [](const Coordinate &c)
-                       {
-                           return fbresult::Position{
-                               static_cast<float>(util::toFloating(c.lon).__value),
                                       static_cast<float>(util::toFloating(c.lat).__value)};
         });
         return builder.CreateVectorOfStructs(coordinates);
     }
 
-    std::optional<util::json::Value>
+    boost::optional<util::json::Value>
-    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
+    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 +334,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::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
         auto route = guidance::assembleRoute(legs);
 
         // Fill legs
@@ -360,8 +354,9 @@ class RouteAPI : public BaseAPI
                 std::transform(leg.steps.begin(),
                                leg.steps.end(),
                                legSteps.begin(),
-                               [this, &fb_result, &leg_geometry](auto &step)
+                               [this, &fb_result, &leg_geometry](auto &step) {
-                               { return this->MakeFBStep(fb_result, leg_geometry, step); });
+                                   return this->MakeFBStep(fb_result, leg_geometry, step);
+                               });
             }
             auto steps_vector = fb_result.CreateVector(legSteps);
 
@@ -408,7 +403,7 @@ class RouteAPI : public BaseAPI
 
         // Fill geometry
         auto overview = MakeOverview(leg_geometries);
-        std::variant<flatbuffers::Offset<flatbuffers::String>,
+        mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
                               flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
             geometry;
         if (overview)
@@ -426,7 +421,8 @@ class RouteAPI : public BaseAPI
         routeObject.add_legs(legs_vector);
         if (overview)
         {
-            std::visit(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject), geometry);
+            mapbox::util::apply_visitor(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject),
+                                        geometry);
         }
 
         return routeObject.Finish();
@@ -442,18 +438,18 @@ class RouteAPI : public BaseAPI
         if (requested_annotations & RouteParameters::AnnotationsType::Speed)
         {
             double prev_speed = 0;
-            speed = GetAnnotations<float>(
+            speed =
-                fb_result,
+                GetAnnotations<float>(fb_result,
                                       leg_geometry,
-                [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                                      [&prev_speed](const guidance::LegGeometry::Annotation &anno) {
-                {
                                           if (anno.duration < std::numeric_limits<float>::min())
                                           {
                                               return prev_speed;
                                           }
                                           else
                                           {
-                        auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
+                                              auto speed =
+                                                  round(anno.distance / anno.duration * 10.) / 10.;
                                               prev_speed = speed;
                                               return util::json::clamp_float(speed);
                                           }
@@ -463,37 +459,37 @@ class RouteAPI : public BaseAPI
         flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration;
         if (requested_annotations & RouteParameters::AnnotationsType::Duration)
         {
-            duration = GetAnnotations<uint32_t>(fb_result,
+            duration = GetAnnotations<uint32_t>(
-                                                leg_geometry,
+                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                                                [](const guidance::LegGeometry::Annotation &anno)
+                    return anno.duration;
-                                                { return anno.duration; });
+                });
         }
 
         flatbuffers::Offset<flatbuffers::Vector<uint32_t>> distance;
         if (requested_annotations & RouteParameters::AnnotationsType::Distance)
         {
-            distance = GetAnnotations<uint32_t>(fb_result,
+            distance = GetAnnotations<uint32_t>(
-                                                leg_geometry,
+                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                                                [](const guidance::LegGeometry::Annotation &anno)
+                    return anno.distance;
-                                                { return anno.distance; });
+                });
         }
 
         flatbuffers::Offset<flatbuffers::Vector<uint32_t>> weight;
         if (requested_annotations & RouteParameters::AnnotationsType::Weight)
         {
-            weight = GetAnnotations<uint32_t>(fb_result,
+            weight = GetAnnotations<uint32_t>(
-                                              leg_geometry,
+                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                                              [](const guidance::LegGeometry::Annotation &anno)
+                    return anno.weight;
-                                              { return anno.weight; });
+                });
         }
 
         flatbuffers::Offset<flatbuffers::Vector<uint32_t>> datasources;
         if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
         {
-            datasources = GetAnnotations<uint32_t>(fb_result,
+            datasources = GetAnnotations<uint32_t>(
-                                                   leg_geometry,
+                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                                                   [](const guidance::LegGeometry::Annotation &anno)
+                    return anno.datasource;
-                                                   { return anno.datasource; });
+                });
         }
         std::vector<uint32_t> nodes;
         if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
@@ -643,7 +639,7 @@ class RouteAPI : public BaseAPI
         stepBuilder.add_rotary_pronunciation(rotary_pronunciation_string);
         stepBuilder.add_intersections(intersections_vector);
         stepBuilder.add_maneuver(maneuver_buffer);
-        std::visit(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
+        mapbox::util::apply_visitor(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
         return stepBuilder.Finish();
     };
 
@@ -657,8 +653,7 @@ class RouteAPI : public BaseAPI
             step.intersections.begin(),
             step.intersections.end(),
             intersections.begin(),
-            [&fb_result, this](const guidance::IntermediateIntersection &intersection)
+            [&fb_result, this](const guidance::IntermediateIntersection &intersection) {
-            {
                 std::vector<flatbuffers::Offset<fbresult::Lane>> lanes;
                 if (json::detail::hasValidLanes(intersection))
                 {
@@ -686,11 +681,11 @@ class RouteAPI : public BaseAPI
                 auto bearings_vector = fb_result.CreateVector(intersection.bearings);
                 std::vector<flatbuffers::Offset<flatbuffers::String>> classes;
                 classes.resize(intersection.classes.size());
-                std::transform(intersection.classes.begin(),
+                std::transform(
+                    intersection.classes.begin(),
                     intersection.classes.end(),
                     classes.begin(),
-                               [&fb_result](const std::string &cls)
+                    [&fb_result](const std::string &cls) { return fb_result.CreateString(cls); });
-                               { return fb_result.CreateString(cls); });
                 auto classes_vector = fb_result.CreateVector(classes);
                 auto entry_vector = fb_result.CreateVector(intersection.entry);
 
@@ -716,18 +711,18 @@ 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::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        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 =
-            std::accumulate(legs.begin(),
+            std::accumulate(legs.begin(), legs.end(), 0, [](const auto &v, const auto &leg) {
-                            legs.end(),
+                return v + leg.steps.size();
-                            0,
+            });
-                            [](const auto &v, const auto &leg) { return v + leg.steps.size(); });
         step_geometries.reserve(total_step_count);
 
         for (const auto idx : util::irange<std::size_t>(0UL, legs.size()))
@@ -738,8 +733,7 @@ class RouteAPI : public BaseAPI
                 legs[idx].steps.begin(),
                 legs[idx].steps.end(),
                 std::back_inserter(step_geometries),
-                [this, &leg_geometry](const guidance::RouteStep &step)
+                [this, &leg_geometry](const guidance::RouteStep &step) {
-                {
                     if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
                     {
                         return static_cast<util::json::Value>(json::makePolyline<100000>(
@@ -783,57 +777,47 @@ class RouteAPI : public BaseAPI
                 if (requested_annotations & RouteParameters::AnnotationsType::Speed)
                 {
                     double prev_speed = 0;
-                    annotation.values.emplace(
+                    annotation.values["speed"] = GetAnnotations(
-                        "speed",
+                        leg_geometry, [&prev_speed](const guidance::LegGeometry::Annotation &anno) {
-                        GetAnnotations(leg_geometry,
-                                       [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                                       {
                             if (anno.duration < std::numeric_limits<double>::min())
                             {
                                 return prev_speed;
                             }
                             else
                             {
-                                               auto speed =
+                                auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
-                                                   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(
+                    annotation.values["duration"] = GetAnnotations(
-                        "duration",
+                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                        GetAnnotations(leg_geometry,
+                            return anno.duration;
-                                       [](const guidance::LegGeometry::Annotation &anno)
+                        });
-                                       { return anno.duration; }));
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Distance)
                 {
-                    annotation.values.emplace(
+                    annotation.values["distance"] = GetAnnotations(
-                        "distance",
+                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                        GetAnnotations(leg_geometry,
+                            return anno.distance;
-                                       [](const guidance::LegGeometry::Annotation &anno)
+                        });
-                                       { return anno.distance; }));
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Weight)
                 {
-                    annotation.values.emplace(
+                    annotation.values["weight"] = GetAnnotations(
-                        "weight",
+                        leg_geometry,
-                        GetAnnotations(leg_geometry,
+                        [](const guidance::LegGeometry::Annotation &anno) { return anno.weight; });
-                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.weight; }));
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
                 {
-                    annotation.values.emplace(
+                    annotation.values["datasources"] = GetAnnotations(
-                        "datasources",
+                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                        GetAnnotations(leg_geometry,
+                            return anno.datasource;
-                                       [](const guidance::LegGeometry::Annotation &anno)
+                        });
-                                       { return anno.datasource; }));
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
                 {
@@ -844,7 +828,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 +844,8 @@ class RouteAPI : public BaseAPI
                             break;
                         datasource_names.values.push_back(std::string(facade.GetDatasourceName(i)));
                     }
-                    metadata.values.emplace("datasource_names", datasource_names);
+                    metadata.values["datasource_names"] = datasource_names;
-                    annotation.values.emplace("metadata", metadata);
+                    annotation.values["metadata"] = metadata;
                 }
 
                 annotations.push_back(std::move(annotation));
@@ -996,10 +980,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
@@ -180,9 +180,9 @@ struct RouteParameters : public BaseParameters
         const auto coordinates_ok = coordinates.size() >= 2;
         const auto base_params_ok = BaseParameters::IsValid();
         const auto valid_waypoints =
-            std::all_of(waypoints.begin(),
+            std::all_of(waypoints.begin(), waypoints.end(), [this](const auto &w) {
-                        waypoints.end(),
+                return w < coordinates.size();
-                        [this](const auto &w) { return w < coordinates.size(); });
+            });
         return coordinates_ok && base_params_ok && valid_waypoints;
     }
 };

include/engine/api/table_api.hpp

@@ -50,14 +50,14 @@ class TableAPI final : public BaseAPI
                  const std::vector<TableCellRef> &fallback_speed_cells,
                  osrm::engine::api::ResultT &response) const
     {
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
         {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
             MakeResponse(tables, candidates, fallback_speed_cells, fb_result);
         }
         else
         {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
             MakeResponse(tables, candidates, fallback_speed_cells, json_result);
         }
     }
@@ -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",
+                response.values["destinations"] =
-                                        MakeWaypoints(candidates, parameters.destinations));
+                    MakeWaypoints(candidates, parameters.destinations);
             }
         }
 
         if (parameters.annotations & TableParameters::AnnotationsType::Duration)
         {
-            response.values.emplace(
+            response.values["durations"] =
-                "durations",
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
-                MakeDurationTable(tables.first, number_of_sources, number_of_destinations));
         }
 
         if (parameters.annotations & TableParameters::AnnotationsType::Distance)
         {
-            response.values.emplace(
+            response.values["distances"] =
-                "distances",
+                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations);
-                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",
+            response.values["fallback_speed_cells"] = MakeEstimatesTable(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;
         }
     }
 
@@ -248,8 +245,9 @@ class TableAPI final : public BaseAPI
 
         boost::range::transform(candidates,
                                 std::back_inserter(waypoints),
-                                [this, &builder](const PhantomNodeCandidates &candidates)
+                                [this, &builder](const PhantomNodeCandidates &candidates) {
-                                { return BaseAPI::MakeWaypoint(&builder, candidates)->Finish(); });
+                                    return BaseAPI::MakeWaypoint(&builder, candidates)->Finish();
+                                });
         return builder.CreateVector(waypoints);
     }
 
@@ -263,8 +261,7 @@ class TableAPI final : public BaseAPI
         boost::range::transform(
             indices,
             std::back_inserter(waypoints),
-            [this, &builder, &candidates](const std::size_t idx)
+            [this, &builder, &candidates](const std::size_t idx) {
-            {
                 BOOST_ASSERT(idx < candidates.size());
                 return BaseAPI::MakeWaypoint(&builder, candidates[idx])->Finish();
             });
@@ -277,11 +274,8 @@ class TableAPI final : public BaseAPI
     {
         std::vector<float> distance_table;
         distance_table.resize(values.size());
-        std::transform(values.begin(),
+        std::transform(
-                       values.end(),
+            values.begin(), values.end(), distance_table.begin(), [](const EdgeDuration duration) {
-                       distance_table.begin(),
-                       [](const EdgeDuration duration)
-                       {
                 if (duration == MAXIMAL_EDGE_DURATION)
                 {
                     return 0.;
@@ -297,11 +291,8 @@ class TableAPI final : public BaseAPI
     {
         std::vector<float> duration_table;
         duration_table.resize(values.size());
-        std::transform(values.begin(),
+        std::transform(
-                       values.end(),
+            values.begin(), values.end(), duration_table.begin(), [](const EdgeDistance distance) {
-                       duration_table.begin(),
-                       [](const EdgeDistance distance)
-                       {
                 if (distance == INVALID_EDGE_DISTANCE)
                 {
                     return 0.;
@@ -317,10 +308,8 @@ class TableAPI final : public BaseAPI
     {
         std::vector<uint32_t> fb_table;
         fb_table.reserve(fallback_speed_cells.size());
-        std::for_each(fallback_speed_cells.begin(),
+        std::for_each(
-                      fallback_speed_cells.end(),
+            fallback_speed_cells.begin(), fallback_speed_cells.end(), [&](const auto &cell) {
-                      [&](const auto &cell)
-                      {
                 fb_table.push_back(cell.row);
                 fb_table.push_back(cell.column);
             });
@@ -336,8 +325,9 @@ class TableAPI final : public BaseAPI
 
         boost::range::transform(candidates,
                                 std::back_inserter(json_waypoints.values),
-                                [this](const PhantomNodeCandidates &candidates)
+                                [this](const PhantomNodeCandidates &candidates) {
-                                { return BaseAPI::MakeWaypoint(candidates); });
+                                    return BaseAPI::MakeWaypoint(candidates);
+                                });
         return json_waypoints;
     }
 
@@ -348,8 +338,7 @@ class TableAPI final : public BaseAPI
         json_waypoints.values.reserve(indices.size());
         boost::range::transform(indices,
                                 std::back_inserter(json_waypoints.values),
-                                [this, &candidates](const std::size_t idx)
+                                [this, &candidates](const std::size_t idx) {
-                                {
                                     BOOST_ASSERT(idx < candidates.size());
                                     return BaseAPI::MakeWaypoint(candidates[idx]);
                                 });
@@ -370,8 +359,7 @@ class TableAPI final : public BaseAPI
             std::transform(row_begin_iterator,
                            row_end_iterator,
                            json_row.values.begin(),
-                           [](const EdgeDuration duration)
+                           [](const EdgeDuration duration) {
-                           {
                                if (duration == MAXIMAL_EDGE_DURATION)
                                {
                                    return util::json::Value(util::json::Null());
@@ -380,8 +368,7 @@ class TableAPI final : public BaseAPI
                                return util::json::Value(
                                    util::json::Number(from_alias<double>(duration) / 10.));
                            });
-
+            json_table.values.push_back(std::move(json_row));
-            json_table.values.push_back(util::json::Value{json_row});
         }
         return json_table;
     }
@@ -400,8 +387,7 @@ class TableAPI final : public BaseAPI
             std::transform(row_begin_iterator,
                            row_end_iterator,
                            json_row.values.begin(),
-                           [](const EdgeDistance distance)
+                           [](const EdgeDistance distance) {
-                           {
                                if (distance == INVALID_EDGE_DISTANCE)
                                {
                                    return util::json::Value(util::json::Null());
@@ -410,7 +396,7 @@ class TableAPI final : public BaseAPI
                                return util::json::Value(util::json::Number(
                                    std::round(from_alias<double>(distance) * 10) / 10.));
                            });
-            json_table.values.push_back(util::json::Value{json_row});
+            json_table.values.push_back(std::move(json_row));
         }
         return json_table;
     }
@@ -420,16 +406,11 @@ class TableAPI final : public BaseAPI
     {
         util::json::Array json_table;
         std::for_each(
-            fallback_speed_cells.begin(),
+            fallback_speed_cells.begin(), fallback_speed_cells.end(), [&](const auto &cell) {
-            fallback_speed_cells.end(),
-            [&](const auto &cell)
-            {
                 util::json::Array row;
-                util::json::Value jCellRow{util::json::Number(static_cast<double>(cell.row))};
+                row.values.push_back(util::json::Number(cell.row));
-                util::json::Value jCellColumn{util::json::Number(static_cast<double>(cell.column))};
+                row.values.push_back(util::json::Number(cell.column));
-                row.values.push_back(jCellRow);
+                json_table.values.push_back(std::move(row));
-                row.values.push_back(jCellColumn);
-                json_table.values.push_back(util::json::Value{row});
             });
         return json_table;
     }

include/engine/api/trip_api.hpp

@@ -27,14 +27,14 @@ class TripAPI final : public RouteAPI
     {
         BOOST_ASSERT(sub_trips.size() == sub_routes.size());
 
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
         {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
             MakeResponse(sub_trips, sub_routes, candidates, fb_result);
         }
         else
         {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
             MakeResponse(sub_trips, sub_routes, candidates, json_result);
         }
     }
@@ -50,10 +50,10 @@ class TripAPI final : public RouteAPI
             data_version_string = fb_result.CreateString(data_timestamp);
         }
 
-        auto response = MakeFBResponse(sub_routes,
+        auto response =
-                                       fb_result,
+            MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_trips, &candidates]() {
-                                       [this, &fb_result, &sub_trips, &candidates]()
+                return MakeWaypoints(fb_result, sub_trips, candidates);
-                                       { return MakeWaypoints(fb_result, sub_trips, candidates); });
+            });
 
         if (!data_timestamp.empty())
         {
@@ -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["trips"] = std::move(routes);
-        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;
         }
     }
 
@@ -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["trips_index"] = trip_index.sub_trip_index;
-            waypoint.values.emplace("waypoint_index", trip_index.point_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;
+    std::size_t bytes_to_pad{0};
-    encoded.reserve(((size + 2) / 3) * 4);
 
-    auto padding = (3 - size % 3) % 3;
+    while (bytes.size() % 3 != 0)
-
-    BOOST_ASSERT(padding == 0 || padding == 1 || padding == 2);
-
-    for (auto itr = detail::Base64FromBinary(first); itr != detail::Base64FromBinary(first + size);
-         ++itr)
     {
-        encoded.push_back(*itr);
+        bytes_to_pad += 1;
+        bytes.push_back(0);
     }
 
-    for (size_t index = 0; index < padding; ++index)
+    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");
-        encoded.push_back('=');
-    }
 
-    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/algorithm_datafacade.hpp

@@ -55,7 +55,7 @@ template <> class AlgorithmDataFacade<CH>
 
     virtual EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
                                     const NodeID edge_based_node_to,
-                                    const std::function<bool(const EdgeData &)> &filter) const = 0;
+                                    const std::function<bool(EdgeData)> filter) const = 0;
 };
 
 template <> class AlgorithmDataFacade<MLD>

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -130,10 +130,9 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
             edge_based_node_from, edge_based_node_to, result);
     }
 
-    EdgeID
+    EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
-    FindSmallestEdge(const NodeID edge_based_node_from,
                             const NodeID edge_based_node_to,
-                     const std::function<bool(const EdgeData &)> &filter) const override final
+                            std::function<bool(EdgeData)> filter) const override final
     {
         return m_query_graph.FindSmallestEdge(edge_based_node_from, edge_based_node_to, filter);
     }
@@ -177,7 +176,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,33 +368,33 @@ 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
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
         return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, max_distance, bearing, use_all_edges);
+            input_coordinate, approach, boost::none, max_distance, bearing, use_all_edges);
     }
 
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate input_coordinate,
                         const size_t max_results,
-                        const std::optional<double> max_distance,
+                        const boost::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        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 boost::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<Bearing> bearing,
                                                      const Approach approach,
                                                      const bool use_all_edges) const override final
     {
@@ -441,11 +440,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto indexes = extractor::getClassIndexes(class_data);
         std::vector<std::string> classes(indexes.size());
-        std::transform(indexes.begin(),
+        std::transform(indexes.begin(), indexes.end(), classes.begin(), [this](const auto index) {
-                       indexes.end(),
+            return m_profile_properties->GetClassName(index);
-                       classes.begin(),
+        });
-                       [this](const auto index)
-                       { return m_profile_properties->GetClassName(index); });
 
         return classes;
     }
@@ -603,16 +600,10 @@ 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) {
-
+            std::vector<NodeID> sequence(
-        std::for_each(found_range.first,
+                m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_begin,
-                      found_range.second,
+                m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_end);
-                      [&](const auto &override)
-                      {
-                          std::vector<NodeID> sequence(m_maneuver_override_node_sequences.begin() +
-                                                           override.node_sequence_offset_begin,
-                                                       m_maneuver_override_node_sequences.begin() +
-                                                           override.node_sequence_offset_end);
             results.push_back(extractor::ManeuverOverride{std::move(sequence),
                                                           override.instruction_node,
                                                           override.override_type,

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 boost::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        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 boost::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     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>
 
@@ -53,10 +54,14 @@ namespace osrm::engine
  *
  * In addition, shared memory can be used for datasets loaded with osrm-datastore.
  *
- * You can chose between two algorithms:
+ * You can chose between three algorithms:
  *  - Algorithm::CH
  *      Contraction Hierarchies, extremely fast queries but slow pre-processing. The default right
  * now.
+ *  - Algorithm::CoreCH
+ *      Deprecated, to be removed in v6.0
+ *      Contraction Hierachies with partial contraction for faster pre-processing but slower
+ * queries.
  *  - Algorithm::MLD
  *      Multi Level Dijkstra, moderately fast in both pre-processing and query.
  *
@@ -69,6 +74,7 @@ struct EngineConfig final
     enum class Algorithm
     {
         CH,
+        CoreCH, // Deprecated, will be removed in v6.0
         MLD
     };
 
@@ -79,10 +85,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,8 +12,6 @@
 
 #include "osrm/coordinate.hpp"
 
-#include <optional>
-
 #include <algorithm>
 #include <cmath>
 #include <iterator>
@@ -49,51 +47,20 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         return rtree.SearchInBox(bbox);
     }
 
-    std::vector<PhantomNodeWithDistance>
-    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
-    {
-        auto results = rtree.SearchInRange(
-            input_coordinate,
-            max_distance,
-            [this, approach, &input_coordinate, &bearing_with_range, &use_all_edges, max_distance](
-                const CandidateSegment &segment)
-            {
-                auto invalidDistance =
-                    CheckSegmentDistance(input_coordinate, segment, max_distance);
-                if (invalidDistance)
-                {
-                    return std::make_pair(false, false);
-                }
-                auto valid = CheckSegmentExclude(segment) &&
-                             CheckApproach(input_coordinate, segment, approach) &&
-                             (use_all_edges ? HasValidEdge(segment, *use_all_edges)
-                                            : HasValidEdge(segment)) &&
-                             (bearing_with_range ? CheckSegmentBearing(segment, *bearing_with_range)
-                                                 : std::make_pair(true, true));
-                return valid;
-            });
-        return MakePhantomNodes(input_coordinate, results);
-    }
-
     // Returns max_results nearest PhantomNodes that are valid within the provided parameters.
     // Does not filter by small/big component!
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate input_coordinate,
                         const Approach approach,
-                        const size_t max_results,
+                        const boost::optional<size_t> max_results,
-                        const std::optional<double> max_distance,
+                        const boost::optional<double> max_distance,
-                        const std::optional<Bearing> bearing_with_range,
+                        const boost::optional<Bearing> bearing_with_range,
-                        const std::optional<bool> use_all_edges) const
+                        const boost::optional<bool> use_all_edges) const
     {
         auto results = rtree.Nearest(
             input_coordinate,
             [this, approach, &input_coordinate, &bearing_with_range, &use_all_edges](
-                const CandidateSegment &segment)
+                const CandidateSegment &segment) {
-            {
                 auto valid = CheckSegmentExclude(segment) &&
                              CheckApproach(input_coordinate, segment, approach) &&
                              (use_all_edges ? HasValidEdge(segment, *use_all_edges)
@@ -102,10 +69,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                                                  : std::make_pair(true, true));
                 return valid;
             },
-            [this, &max_distance, max_results, input_coordinate](const std::size_t num_results,
+            [this, &max_distance, &max_results, input_coordinate](const std::size_t num_results,
-                                                                 const CandidateSegment &segment)
+                                                                  const CandidateSegment &segment) {
-            {
+                return (max_results && num_results >= *max_results) ||
-                return (num_results >= max_results) ||
                        (max_distance && max_distance != -1.0 &&
                         CheckSegmentDistance(input_coordinate, segment, *max_distance));
             });
@@ -121,9 +87,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 boost::optional<double> max_distance,
-        const std::optional<Bearing> bearing_with_range,
+        const boost::optional<Bearing> bearing_with_range,
-        const std::optional<bool> use_all_edges) const
+        const boost::optional<bool> use_all_edges) const
     {
         bool has_nearest = false;
         bool has_big_component = false;
@@ -141,8 +107,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
              &big_component_coord,
              &big_component_distance,
              &use_all_edges,
-             &bearing_with_range](const CandidateSegment &segment)
+             &bearing_with_range](const CandidateSegment &segment) {
-            {
                 auto is_big_component = !IsTinyComponent(segment);
                 auto not_nearest =
                     has_nearest && segment.fixed_projected_coordinate != nearest_coord;
@@ -194,8 +159,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 return use_candidate;
             },
             [this, &has_big_component, &max_distance, input_coordinate, &big_component_distance](
-                const std::size_t /*num_results*/, const CandidateSegment &segment)
+                const std::size_t /*num_results*/, const CandidateSegment &segment) {
-            {
                 auto distance = GetSegmentDistance(input_coordinate, segment);
                 auto further_than_big_component = distance > big_component_distance;
                 auto no_more_candidates = has_big_component && further_than_big_component;
@@ -226,14 +190,10 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         PhantomNodeCandidates nearest_phantoms;
         PhantomNodeCandidates big_component_phantoms;
 
-        const auto add_to_candidates =
+        const auto add_to_candidates = [this, &input_coordinate](PhantomNodeCandidates &candidates,
-            [this, &input_coordinate](PhantomNodeCandidates &candidates, const EdgeData data)
+                                                                 const EdgeData data) {
-        {
             auto candidate_it =
-                std::find_if(candidates.begin(),
+                std::find_if(candidates.begin(), candidates.end(), [&](const PhantomNode &node) {
-                             candidates.end(),
-                             [&](const PhantomNode &node)
-                             {
                     return data.forward_segment_id.id == node.forward_segment_id.id &&
                            data.reverse_segment_id.id == node.reverse_segment_id.id;
                 });
@@ -299,10 +259,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             }
         };
 
-        std::for_each(results.begin(),
+        std::for_each(results.begin(), results.end(), [&](const CandidateSegment &segment) {
-                      results.end(),
-                      [&](const CandidateSegment &segment)
-                      {
             if (segment.fixed_projected_coordinate == nearest_coord)
             {
                 add_to_candidates(nearest_phantoms, segment.data);
@@ -324,8 +281,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         std::transform(results.begin(),
                        results.end(),
                        distance_and_phantoms.begin(),
-                       [this, &input_coordinate](const CandidateSegment &segment)
+                       [this, &input_coordinate](const CandidateSegment &segment) {
-                       { return MakePhantomNode(input_coordinate, segment.data); });
+                           return MakePhantomNode(input_coordinate, segment.data);
+                       });
         return distance_and_phantoms;
     }
 
@@ -442,8 +400,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         }
 
         // check phantom node segments validity
-        auto areSegmentsValid = [](auto first, auto last) -> bool
+        auto areSegmentsValid = [](auto first, auto last) -> bool {
-        { return std::find(first, last, INVALID_SEGMENT_WEIGHT) == last; };
+            return std::find(first, last, INVALID_SEGMENT_WEIGHT) == last;
+        };
         bool is_forward_valid_source =
             areSegmentsValid(forward_weights.begin(), forward_weights.end());
         bool is_forward_valid_target = areSegmentsValid(

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

@@ -43,8 +43,7 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
                                                         const bool target_traversed_in_reverse)
 {
     // merges segments with same name id
-    const auto collapse_segments = [](std::vector<NamedSegment> &segments)
+    const auto collapse_segments = [](std::vector<NamedSegment> &segments) {
-    {
         auto out = segments.begin();
         auto end = segments.end();
 
@@ -76,8 +75,7 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
     std::transform(route_data.begin(),
                    route_data.end(),
                    segments.begin(),
-                   [&index, &facade](const PathData &point)
+                   [&index, &facade](const PathData &point) {
-                   {
                        return NamedSegment{point.duration_until_turn,
                                            index++,
                                            facade.GetNameIndex(point.from_edge_based_node)};
@@ -89,10 +87,8 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
     if (target_duration > EdgeDuration{1})
         segments.push_back({target_duration, index++, facade.GetNameIndex(target_node_id)});
     // this makes sure that the segment with the lowest position comes first
-    std::sort(segments.begin(),
+    std::sort(
-              segments.end(),
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
-              [](const NamedSegment &lhs, const NamedSegment &rhs)
-              {
             return lhs.name_id < rhs.name_id ||
                    (lhs.name_id == rhs.name_id && lhs.position < rhs.position);
         });
@@ -100,26 +96,24 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
     segments.resize(new_end - segments.begin());
 
     // Filter out segments with an empty name (name_id == 0)
-    new_end = std::remove_if(segments.begin(),
+    new_end = std::remove_if(segments.begin(), segments.end(), [](const NamedSegment &segment) {
-                             segments.end(),
+        return segment.name_id == 0;
-                             [](const NamedSegment &segment) { return segment.name_id == 0; });
+    });
     segments.resize(new_end - segments.begin());
 
     // sort descending
-    std::sort(segments.begin(),
+    std::sort(
-              segments.end(),
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
-              [](const NamedSegment &lhs, const NamedSegment &rhs)
-              {
             return lhs.duration > rhs.duration ||
                    (lhs.duration == rhs.duration && lhs.position < rhs.position);
         });
 
     // make sure the segments are sorted by position
     segments.resize(std::min(segments.size(), SegmentNumber));
-    std::sort(segments.begin(),
+    std::sort(
-              segments.end(),
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
-              [](const NamedSegment &lhs, const NamedSegment &rhs)
+            return lhs.position < rhs.position;
-              { return lhs.position < rhs.position; });
+        });
 
     std::array<std::uint32_t, SegmentNumber> summary;
     std::fill(summary.begin(), summary.end(), EMPTY_NAMEID);
@@ -144,8 +138,7 @@ inline std::string assembleSummary(const datafacade::BaseDataFacade &facade,
 
     // transform a name_id into a string containing either the name, or -if the name is empty-
     // the reference.
-    const auto name_id_to_string = [&](const NameID name_id)
+    const auto name_id_to_string = [&](const NameID name_id) {
-    {
         const auto name = facade.GetNameForID(name_id);
         if (!name.empty())
             return std::string(name);
@@ -185,16 +178,14 @@ inline RouteLeg assembleLeg(const datafacade::BaseDataFacade &facade,
     const auto target_weight =
         (target_traversed_in_reverse ? target_node.reverse_weight : target_node.forward_weight);
 
-    auto duration = std::accumulate(route_data.begin(),
+    auto duration = std::accumulate(
-                                    route_data.end(),
+        route_data.begin(), route_data.end(), 0, [](const double sum, const PathData &data) {
-                                    0,
+            return sum + from_alias<double>(data.duration_until_turn);
-                                    [](const double sum, const PathData &data)
+        });
-                                    { return sum + from_alias<double>(data.duration_until_turn); });
+    auto weight = std::accumulate(
-    auto weight = std::accumulate(route_data.begin(),
+        route_data.begin(), route_data.end(), 0, [](const double sum, const PathData &data) {
-                                  route_data.end(),
+            return sum + from_alias<double>(data.weight_until_turn);
-                                  0,
+        });
-                                  [](const double sum, const PathData &data)
-                                  { return sum + from_alias<double>(data.weight_until_turn); });
 
     //                 s
     //                 |

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

@@ -1,6 +1,7 @@
 #ifndef OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP
 
 #include "engine/guidance/route_step.hpp"
+#include "util/attributes.hpp"
 
 #include <type_traits>
 #include <vector>
@@ -11,15 +12,16 @@ namespace osrm::engine::guidance
 // Multiple possible reasons can result in unnecessary/confusing instructions
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-[[nodiscard]] std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
 
 // Multiple possible reasons can result in unnecessary/confusing instructions
 // A prime example would be a segregated intersection. Turning around at this
 // intersection would result in two instructions to turn left.
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-[[nodiscard]] std::vector<RouteStep>
+OSRM_ATTR_WARN_UNUSED
-collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);
+std::vector<RouteStep> collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);
 
 // A combined turn is a set of two instructions that actually form a single turn, as far as we
 // perceive it. A u-turn consisting of two left turns is one such example. But there are also lots

include/engine/guidance/collapsing_utility.hpp

@@ -3,6 +3,7 @@
 
 #include "guidance/turn_instruction.hpp"
 #include "engine/guidance/route_step.hpp"
+#include "util/attributes.hpp"
 #include "util/bearing.hpp"
 #include "util/guidance/name_announcements.hpp"
 
@@ -121,8 +122,9 @@ inline bool haveSameMode(const RouteStep &first, const RouteStep &second, const
 // alias for readability
 inline bool haveSameName(const RouteStep &lhs, const RouteStep &rhs)
 {
-    const auto has_name_or_ref = [](auto const &step)
+    const auto has_name_or_ref = [](auto const &step) {
-    { return !step.name.empty() || !step.ref.empty(); };
+        return !step.name.empty() || !step.ref.empty();
+    };
 
     // make sure empty is not involved
     if (!has_name_or_ref(lhs) || !has_name_or_ref(rhs))
@@ -149,14 +151,12 @@ inline bool haveSameName(const RouteStep &lhs, const RouteStep &rhs)
 // alias for readability, both turn right | left
 inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
 {
-    const auto is_left = [](const RouteStep &step)
+    const auto is_left = [](const RouteStep &step) {
-    {
         return hasModifier(step, osrm::guidance::DirectionModifier::Straight) ||
                hasLeftModifier(step.maneuver.instruction);
     };
 
-    const auto is_right = [](const RouteStep &step)
+    const auto is_right = [](const RouteStep &step) {
-    {
         return hasModifier(step, osrm::guidance::DirectionModifier::Straight) ||
                hasRightModifier(step.maneuver.instruction);
     };
@@ -165,7 +165,8 @@ inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
 }
 
 // do this after invalidating any steps to compress the step array again
-[[nodiscard]] inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
+OSRM_ATTR_WARN_UNUSED
+inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
 {
     // finally clean up the post-processed instructions.
     // Remove all invalid instructions from the set of instructions.
@@ -173,8 +174,7 @@ inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
     // Two valid NO_TURNs exist in each leg in the form of Depart/Arrive
 
     // keep valid instructions
-    const auto not_is_valid = [](const RouteStep &step)
+    const auto not_is_valid = [](const RouteStep &step) {
-    {
         return step.maneuver.instruction == osrm::guidance::TurnInstruction::NO_TURN() &&
                step.maneuver.waypoint_type == WaypointType::None;
     };
@@ -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 exit_intersection = exit_step.intersections.front();
-    const auto &entry_intersection = entry_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];
@@ -225,8 +225,7 @@ inline double totalTurnAngle(const RouteStep &entry_step, const RouteStep &exit_
 inline bool bearingsAreReversed(const double bearing_in, const double bearing_out)
 {
     // Nearly perfectly reversed angles have a difference close to 180 degrees (straight)
-    const double left_turn_angle = [&]()
+    const double left_turn_angle = [&]() {
-    {
         if (0 <= bearing_out && bearing_out <= bearing_in)
             return bearing_in - bearing_out;
         return bearing_in + 360 - bearing_out;

include/engine/guidance/lane_processing.hpp

@@ -1,10 +1,11 @@
 #ifndef OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
 #define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
 
-#include "engine/guidance/route_step.hpp"
-
 #include <vector>
 
+#include "engine/guidance/route_step.hpp"
+#include "util/attributes.hpp"
+
 namespace osrm::engine::guidance
 {
 
@@ -13,8 +14,8 @@ namespace osrm::engine::guidance
 // we anticipate lane changes emitting only matching lanes early on.
 // the second parameter describes the duration that we feel two segments need to be apart to count
 // as separate maneuvers.
-[[nodiscard]] std::vector<RouteStep>
+OSRM_ATTR_WARN_UNUSED
-anticipateLaneChange(std::vector<RouteStep> steps,
+std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
                                             const double min_distance_needed_for_lane_change = 200);
 
 } // namespace osrm::engine::guidance

include/engine/guidance/post_processing.hpp

@@ -5,6 +5,7 @@
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/phantom_node.hpp"
+#include "util/attributes.hpp"
 
 #include <vector>
 
@@ -12,7 +13,8 @@ namespace osrm::engine::guidance
 {
 
 // passed as none-reference to modify in-place and move out again
-[[nodiscard]] std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
 
 // trim initial/final segment of very short length.
 // This function uses in/out parameter passing to modify both steps and geometry in place.
@@ -22,21 +24,23 @@ namespace osrm::engine::guidance
 void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry);
 
 // assign relative locations to depart/arrive instructions
-[[nodiscard]] std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
                                                const LegGeometry &geometry,
                                                const PhantomNode &source_node,
                                                const PhantomNode &target_node);
 
 // collapse suppressed instructions remaining into intersections array
-[[nodiscard]] std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
 
 // postProcess will break the connection between the leg geometry
 // for which a segment is supposed to represent exactly the coordinates
 // between routing maneuvers and the route steps itself.
 // If required, we can get both in sync again using this function.
 // Move in LegGeometry for modification in place.
-[[nodiscard]] LegGeometry resyncGeometry(LegGeometry leg_geometry,
+OSRM_ATTR_WARN_UNUSED
-                                         const std::vector<RouteStep> &steps);
+LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps);
 
 /**
  * Apply maneuver override relations to the selected route.

include/engine/guidance/postprocessing_toolkit.hpp

@@ -20,16 +20,14 @@ template <typename Iter, typename Fn> inline Fn forEachRoundabout(Iter first, It
 {
     while (first != last)
     {
-        const auto enter = std::find_if(first,
+        const auto enter = std::find_if(first, last, [](const RouteStep &step) {
-                                        last,
+            return entersRoundabout(step.maneuver.instruction);
-                                        [](const RouteStep &step)
+        });
-                                        { return entersRoundabout(step.maneuver.instruction); });
 
         // enter has to come before leave, otherwise: faulty data / partial roundabout, skip those
-        const auto leave = std::find_if(enter,
+        const auto leave = std::find_if(enter, last, [](const RouteStep &step) {
-                                        last,
+            return leavesRoundabout(step.maneuver.instruction);
-                                        [](const RouteStep &step)
+        });
-                                        { return leavesRoundabout(step.maneuver.instruction); });
 
         // No roundabouts, or partial one (like start / end inside a roundabout)
         if (enter == last || leave == last)

include/engine/guidance/route_leg.hpp

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

include/engine/guidance/verbosity_reduction.hpp

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

include/engine/internal_route_result.hpp

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

include/engine/map_matching/bayes_classifier.hpp

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

include/engine/map_matching/hidden_markov_model.hpp

@@ -4,7 +4,7 @@
 #include "util/integer_range.hpp"
 
 #include <boost/assert.hpp>
-#include <numbers>
+#include <boost/math/constants/constants.hpp>
 
 #include <cmath>
 
@@ -14,7 +14,7 @@
 namespace osrm::engine::map_matching
 {
 
-static const double log_2_pi = std::log(2. * std::numbers::pi);
+static const double log_2_pi = std::log(2. * boost::math::constants::pi<double>());
 static const double IMPOSSIBLE_LOG_PROB = -std::numeric_limits<double>::infinity();
 static const double MINIMAL_LOG_PROB = std::numeric_limits<double>::lowest();
 static const std::size_t INVALID_STATE = std::numeric_limits<std::size_t>::max();

include/engine/map_matching/matching_confidence.hpp

@@ -2,7 +2,7 @@
 #define ENGINE_MAP_MATCHING_CONFIDENCE_HPP
 
 #include "engine/map_matching/bayes_classifier.hpp"
-#include <boost/assert.hpp>
+
 #include <cmath>
 
 namespace osrm::engine::map_matching

include/engine/phantom_node.hpp

@@ -259,10 +259,10 @@ inline util::Coordinate candidatesInputLocation(const PhantomNodeCandidates &can
 
 inline bool candidatesHaveComponent(const PhantomNodeCandidates &candidates, uint32_t component_id)
 {
-    return std::any_of(candidates.begin(),
+    return std::any_of(
-                       candidates.end(),
+        candidates.begin(), candidates.end(), [component_id](const PhantomNode &node) {
-                       [component_id](const PhantomNode &node)
+            return node.component.id == component_id;
-                       { return node.component.id == component_id; });
+        });
 }
 
 struct PhantomEndpoints

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,14 +29,14 @@ 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
     {
-        return !std::any_of(std::begin(coordinates),
+        return !std::any_of(
-                            std::end(coordinates),
+            std::begin(coordinates), std::end(coordinates), [](const util::Coordinate coordinate) {
-                            [](const util::Coordinate coordinate)
+                return !coordinate.IsValid();
-                            { return !coordinate.IsValid(); });
+            });
     }
 
     bool CheckAlgorithms(const api::BaseParameters &params,
@@ -95,7 +95,7 @@ class BasePlugin
                  const std::string &message,
                  osrm::engine::api::ResultT &result) const
     {
-        std::visit(ErrorRenderer(code, message), result);
+        mapbox::util::apply_visitor(ErrorRenderer(code, message), result);
         return Status::Error;
     }
 
@@ -105,15 +105,13 @@ class BasePlugin
     {
         // are all phantoms from a tiny cc?
         const auto all_in_same_tiny_component =
-            [](const std::vector<PhantomCandidateAlternatives> &alts_list)
+            [](const std::vector<PhantomCandidateAlternatives> &alts_list) {
-        {
                 return std::any_of(
                     alts_list.front().first.begin(),
                     alts_list.front().first.end(),
                     // For each of the first possible phantoms, check if all other
                     // positions in the list have a phantom from the same small component.
-                [&](const PhantomNode &phantom)
+                    [&](const PhantomNode &phantom) {
-                {
                         if (!phantom.component.is_tiny)
                         {
                             return false;
@@ -122,28 +120,30 @@ class BasePlugin
                         return std::all_of(
                             std::next(alts_list.begin()),
                             std::end(alts_list),
-                        [component_id](const PhantomCandidateAlternatives &alternatives)
+                            [component_id](const PhantomCandidateAlternatives &alternatives) {
-                        { return candidatesHaveComponent(alternatives.first, component_id); });
+                                return candidatesHaveComponent(alternatives.first, component_id);
+                            });
                     });
             };
 
         // Move the alternative into the final list
-        const auto fallback_to_big_component = [](PhantomCandidateAlternatives &alternatives)
+        const auto fallback_to_big_component = [](PhantomCandidateAlternatives &alternatives) {
-        {
             auto no_big_alternative = alternatives.second.empty();
             return no_big_alternative ? std::move(alternatives.first)
                                       : std::move(alternatives.second);
         };
 
         // Move the alternative into the final list
-        const auto use_closed_phantom = [](PhantomCandidateAlternatives &alternatives)
+        const auto use_closed_phantom = [](PhantomCandidateAlternatives &alternatives) {
-        { return std::move(alternatives.first); };
+            return std::move(alternatives.first);
+        };
 
         const auto no_alternatives =
             std::all_of(alternatives_list.begin(),
                         alternatives_list.end(),
-                        [](const PhantomCandidateAlternatives &alternatives)
+                        [](const PhantomCandidateAlternatives &alternatives) {
-                        { return alternatives.second.empty(); });
+                            return alternatives.second.empty();
+                        });
 
         std::vector<PhantomNodeCandidates> snapped_phantoms;
         snapped_phantoms.reserve(alternatives_list.size());
@@ -200,8 +200,8 @@ class BasePlugin
             phantom_nodes[i] = facade.NearestPhantomNodesInRange(
                 parameters.coordinates[i],
                 radiuses[i],
-                use_bearings ? parameters.bearings[i] : std::nullopt,
+                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                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_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                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_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                            : engine::Approach::UNRESTRICTED,
                 use_all_edges);
 
@@ -313,19 +313,19 @@ class BasePlugin
                           alternatives.end(),
                           coordinates.begin(),
                           coordinates.end(),
-                          [](const auto &candidates_pair, const auto &coordinate)
+                          [](const auto &candidates_pair, const auto &coordinate) {
-                          {
                               return std::any_of(candidates_pair.first.begin(),
                                                  candidates_pair.first.end(),
-                                                 [&](const auto &phantom)
+                                                 [&](const auto &phantom) {
-                                                 { return phantom.input_location == coordinate; });
+                                                     return phantom.input_location == coordinate;
+                                                 });
                           });
         std::size_t missing_index = std::distance(alternatives.begin(), mismatch.first);
         return std::string("Could not find a matching segment for coordinate ") +
                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,26 @@ std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter
         return {};
     }
 
-    std::string output;
+    std::vector<int> delta_numbers;
-    // just a guess that we will need ~4 bytes per coordinate to avoid reallocations
+    BOOST_ASSERT(size > 0);
-    output.reserve(size * 4);
+    delta_numbers.reserve((size - 1) * 2);
-
     int current_lat = 0;
     int current_lon = 0;
-    for (auto it = begin; it != end; ++it)
+    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>(it->lat) * coordinate_to_polyline) - current_lat;
+                std::round(static_cast<int>(loc.lat) * coordinate_to_polyline) - current_lat;
             const int lon_diff =
-            std::round(static_cast<int>(it->lon) * coordinate_to_polyline) - current_lon;
+                std::round(static_cast<int>(loc.lon) * coordinate_to_polyline) - current_lon;
-        detail::encode(lat_diff, output);
+            delta_numbers.emplace_back(lat_diff);
-        detail::encode(lon_diff, output);
+            delta_numbers.emplace_back(lon_diff);
             current_lat += lat_diff;
             current_lon += lon_diff;
-    }
+        });
-    return output;
+    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

@@ -71,27 +71,24 @@ void insertTargetInReverseHeap(Heap &reverse_heap, const PhantomNode &target)
 static constexpr bool FORWARD_DIRECTION = true;
 static constexpr bool REVERSE_DIRECTION = false;
 
-// Identify nodes in the forward(reverse) search direction that will require step forcing
+// Identify nodes in the forward(reverse) search direction that will require loop forcing
 // e.g. if source and destination nodes are on the same segment.
-std::vector<NodeID> getForwardForceNodes(const PhantomEndpointCandidates &candidates);
+std::vector<NodeID> getForwardLoopNodes(const PhantomEndpointCandidates &candidates);
-std::vector<NodeID> getForwardForceNodes(const PhantomCandidatesToTarget &candidates);
+std::vector<NodeID> getForwardLoopNodes(const PhantomCandidatesToTarget &candidates);
-std::vector<NodeID> getBackwardForceNodes(const PhantomEndpointCandidates &candidates);
+std::vector<NodeID> getBackwardLoopNodes(const PhantomEndpointCandidates &candidates);
-std::vector<NodeID> getBackwardForceNodes(const PhantomCandidatesToTarget &candidates);
+std::vector<NodeID> getBackwardLoopNodes(const PhantomCandidatesToTarget &candidates);
 
 // Find the specific phantom node endpoints for a given path from a list of candidates.
 PhantomEndpoints endpointsFromCandidates(const PhantomEndpointCandidates &candidates,
                                          const std::vector<NodeID> &path);
 
 template <typename HeapNodeT>
-inline bool shouldForceStep(const std::vector<NodeID> &force_nodes,
+inline bool force_loop(const std::vector<NodeID> &force_nodes, const HeapNodeT &heap_node)
-                            const HeapNodeT &forward_heap_node,
-                            const HeapNodeT &reverse_heap_node)
 {
-    // routing steps are forced when the node is a source of both forward and reverse search heaps.
+    // if loops are forced, they are so at the source
-    return forward_heap_node.data.parent == forward_heap_node.node &&
+    return !force_nodes.empty() &&
-           reverse_heap_node.data.parent == reverse_heap_node.node &&
+           std::find(force_nodes.begin(), force_nodes.end(), heap_node.node) != force_nodes.end() &&
-           std::find(force_nodes.begin(), force_nodes.end(), forward_heap_node.node) !=
+           heap_node.data.parent == heap_node.node;
-               force_nodes.end();
 }
 
 template <typename Heap>
@@ -193,10 +190,8 @@ void annotatePath(const FacadeT &facade,
     std::vector<SegmentDuration> duration_vector;
     std::vector<DatasourceID> datasource_vector;
 
-    const auto get_segment_geometry = [&](const auto geometry_index)
+    const auto get_segment_geometry = [&](const auto geometry_index) {
-    {
+        const auto copy = [](auto &vector, const auto range) {
-        const auto copy = [](auto &vector, const auto range)
-        {
             vector.resize(range.size());
             std::copy(range.begin(), range.end(), vector.begin());
         };
@@ -258,7 +253,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 +310,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

@@ -112,7 +112,8 @@ void routingStep(const DataFacade<Algorithm> &facade,
                  NodeID &middle_node_id,
                  EdgeWeight &upper_bound,
                  EdgeWeight min_edge_offset,
-                 const std::vector<NodeID> &force_step_nodes)
+                 const std::vector<NodeID> &force_loop_forward_nodes,
+                 const std::vector<NodeID> &force_loop_reverse_nodes)
 {
     auto heapNode = forward_heap.DeleteMinGetHeapNode();
     const auto reverseHeapNode = reverse_heap.GetHeapNodeIfWasInserted(heapNode.node);
@@ -122,13 +123,13 @@ void routingStep(const DataFacade<Algorithm> &facade,
         const EdgeWeight new_weight = reverseHeapNode->weight + heapNode.weight;
         if (new_weight < upper_bound)
         {
-            if (shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) ||
+            if (force_loop(force_loop_forward_nodes, heapNode) ||
+                force_loop(force_loop_reverse_nodes, heapNode) ||
                 // in this case we are looking at a bi-directional way where the source
                 // and target phantom are on the same edge based node
                 new_weight < EdgeWeight{0})
             {
-                // Before forcing step, check whether there is a loop present at the node.
+                // check whether there is a loop present at the node
-                // We may find a valid weight path by following the loop.
                 for (const auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
                 {
                     const auto &data = facade.GetEdgeData(edge);
@@ -293,9 +294,9 @@ EdgeDistance calculateEBGNodeAnnotations(const DataFacade<Algorithm> &facade,
 
             // Look for an edge on the forward CH graph (.forward)
             EdgeID smaller_edge_id =
-                facade.FindSmallestEdge(std::get<0>(edge),
+                facade.FindSmallestEdge(std::get<0>(edge), std::get<1>(edge), [](const auto &data) {
-                                        std::get<1>(edge),
+                    return data.forward;
-                                        [](const auto &data) { return data.forward; });
+                });
 
             // If we didn't find one there, the we might be looking at a part of the path that
             // was found using the backward search.  Here, we flip the node order (.second,
@@ -380,8 +381,7 @@ void unpackPath(const FacadeT &facade,
         unpackPath(facade,
                    packed_path_begin,
                    packed_path_end,
-                   [&](std::pair<NodeID, NodeID> &edge, const auto &edge_id)
+                   [&](std::pair<NodeID, NodeID> &edge, const auto &edge_id) {
-                   {
                        BOOST_ASSERT(edge.first == unpacked_nodes.back());
                        unpacked_nodes.push_back(edge.second);
                        unpacked_edges.push_back(edge_id);
@@ -420,22 +420,23 @@ void retrievePackedPathFromSingleManyToManyHeap(
 // assumes that heaps are already setup correctly.
 // ATTENTION: This only works if no additional offset is supplied next to the Phantom Node
 // Offsets.
-// In case additional offsets are supplied, you might have to force a routing step first.
+// In case additional offsets are supplied, you might have to force a loop first.
-// A forced step might be necessary, if source and target are on the same segment.
+// A forced loop might be necessary, if source and target are on the same segment.
 // If this is the case and the offsets of the respective direction are larger for the source
 // than the target
-// then a force step is required (e.g. source_phantom.forward_segment_id ==
+// then a force loop is required (e.g. source_phantom.forward_segment_id ==
 // target_phantom.forward_segment_id
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
-// a force step, if the heaps have been initialized with positive offsets.
+// a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> &engine_working_data,
             const DataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             EdgeWeight &weight,
             std::vector<NodeID> &packed_leg,
-            const std::vector<NodeID> &force_step_nodes,
+            const std::vector<NodeID> &force_loop_forward_node,
+            const std::vector<NodeID> &force_loop_reverse_node,
             const EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT);
 
 template <typename PhantomEndpointT>
@@ -445,7 +446,8 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             EdgeWeight &weight,
             std::vector<NodeID> &packed_leg,
-            const std::vector<NodeID> &force_step_nodes,
+            const std::vector<NodeID> &force_loop_forward_node,
+            const std::vector<NodeID> &force_loop_reverse_node,
             const PhantomEndpointT & /*endpoints*/,
             const EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT)
 {
@@ -456,13 +458,14 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
                   reverse_heap,
                   weight,
                   packed_leg,
-                  force_step_nodes,
+                  force_loop_forward_node,
+                  force_loop_reverse_node,
                   duration_upper_bound);
 }
 
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
-// the addition of force_step parameters might be required
+// the addition of force_loop parameters might be required
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                           const DataFacade<ch::Algorithm> &facade,
                           SearchEngineData<Algorithm>::QueryHeap &forward_heap,

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -11,7 +11,6 @@
 #include <boost/assert.hpp>
 
 #include <algorithm>
-#include <boost/core/ignore_unused.hpp>
 #include <iterator>
 #include <limits>
 #include <tuple>
@@ -31,8 +30,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                  const PhantomNode &source,
                                  const PhantomNode &target)
 {
-    auto level = [&partition, node](const SegmentID &source, const SegmentID &target)
+    auto level = [&partition, node](const SegmentID &source, const SegmentID &target) {
-    {
         if (source.enabled && target.enabled)
             return partition.GetQueryLevel(source.id, target.id, node);
         return INVALID_LEVEL_ID;
@@ -61,8 +59,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
         endpoint_candidates.source_phantoms.begin(),
         endpoint_candidates.source_phantoms.end(),
         INVALID_LEVEL_ID,
-        [&](LevelID current_level, const PhantomNode &source)
+        [&](LevelID current_level, const PhantomNode &source) {
-        {
             return std::min(
                 current_level,
                 getNodeQueryLevel(partition, node, source, endpoint_candidates.target_phantom));
@@ -79,8 +76,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
         endpoint_candidates.source_phantoms.begin(),
         endpoint_candidates.source_phantoms.end(),
         INVALID_LEVEL_ID,
-        [&](LevelID level_1, const PhantomNode &source)
+        [&](LevelID level_1, const PhantomNode &source) {
-        {
             return std::min(
                 level_1,
                 std::accumulate(endpoint_candidates.target_phantoms.begin(),
@@ -123,8 +119,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                  const NodeID node,
                                  const PhantomNodeCandidates &candidates)
 {
-    auto highest_different_level = [&partition, node](const SegmentID &segment)
+    auto highest_different_level = [&partition, node](const SegmentID &segment) {
-    {
         return segment.enabled ? partition.GetHighestDifferentLevel(segment.id, node)
                                : INVALID_LEVEL_ID;
     };
@@ -133,8 +128,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
         std::accumulate(candidates.begin(),
                         candidates.end(),
                         INVALID_LEVEL_ID,
-                        [&](LevelID current_level, const PhantomNode &phantom_node)
+                        [&](LevelID current_level, const PhantomNode &phantom_node) {
-                        {
                             auto highest_level =
                                 std::min(highest_different_level(phantom_node.forward_segment_id),
                                          highest_different_level(phantom_node.reverse_segment_id));
@@ -157,11 +151,9 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
     // This is equivalent to min_{∀ source, target} partition.GetQueryLevel(source, node, target)
     auto init = getNodeQueryLevel(partition, node, candidates_list[phantom_index]);
     auto result = std::accumulate(
-        phantom_indices.begin(),
+        phantom_indices.begin(), phantom_indices.end(), init, [&](LevelID level, size_t index) {
-        phantom_indices.end(),
+            return std::min(level, getNodeQueryLevel(partition, node, candidates_list[index]));
-        init,
+        });
-        [&](LevelID level, size_t index)
-        { return std::min(level, getNodeQueryLevel(partition, node, candidates_list[index])); });
     return result;
 }
 } // namespace
@@ -270,29 +262,10 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
     return packed_path;
 }
 
-template <typename Heap>
+template <bool DIRECTION, typename Algorithm, typename... Args>
-void insertOrUpdate(Heap &heap,
-                    const NodeID node,
-                    const EdgeWeight weight,
-                    const typename Heap::DataType &data)
-{
-    const auto heapNode = heap.GetHeapNodeIfWasInserted(node);
-    if (!heapNode)
-    {
-        heap.Insert(node, weight, data);
-    }
-    else if (weight < heapNode->weight)
-    {
-        heapNode->data = data;
-        heapNode->weight = weight;
-        heap.DecreaseKey(*heapNode);
-    }
-}
-
-template <bool DIRECTION, typename Algorithm, typename Heap, typename... Args>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
-                        Heap &forward_heap,
+                        typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                        const typename Heap::HeapNode &heapNode,
+                        const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
                         const Args &... args)
 {
     const auto &partition = facade.GetMultiLevelPartition();
@@ -301,31 +274,14 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
 
     const auto level = getNodeQueryLevel(partition, heapNode.node, args...);
 
-    static constexpr auto IS_MAP_MATCHING =
-        std::is_same_v<typename SearchEngineData<mld::Algorithm>::MapMatchingQueryHeap, Heap>;
-
     if (level >= 1 && !heapNode.data.from_clique_arc)
     {
-        if constexpr (DIRECTION == FORWARD_DIRECTION)
+        if (DIRECTION == FORWARD_DIRECTION)
         {
             // Shortcuts in forward direction
             const auto &cell =
                 cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
             auto destination = cell.GetDestinationNodes().begin();
-            auto distance = [&cell, node = heapNode.node ]() -> auto
-            {
-                if constexpr (IS_MAP_MATCHING)
-                {
-
-                    return cell.GetOutDistance(node).begin();
-                }
-                else
-                {
-                    boost::ignore_unused(cell, node);
-                    return 0;
-                }
-            }
-            ();
             for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))
             {
                 BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
@@ -335,23 +291,19 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                 {
                     const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
                     BOOST_ASSERT(to_weight >= heapNode.weight);
-
+                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
-                    if constexpr (IS_MAP_MATCHING)
+                    if (!toHeapNode)
                     {
-                        const EdgeDistance to_distance = heapNode.data.distance + *distance;
+                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
-                        insertOrUpdate(
-                            forward_heap, to, to_weight, {heapNode.node, true, to_distance});
                     }
-                    else
+                    else if (to_weight < toHeapNode->weight)
                     {
-                        insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, true});
+                        toHeapNode->data = {heapNode.node, true};
+                        toHeapNode->weight = to_weight;
+                        forward_heap.DecreaseKey(*toHeapNode);
                     }
                 }
                 ++destination;
-                if constexpr (IS_MAP_MATCHING)
-                {
-                    ++distance;
-                }
             }
         }
         else
@@ -360,20 +312,6 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
             const auto &cell =
                 cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
             auto source = cell.GetSourceNodes().begin();
-            auto distance = [&cell, node = heapNode.node ]() -> auto
-            {
-                if constexpr (IS_MAP_MATCHING)
-                {
-
-                    return cell.GetInDistance(node).begin();
-                }
-                else
-                {
-                    boost::ignore_unused(cell, node);
-                    return 0;
-                }
-            }
-            ();
             for (auto shortcut_weight : cell.GetInWeight(heapNode.node))
             {
                 BOOST_ASSERT(source != cell.GetSourceNodes().end());
@@ -383,22 +321,19 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                 {
                     const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
                     BOOST_ASSERT(to_weight >= heapNode.weight);
-                    if constexpr (IS_MAP_MATCHING)
+                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
+                    if (!toHeapNode)
                     {
-                        const EdgeDistance to_distance = heapNode.data.distance + *distance;
+                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
-                        insertOrUpdate(
-                            forward_heap, to, to_weight, {heapNode.node, true, to_distance});
                     }
-                    else
+                    else if (to_weight < toHeapNode->weight)
                     {
-                        insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, true});
+                        toHeapNode->data = {heapNode.node, true};
+                        toHeapNode->weight = to_weight;
+                        forward_heap.DecreaseKey(*toHeapNode);
                     }
                 }
                 ++source;
-                if constexpr (IS_MAP_MATCHING)
-                {
-                    ++distance;
-                }
             }
         }
     }
@@ -425,31 +360,30 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                 const EdgeWeight to_weight =
                     heapNode.weight + node_weight + alias_cast<EdgeWeight>(turn_penalty);
 
-                if constexpr (IS_MAP_MATCHING)
+                const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
+                if (!toHeapNode)
                 {
-                    const auto node_distance =
+                    forward_heap.Insert(to, to_weight, {heapNode.node, false});
-                        facade.GetNodeDistance(DIRECTION == FORWARD_DIRECTION ? heapNode.node : to);
-
-                    const EdgeDistance to_distance = heapNode.data.distance + node_distance;
-                    insertOrUpdate(
-                        forward_heap, to, to_weight, {heapNode.node, false, to_distance});
                 }
-                else
+                else if (to_weight < toHeapNode->weight)
                 {
-                    insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, false});
+                    toHeapNode->data = {heapNode.node, false};
+                    toHeapNode->weight = to_weight;
+                    forward_heap.DecreaseKey(*toHeapNode);
                 }
             }
         }
     }
 }
 
-template <bool DIRECTION, typename Algorithm, typename Heap, typename... Args>
+template <bool DIRECTION, typename Algorithm, typename... Args>
 void routingStep(const DataFacade<Algorithm> &facade,
-                 Heap &forward_heap,
+                 typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                 Heap &reverse_heap,
+                 typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                  NodeID &middle_node,
                  EdgeWeight &path_upper_bound,
-                 const std::vector<NodeID> &force_step_nodes,
+                 const std::vector<NodeID> &force_loop_forward_nodes,
+                 const std::vector<NodeID> &force_loop_reverse_nodes,
                  const Args &... args)
 {
     const auto heapNode = forward_heap.DeleteMinGetHeapNode();
@@ -468,8 +402,11 @@ void routingStep(const DataFacade<Algorithm> &facade,
         auto reverse_weight = reverseHeapNode->weight;
         auto path_weight = weight + reverse_weight;
 
-        if (!shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) &&
+        // MLD uses loops forcing only to prune single node paths in forward and/or
-            (path_weight >= EdgeWeight{0}) && (path_weight < path_upper_bound))
+        // backward direction (there is no need to force loops in MLD but in CH)
+        if (!force_loop(force_loop_forward_nodes, heapNode) &&
+            !force_loop(force_loop_reverse_nodes, heapNode) && (path_weight >= EdgeWeight{0}) &&
+            (path_weight < path_upper_bound))
         {
             middle_node = heapNode.node;
             path_upper_bound = path_weight;
@@ -487,27 +424,25 @@ void routingStep(const DataFacade<Algorithm> &facade,
 
 using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
+using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
 
-struct UnpackedPath
+template <typename Algorithm, typename... Args>
-{
+UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
-    EdgeWeight weight;
+                    const DataFacade<Algorithm> &facade,
-    UnpackedNodes nodes;
+                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-    UnpackedEdges edges;
+                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-};
+                    const std::vector<NodeID> &force_loop_forward_nodes,
-
+                    const std::vector<NodeID> &force_loop_reverse_nodes,
-template <typename Algorithm, typename Heap, typename... Args>
-std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
-                                                       Heap &forward_heap,
-                                                       Heap &reverse_heap,
-                                                       const std::vector<NodeID> &force_step_nodes,
                     EdgeWeight weight_upper_bound,
                     const Args &... args)
 {
     if (forward_heap.Empty() || reverse_heap.Empty())
     {
-        return {};
+        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
     }
 
+    const auto &partition = facade.GetMultiLevelPartition();
+
     BOOST_ASSERT(!forward_heap.Empty() && forward_heap.MinKey() < INVALID_EDGE_WEIGHT);
     BOOST_ASSERT(!reverse_heap.Empty() && reverse_heap.MinKey() < INVALID_EDGE_WEIGHT);
 
@@ -521,15 +456,27 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
     {
         if (!forward_heap.Empty())
         {
-            routingStep<FORWARD_DIRECTION>(
+            routingStep<FORWARD_DIRECTION>(facade,
-                facade, forward_heap, reverse_heap, middle, weight, force_step_nodes, args...);
+                                           forward_heap,
+                                           reverse_heap,
+                                           middle,
+                                           weight,
+                                           force_loop_forward_nodes,
+                                           force_loop_reverse_nodes,
+                                           args...);
             if (!forward_heap.Empty())
                 forward_heap_min = forward_heap.MinKey();
         }
         if (!reverse_heap.Empty())
         {
-            routingStep<REVERSE_DIRECTION>(
+            routingStep<REVERSE_DIRECTION>(facade,
-                facade, reverse_heap, forward_heap, middle, weight, force_step_nodes, args...);
+                                           reverse_heap,
+                                           forward_heap,
+                                           middle,
+                                           weight,
+                                           force_loop_reverse_nodes,
+                                           force_loop_forward_nodes,
+                                           args...);
             if (!reverse_heap.Empty())
                 reverse_heap_min = reverse_heap.MinKey();
         }
@@ -538,32 +485,9 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
     // No path found for both target nodes?
     if (weight >= weight_upper_bound || SPECIAL_NODEID == middle)
     {
-        return {};
+        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
     }
 
-    return {{middle, weight}};
-}
-
-template <typename Algorithm, typename... Args>
-UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
-                    const DataFacade<Algorithm> &facade,
-                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                    const std::vector<NodeID> &force_step_nodes,
-                    EdgeWeight weight_upper_bound,
-                    const Args &...args)
-{
-    auto searchResult = runSearch(
-        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
-    if (!searchResult)
-    {
-        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
-    }
-
-    auto [middle, weight] = *searchResult;
-
-    const auto &partition = facade.GetMultiLevelPartition();
-
     // Get packed path as edges {from node ID, to node ID, from_clique_arc}
     auto packed_path = retrievePackedPathFromHeap(forward_heap, reverse_heap, middle);
 
@@ -581,7 +505,9 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
 
     for (auto const &packed_edge : packed_path)
     {
-        auto [source, target, overlay_edge] = packed_edge;
+        NodeID source, target;
+        bool overlay_edge;
+        std::tie(source, target, overlay_edge) = packed_edge;
         if (!overlay_edge)
         { // a base graph edge
             unpacked_nodes.push_back(target);
@@ -601,52 +527,32 @@ 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,
+            // TODO: when structured bindings will be allowed change to
+            // auto [subpath_weight, subpath_source, subpath_target, subpath] = ...
+            EdgeWeight subpath_weight;
+            std::vector<NodeID> subpath_nodes;
+            std::vector<EdgeID> subpath_edges;
+            std::tie(subpath_weight, subpath_nodes, subpath_edges) =
+                search(engine_working_data,
                        facade,
                        forward_heap,
                        reverse_heap,
-                                           force_step_nodes,
+                       force_loop_forward_nodes,
+                       force_loop_reverse_nodes,
                        INVALID_EDGE_WEIGHT,
                        sublevel,
                        parent_cell_id);
-            BOOST_ASSERT(!unpacked_subpath.edges.empty());
+            BOOST_ASSERT(!subpath_edges.empty());
-            BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
+            BOOST_ASSERT(subpath_nodes.size() > 1);
-            BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
+            BOOST_ASSERT(subpath_nodes.front() == source);
-            BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
+            BOOST_ASSERT(subpath_nodes.back() == target);
-            unpacked_nodes.insert(unpacked_nodes.end(),
+            unpacked_nodes.insert(
-                                  std::next(unpacked_subpath.nodes.begin()),
+                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
-                                  unpacked_subpath.nodes.end());
+            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
-            unpacked_edges.insert(
-                unpacked_edges.end(), unpacked_subpath.edges.begin(), unpacked_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>
-EdgeDistance
-searchDistance(SearchEngineData<Algorithm> &,
-               const DataFacade<Algorithm> &facade,
-               typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
-               typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
-               const std::vector<NodeID> &force_step_nodes,
-               EdgeWeight weight_upper_bound,
-               const Args &...args)
-{
-
-    auto searchResult = runSearch(
-        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
-    if (!searchResult)
-    {
-        return INVALID_EDGE_DISTANCE;
-    }
-
-    auto [middle, _] = *searchResult;
-
-    auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance;
-
-    return distance;
 }
 
 // Alias to be compatible with the CH-based search
@@ -657,20 +563,20 @@ inline void search(SearchEngineData<Algorithm> &engine_working_data,
                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                    EdgeWeight &weight,
                    std::vector<NodeID> &unpacked_nodes,
-                   const std::vector<NodeID> &force_step_nodes,
+                   const std::vector<NodeID> &force_loop_forward_node,
+                   const std::vector<NodeID> &force_loop_reverse_node,
                    const PhantomEndpointT &endpoints,
                    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,
+    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
                                                            facade,
                                                            forward_heap,
                                                            reverse_heap,
-                                force_step_nodes,
+                                                           force_loop_forward_node,
+                                                           force_loop_reverse_node,
                                                            weight_upper_bound,
                                                            endpoints);
-    weight = unpacked_path.weight;
-    unpacked_nodes = std::move(unpacked_path.nodes);
 }
 
 // TODO: refactor CH-related stub to use unpacked_edges
@@ -695,8 +601,7 @@ void unpackPath(const FacadeT &facade,
         util::for_each_pair(
             packed_path_begin,
             packed_path_end,
-            [&facade, &unpacked_nodes, &unpacked_edges](const auto from, const auto to)
+            [&facade, &unpacked_nodes, &unpacked_edges](const auto from, const auto to) {
-            {
                 unpacked_nodes.push_back(to);
                 unpacked_edges.push_back(facade.FindEdge(from, to));
             });
@@ -708,8 +613,8 @@ void unpackPath(const FacadeT &facade,
 template <typename Algorithm>
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                           const DataFacade<Algorithm> &facade,
-                          typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+                          typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                          typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
+                          typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                           const PhantomNode &source_phantom,
                           const PhantomNode &target_phantom,
                           EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
@@ -717,50 +622,31 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
     forward_heap.Clear();
     reverse_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()});
-    }
-
-    if (source_phantom.IsValidReverseSource())
-    {
-        forward_heap.Insert(source_phantom.reverse_segment_id.id,
-                            EdgeWeight{0} - source_phantom.GetReverseWeightPlusOffset(),
-                            {source_phantom.reverse_segment_id.id,
-                             false,
-                             EdgeDistance{0} - source_phantom.GetReverseDistance()});
-    }
-
-    if (target_phantom.IsValidForwardTarget())
-    {
-        reverse_heap.Insert(
-            target_phantom.forward_segment_id.id,
-            target_phantom.GetForwardWeightPlusOffset(),
-            {target_phantom.forward_segment_id.id, false, target_phantom.GetForwardDistance()});
-    }
-
-    if (target_phantom.IsValidReverseTarget())
-    {
-        reverse_heap.Insert(
-            target_phantom.reverse_segment_id.id,
-            target_phantom.GetReverseWeightPlusOffset(),
-            {target_phantom.reverse_segment_id.id, false, target_phantom.GetReverseDistance()});
-    }
-
     const PhantomEndpoints endpoints{source_phantom, target_phantom};
+    insertNodesInHeaps(forward_heap, reverse_heap, endpoints);
 
-    auto distance = searchDistance(
+    EdgeWeight weight = INVALID_EDGE_WEIGHT;
-        engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);
+    std::vector<NodeID> unpacked_nodes;
+    std::vector<EdgeID> unpacked_edges;
+    std::tie(weight, unpacked_nodes, unpacked_edges) = search(engine_working_data,
+                                                              facade,
+                                                              forward_heap,
+                                                              reverse_heap,
+                                                              {},
+                                                              {},
+                                                              weight_upper_bound,
+                                                              endpoints);
 
-    if (distance == INVALID_EDGE_DISTANCE)
+    if (weight == INVALID_EDGE_WEIGHT)
     {
         return std::numeric_limits<double>::max();
     }
-    return from_alias<double>(distance);
+
+    std::vector<PathData> unpacked_path;
+
+    annotatePath(facade, endpoints, unpacked_nodes, unpacked_edges, unpacked_path);
+
+    return getPathDistance(facade, unpacked_path, source_phantom, target_phantom);
 }
 
 } // namespace osrm::engine::routing_algorithms::mld

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
 {
@@ -19,7 +19,8 @@ void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
                      typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                      typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                      const PhantomEndpointCandidates &candidates,
-                     EdgeWeight &leg_weight,
+                     const EdgeWeight &total_weight,
+                     EdgeWeight &new_total_weight,
                      std::vector<NodeID> &leg_packed_path)
 {
     forward_heap.Clear();
@@ -30,14 +31,14 @@ void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
         if (source.IsValidForwardSource())
         {
             forward_heap.Insert(source.forward_segment_id.id,
-                                EdgeWeight{0} - source.GetForwardWeightPlusOffset(),
+                                total_weight - source.GetForwardWeightPlusOffset(),
                                 source.forward_segment_id.id);
         }
 
         if (source.IsValidReverseSource())
         {
             forward_heap.Insert(source.reverse_segment_id.id,
-                                EdgeWeight{0} - source.GetReverseWeightPlusOffset(),
+                                total_weight - source.GetReverseWeightPlusOffset(),
                                 source.reverse_segment_id.id);
         }
     }
@@ -61,9 +62,10 @@ void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
            facade,
            forward_heap,
            reverse_heap,
-           leg_weight,
+           new_total_weight,
            leg_packed_path,
-           {},
+           getForwardLoopNodes(candidates),
+           getBackwardLoopNodes(candidates),
            candidates);
 }
 
@@ -123,7 +125,8 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
                reverse_heap,
                new_total_weight_to_forward,
                leg_packed_path_forward,
-               getForwardForceNodes(candidates),
+               getForwardLoopNodes(candidates),
+               {},
                candidates);
     }
 
@@ -162,7 +165,8 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
                reverse_heap,
                new_total_weight_to_reverse,
                leg_packed_path_reverse,
-               getBackwardForceNodes(candidates),
+               {},
+               getBackwardLoopNodes(candidates),
                candidates);
     }
 }
@@ -244,8 +248,7 @@ constructRouteResult(const DataFacade<Algorithm> &facade,
         auto source_it =
             std::find_if(source_candidates.begin(),
                          source_candidates.end(),
-                         [&start_node](const auto &source_phantom)
+                         [&start_node](const auto &source_phantom) {
-                         {
                              return (start_node == source_phantom.forward_segment_id.id ||
                                      start_node == source_phantom.reverse_segment_id.id);
                          });
@@ -254,8 +257,7 @@ constructRouteResult(const DataFacade<Algorithm> &facade,
         auto target_it =
             std::find_if(target_candidates.begin(),
                          target_candidates.end(),
-                         [&end_node](const auto &target_phantom)
+                         [&end_node](const auto &target_phantom) {
-                         {
                              return (end_node == target_phantom.forward_segment_id.id ||
                                      end_node == target_phantom.reverse_segment_id.id);
                          });
@@ -300,7 +302,7 @@ shortestPathWithWaypointUTurns(SearchEngineData<Algorithm> &engine_working_data,
         PhantomEndpointCandidates search_candidates{waypoint_candidates[i],
                                                     waypoint_candidates[i + 1]};
         std::vector<NodeID> packed_leg;
-        EdgeWeight leg_weight = INVALID_EDGE_WEIGHT;
+        EdgeWeight new_total_weight = INVALID_EDGE_WEIGHT;
 
         // We have a valid path up to this leg
         BOOST_ASSERT(total_weight != INVALID_EDGE_WEIGHT);
@@ -309,15 +311,16 @@ shortestPathWithWaypointUTurns(SearchEngineData<Algorithm> &engine_working_data,
                         forward_heap,
                         reverse_heap,
                         search_candidates,
-                        leg_weight,
+                        total_weight,
+                        new_total_weight,
                         packed_leg);
 
-        if (leg_weight == INVALID_EDGE_WEIGHT)
+        if (new_total_weight == INVALID_EDGE_WEIGHT)
             return {};
 
         packed_leg_begin.push_back(total_packed_path.size());
         total_packed_path.insert(total_packed_path.end(), packed_leg.begin(), packed_leg.end());
-        total_weight += leg_weight;
+        total_weight = new_total_weight;
     };
 
     // Add sentinel
@@ -339,10 +342,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;
+    boost::optional<size_t> forward_to_forward;
-    std::optional<size_t> reverse_to_forward;
+    boost::optional<size_t> reverse_to_forward;
-    std::optional<size_t> forward_to_reverse;
+    boost::optional<size_t> forward_to_reverse;
-    std::optional<size_t> reverse_to_reverse;
+    boost::optional<size_t> reverse_to_reverse;
 };
 
 // Identify which of the source candidates segments is being used for paths to the
@@ -463,16 +466,16 @@ struct route_state
         last.total_weight_to_forward.resize(init_candidates.size(), {0});
         last.total_weight_to_reverse.resize(init_candidates.size(), {0});
         // Initialize routability from source validity.
-        std::transform(init_candidates.begin(),
+        std::transform(
+            init_candidates.begin(),
             init_candidates.end(),
             std::back_inserter(last.reached_forward_node_target),
-                       [](const PhantomNode &phantom_node)
+            [](const PhantomNode &phantom_node) { return phantom_node.IsValidForwardSource(); });
-                       { return phantom_node.IsValidForwardSource(); });
+        std::transform(
-        std::transform(init_candidates.begin(),
+            init_candidates.begin(),
             init_candidates.end(),
             std::back_inserter(last.reached_reverse_node_target),
-                       [](const PhantomNode &phantom_node)
+            [](const PhantomNode &phantom_node) { return phantom_node.IsValidReverseSource(); });
-                       { return phantom_node.IsValidReverseSource(); });
     }
 
     bool completeLeg()
@@ -610,21 +613,15 @@ struct route_state
     {
         // Find the segment from final leg with the shortest path
         auto forward_range = util::irange<std::size_t>(0UL, last.total_weight_to_forward.size());
-        auto forward_min = std::min_element(
+        auto forward_min =
-            forward_range.begin(),
+            std::min_element(forward_range.begin(), forward_range.end(), [&](size_t a, size_t b) {
-            forward_range.end(),
-            [&](size_t a, size_t b)
-            {
                 return (last.total_weight_to_forward[a] < last.total_weight_to_forward[b] ||
                         (last.total_weight_to_forward[a] == last.total_weight_to_forward[b] &&
                          last.total_nodes_to_forward[a] < last.total_nodes_to_forward[b]));
             });
         auto reverse_range = util::irange<std::size_t>(0UL, last.total_weight_to_reverse.size());
-        auto reverse_min = std::min_element(
+        auto reverse_min =
-            reverse_range.begin(),
+            std::min_element(reverse_range.begin(), reverse_range.end(), [&](size_t a, size_t b) {
-            reverse_range.end(),
-            [&](size_t a, size_t b)
-            {
                 return (last.total_weight_to_reverse[a] < last.total_weight_to_reverse[b] ||
                         (last.total_weight_to_reverse[a] == last.total_weight_to_reverse[b] &&
                          last.total_nodes_to_reverse[a] < last.total_nodes_to_reverse[b]));
@@ -771,7 +768,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