wip

* Attempt to fix failing CI on gcc-13 jobs

* Attempt to fix failing CI on gcc-13 jobs

* Attempt to fix failing CI on gcc-13 jobs

* Attempt to fix failing CI on gcc-13 jobs

* Attempt to fix failing CI on gcc-13 jobs

.github/ISSUE_TEMPLATE/question.md

@@ -1,5 +0,0 @@
----
-name: Question
-about: Ask a question about OSRM
-labels: question
----

.github/workflows/osrm-backend.yml

@@ -19,6 +19,10 @@ env:
   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
@@ -26,7 +30,6 @@ jobs:
     continue-on-error: false
     env:
       BUILD_TYPE: Release
-      ENABLE_APPLE_SILICON: "OFF"
     steps:
     - uses: actions/checkout@v3
     - run: pip install "conan<2.0.0"
@@ -34,7 +37,7 @@ jobs:
     - run: cmake --version
     - uses: actions/setup-node@v3
       with:
-        node-version: 16
+        node-version: 18
     - run: node --version
     - run: npm --version
     - name: Prepare environment
@@ -71,13 +74,13 @@ jobs:
         token: ${{ secrets.GITHUB_TOKEN }}
 
   format-taginfo-docs:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - uses: actions/checkout@v3
     - name: Use Node.js
       uses: actions/setup-node@v3
       with:
-        node-version: 16
+        node-version: 18
     - name: Enable Node.js cache
       uses: actions/cache@v3
       with:
@@ -88,7 +91,7 @@ jobs:
     - name: Prepare environment
       run: |
         npm ci --ignore-scripts
-        clang-format-10 --version
+        clang-format-15 --version
     - name: Run checks
       run: |
         ./scripts/check_taginfo.py taginfo.json profiles/car.lua
@@ -145,44 +148,54 @@ jobs:
     strategy:
       matrix:
         include:
-          - name: gcc-9-debug-cov
+          - name: gcc-13-debug-cov
             continue-on-error: false
-            node: 16
-            runs-on: ubuntu-20.04
+            node: 20
+            runs-on: ubuntu-24.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: gcc-9
+            CCOMPILER: gcc-13
             CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: g++-9
+            CXXCOMPILER: g++-13
             ENABLE_COVERAGE: ON
 
-          - name: gcc-9-debug-asan-ubsan
+          - name: clang-15-debug-asan-ubsan
             continue-on-error: false
-            node: 16
-            runs-on: ubuntu-20.04
+            node: 20
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: gcc-9
+            CCOMPILER: clang-15
             CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: g++-9
+            CXXCOMPILER: clang++-15
             ENABLE_SANITIZER: ON
             TARGET_ARCH: x86_64-asan-ubsan
             OSRM_CONNECTION_RETRIES: 10
             OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
 
-          - name: clang-6.0-debug
+          - name: clang-15-release
             continue-on-error: false
-            node: 16
-            runs-on: ubuntu-20.04
+            node: 18
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
-            CCOMPILER: clang-6.0
-            CXXCOMPILER: clang++-6.0
+            BUILD_TYPE: Release
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             CUCUMBER_TIMEOUT: 60000
 
-          - name: clang-15.0-debug-clang-tidy
+          - name: clang-15-debug
             continue-on-error: false
-            node: 16
+            node: 18
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Debug
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
+            CUCUMBER_TIMEOUT: 60000
+
+          - name: clang-15-debug-clang-tidy
+            continue-on-error: false
+            node: 18
             runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Debug
@@ -191,117 +204,103 @@ jobs:
             CUCUMBER_TIMEOUT: 60000
             ENABLE_CLANG_TIDY: ON
 
-          - name: conan-linux-debug-asan-ubsan
+          - name: clang-14-release
             continue-on-error: false
-            node: 16
-            runs-on: ubuntu-20.04
+            node: 18
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-11
-            CXXCOMPILER: clang++-11
+            CCOMPILER: clang-14
+            CXXCOMPILER: clang++-14
+            CUCUMBER_TIMEOUT: 60000
+
+          - name: clang-13-release
+            continue-on-error: false
+            node: 18
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
+            CUCUMBER_TIMEOUT: 60000
+
+          - name: conan-linux-debug-asan-ubsan
+            continue-on-error: false
+            node: 18
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             ENABLE_CONAN: ON
             ENABLE_SANITIZER: ON
 
           - name: conan-linux-release
             continue-on-error: false
-            node: 16
-            runs-on: ubuntu-20.04
+            node: 18
+            runs-on: ubuntu-22.04
             BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-6.0
-            CXXCOMPILER: clang++-6.0
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
             ENABLE_CONAN: ON
 
+          - 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: 16
+            node: 20
             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: 16
-            runs-on: ubuntu-20.04
+            node: 20
+            runs-on: ubuntu-22.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: 16
-            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: 16
-            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: 16
-            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: 16
-            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: 18
-            runs-on: ubuntu-20.04
+            node: 20
+            runs-on: ubuntu-22.04
             BUILD_TYPE: Release
-            CCOMPILER: clang-6.0
-            CXXCOMPILER: clang++-6.0
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
           - name: conan-linux-debug-node
             build_node_package: true
             continue-on-error: false
-            node: 18
-            runs-on: ubuntu-20.04
+            node: 20
+            runs-on: ubuntu-22.04
             BUILD_TYPE: Debug
-            CCOMPILER: clang-6.0
-            CXXCOMPILER: clang++-6.0
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
           - name: conan-macos-x64-release-node
             build_node_package: true
             continue-on-error: true
-            node: 18
-            runs-on: macos-11
+            node: 20
+            runs-on: macos-13 # x86_64
             BUILD_TYPE: Release
             CCOMPILER: clang
             CXXCOMPILER: clang++
@@ -312,15 +311,14 @@ jobs:
           - name: conan-macos-arm64-release-node
             build_node_package: true
             continue-on-error: true
-            node: 18
-            runs-on: macos-11
+            node: 20
+            runs-on: macos-14 # arm64 
             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 }}
@@ -340,13 +338,13 @@ 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 }}
     steps:
     - uses: actions/checkout@v3
-
+    - name: Build machine architecture
+      run: uname -m
     - name: Use Node.js
       uses: actions/setup-node@v3
       with:
@@ -369,9 +367,9 @@ jobs:
       uses: actions/cache@v3
       with:
         path: ~/.conan
-        key: v6-conan-${{ matrix.name }}-${{ github.sha }}
+        key: v9-conan-${{ matrix.name }}-${{ github.sha }}
         restore-keys: |
-          v6-conan-${{ matrix.name }}-
+          v9-conan-${{ matrix.name }}-
     - name: Enable test cache
       uses: actions/cache@v3
       with:
@@ -390,6 +388,7 @@ 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
@@ -400,7 +399,7 @@ jobs:
 
     - name: Install dev dependencies
       run: |
-        python3 -m pip install "conan<2.0.0"
+        python3 -m pip install "conan<2.0.0" || python3 -m pip install "conan<2.0.0" --break-system-packages
 
         # 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
@@ -415,19 +414,8 @@ 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 [ "${TARGET_ARCH}" != "i686" ] && [ "${ENABLE_CONAN}" != "ON" ]; then
+        if [ "${ENABLE_CONAN}" != "ON" ]; then
           sudo apt-get update -y
           sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev libboost-all-dev
           if [[ "${CCOMPILER}" != clang-* ]]; then
@@ -436,9 +424,6 @@ jobs:
           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
@@ -462,22 +447,18 @@ jobs:
         fi
         echo "CC=${CCOMPILER}" >> $GITHUB_ENV
         echo "CXX=${CXXCOMPILER}" >> $GITHUB_ENV
+        if [[ "${RUNNER_OS}" == "macOS" ]]; then
+          # missing from GCC path, needed for conan builds of libiconv, for example.
+          sudo xcode-select --switch /Library/Developer/CommandLineTools
+          echo "LIBRARY_PATH=${LIBRARY_PATH}:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib" >> $GITHUB_ENV
+          echo "CPATH=${CPATH}:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include" >> $GITHUB_ENV
+        fi
 
     - name: Build and install OSRM
       run: |
         echo "Using ${JOBS} jobs"
         pushd ${OSRM_BUILD_DIR}
 
-        # 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} \
@@ -489,12 +470,10 @@ jobs:
                  -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
                  -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
                  -DENABLE_CCACHE=ON \
-                 -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-                 "${APPLE_SILICON_FLAGS[@]}"
-
+                 -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
         make --jobs=${JOBS}
 
-        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" && "${ENABLE_APPLE_SILICON}" != "ON" ]]; then
+        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
           make tests --jobs=${JOBS}
           make benchmarks --jobs=${JOBS}
           ccache -s
@@ -506,14 +485,14 @@ jobs:
         fi
         popd
     - name: Build example
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
       run: |
         mkdir example/build && pushd example/build
         cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
         make --jobs=${JOBS}
         popd
     - name: Run all tests
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
       run: |
         make -C test/data benchmark
 
@@ -524,50 +503,39 @@ 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}" ] && [ "$TARGET_ARCH" != "i686" ]; then
+        if [ -z "${ENABLE_SANITIZER}" ]; 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 16
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
-      uses: actions/setup-node@v3
-      with:
-        node-version: 16
-    - name: Run Node package tests on Node 16
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
-      run: |
-        node --version
-        npm run nodejs-tests
     - name: Use Node 18
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
       uses: actions/setup-node@v3
       with:
         node-version: 18
     - name: Run Node package tests on Node 18
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      run: |
+        node --version
+        npm run nodejs-tests
+    - name: Use Node 20
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: 20
+    - name: Run Node package tests on Node 20
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
       run: |
         node --version
         npm run nodejs-tests
     - name: Use Node latest
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
       uses: actions/setup-node@v3
       with:
         node-version: latest
     - name: Run Node package tests on Node-latest
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
       run: |
         node --version
         npm run nodejs-tests
@@ -579,30 +547,22 @@ jobs:
         name: logs
         path: test/logs/
 
-    - name: Generate code coverage
-      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-      run: |
-        lcov --directory . --capture --output-file coverage.info # capture coverage info
-        lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
-        lcov --list coverage.info #debug info
-        # Uploading report to CodeCov
-    - name: Upload code coverage
-      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-      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: Generate code coverage
+    #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
+    #   run: |
+    #     lcov --directory . --capture --output-file coverage.info # capture coverage info
+    #     lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
+    #     lcov --list coverage.info #debug info
+    
+    # # Uploading report to CodeCov
+    # - name: Upload code coverage
+    #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
+    #   uses: codecov/codecov-action@v1
+    #   with:
+    #     files: coverage.info
+    #     name: codecov-osrm-backend
+    #     fail_ci_if_error: true
+    #     verbose: true
     - name: Build Node package
       if: ${{ matrix.build_node_package }}
       run: ./scripts/ci/node_package.sh
@@ -620,8 +580,72 @@ jobs:
         replacesArtifacts: true
         token: ${{ secrets.GITHUB_TOKEN }}
 
+
+  benchmarks:
+    if: github.event_name == 'pull_request'
+    needs: [format-taginfo-docs]
+    runs-on: ubuntu-22.04
+    env:
+      CCOMPILER: clang-13
+      CXXCOMPILER: clang++-13
+      CC: clang-13
+      CXX: clang++-13
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      PR_NUMBER: ${{ github.event.pull_request.number }}
+      GITHUB_REPOSITORY: ${{ github.repository }}
+    steps: 
+      - name: Enable compiler cache
+        uses: actions/cache@v3
+        with:
+          path: ~/.ccache
+          key: v1-ccache-benchmarks-${{ github.sha }}
+          restore-keys: |
+            v1-ccache-benchmarks-
+      - name: Enable Conan cache
+        uses: actions/cache@v3
+        with:
+          path: ~/.conan
+          key: v1-conan-benchmarks-${{ github.sha }}
+          restore-keys: |
+            v1-conan-benchmarks-
+      - name: Checkout PR Branch
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.head_ref }}
+          path: pr
+      - run: python3 -m pip install "conan<2.0.0" "requests==2.31.0"
+      - name: Build PR Branch
+        run: |
+          mkdir -p pr/build
+          cd pr/build
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
+          make -j$(nproc) 
+          make -j$(nproc) benchmarks
+          cd ..
+          make -C test/data 
+      - name: Checkout Base Branch
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.base.ref }}
+          path: base
+      - name: Build Base Branch
+        run: |
+          mkdir base/build
+          cd base/build
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
+          make -j$(nproc)
+          make -j$(nproc) benchmarks
+          cd ..
+          make -C test/data 
+      - name: Run Benchmarks
+        run: |
+          ./pr/scripts/ci/run_benchmarks.sh base pr
+      - name: Post Benchmark Results
+        run: |
+          python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
+
   ci-complete:
     runs-on: ubuntu-22.04
-    needs: [build-test-publish, docker-image, windows-release-node]
+    needs: [build-test-publish, docker-image, windows-release-node, benchmarks]
     steps:
     - run: echo "CI complete"

CHANGELOG.md

@@ -1,17 +1,26 @@
 # Unreleased
   - Changes from 5.27.1
     - Features
+      - 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:
       - 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: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551)
+      - 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)
@@ -30,10 +39,21 @@
       - FIXED: Added a variable to preprocessor guard in file osrm-backend/include/util/range_table.hpp to solve build error. [#6596](https://github.com/Project-OSRM/osrm-backend/pull/6596)
       - FIXED: Ensure required file check in osrm-routed is correctly enforced. [#6655](https://github.com/Project-OSRM/osrm-backend/pull/6655)
       - FIXED: Correct HTTP docs to reflect summary output dependency on steps parameter. [#6655](https://github.com/Project-OSRM/osrm-backend/pull/6655)
+      - 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)
     - 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. [#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)
+
 # 5.27.1
   - Changes from 5.27.0
     - Misc:

CMakeLists.txt

@@ -42,16 +42,13 @@ if (ENABLE_CLANG_TIDY)
     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=*")
+    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
   endif()
 endif()
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 # be compatible with version handling before cmake 3.x
-if (POLICY CMP0048)
-  cmake_policy(SET CMP0048 OLD)
-endif()
 if (POLICY CMP0057)
   cmake_policy(SET CMP0057 NEW)
 endif()
@@ -73,14 +70,17 @@ include(JSONParser)
 file(READ "package.json" packagejsonraw)
 sbeParseJson(packagejson packagejsonraw)
 
-if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)")
-    set(OSRM_VERSION_MAJOR ${CMAKE_MATCH_1})
-    set(OSRM_VERSION_MINOR ${CMAKE_MATCH_2})
-    set(OSRM_VERSION_PATCH ${CMAKE_MATCH_3})
+# This regex is not strict enough, but the correct one is too complicated for cmake matching.
+# https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)([-+][0-9a-zA-Z.-]+)?$")
+    set(OSRM_VERSION_MAJOR            ${CMAKE_MATCH_1})
+    set(OSRM_VERSION_MINOR            ${CMAKE_MATCH_2})
+    set(OSRM_VERSION_PATCH            ${CMAKE_MATCH_3})
+    set(OSRM_VERSION_PRERELEASE_BUILD ${CMAKE_MATCH_4})
 
-    set(OSRM_VERSION "${OSRM_VERSION_MAJOR}.${OSRM_VERSION_MINOR}.${OSRM_VERSION_PATCH}")
+    set(OSRM_VERSION packagejson.version)
 else()
-    message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible X.Y.Z, but found ${packagejson.version}")
+    message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible label, but found ${packagejson.version}")
 endif()
 
 if (MSVC)
@@ -115,7 +115,7 @@ include(GNUInstallDirs)
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
   message(STATUS "Building on a 64 bit system")
 else()
-  message(STATUS "Building on a 32 bit system")
+  message(FATAL_ERROR "Building on a 32 bit system is not supported")
 endif()
 
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
@@ -151,7 +151,7 @@ add_library(UPDATER OBJECT ${UpdaterGlob})
 add_library(STORAGE OBJECT ${StorageGlob})
 add_library(ENGINE OBJECT ${EngineGlob})
 
-if (BUILD_ROUTED) 
+if (BUILD_ROUTED)
   add_library(SERVER OBJECT ${ServerGlob})
   add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
 endif()
@@ -223,7 +223,7 @@ endif()
 set(MAYBE_COVERAGE_LIBRARIES "")
 if (ENABLE_COVERAGE)
   if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
-    message(ERROR "ENABLE_COVERAGE=ON only make sense with a Debug build")
+    message(ERROR "ENABLE_COVERAGE=ON only makes sense with a Debug build")
   endif()
   message(STATUS "Enabling coverage")
   set(MAYBE_COVERAGE_LIBRARIES "-lgcov")
@@ -309,10 +309,10 @@ 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-9.1.0/include")
+set(FMT_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/fmt/include")
 add_compile_definitions(FMT_HEADER_ONLY)
 include_directories(SYSTEM ${FMT_INCLUDE_DIR})
-        
+
 
 # see https://stackoverflow.com/questions/70898030/boost-link-error-using-conan-find-package
 if (MSVC)
@@ -322,22 +322,24 @@ endif()
 if(ENABLE_CONAN)
   message(STATUS "Installing dependencies via Conan")
 
-  # Conan will generate Find*.cmake files to build directory, so we use them with the highest priority 
+  # Conan will generate Find*.cmake files to build directory, so we use them with the highest priority
   list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_BINARY_DIR})
   list(INSERT CMAKE_PREFIX_PATH 0 ${CMAKE_BINARY_DIR})
 
   include(${CMAKE_CURRENT_LIST_DIR}/cmake/conan.cmake)
 
-  set(CONAN_BOOST_VERSION "1.79.0#96e4902111a2e343a8ba0aa95391bb58")
-  set(CONAN_BZIP2_VERSION "1.0.8#d1b2d5816f25865acf978501dff1f897")
-  set(CONAN_EXPAT_VERSION "2.2.10#916908d4a570ad839edd25322c3268cd")
-  set(CONAN_LUA_VERSION "5.4.4#3ec62efc37cd0a5d80b9e5cb35277360")
-  set(CONAN_TBB_VERSION "2021.3.0#507ec17cbd51a84167e143b20d170eea")
-  
+  conan_check(REQUIRED)
+
+  set(CONAN_BOOST_VERSION "1.85.0@#14265ec82b25d91305bbb3b30d3357f8")
+  set(CONAN_BZIP2_VERSION "1.0.8@#d1b2d5816f25865acf978501dff1f897")
+  set(CONAN_EXPAT_VERSION "2.2.10@#916908d4a570ad839edd25322c3268cd")
+  set(CONAN_LUA_VERSION "5.4.4@#3ec62efc37cd0a5d80b9e5cb35277360")
+  set(CONAN_TBB_VERSION "2021.3.0@#507ec17cbd51a84167e143b20d170eea")
+
   set(CONAN_SYSTEM_INCLUDES ON)
 
-  # TODO: 
-  # if we link TBB dynamically osrm-extract.exe finishes on the first access to any TBB symbol 
+  # 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)
@@ -345,22 +347,29 @@ if(ENABLE_CONAN)
     set(TBB_SHARED True)
   endif()
 
-  set(CONAN_ARGS       
-    REQUIRES 
+  set(CONAN_ARGS
+    REQUIRES
     "boost/${CONAN_BOOST_VERSION}"
     "bzip2/${CONAN_BZIP2_VERSION}"
     "expat/${CONAN_EXPAT_VERSION}"
     "lua/${CONAN_LUA_VERSION}"
     "onetbb/${CONAN_TBB_VERSION}"
-    BASIC_SETUP 
+    BASIC_SETUP
     GENERATORS cmake_find_package json  # json generator generates a conanbuildinfo.json in the build folder so (non-CMake) projects can easily parse OSRM's dependencies
     KEEP_RPATHS
     NO_OUTPUT_DIRS
     OPTIONS boost:filesystem_version=3 # https://stackoverflow.com/questions/73392648/error-with-boost-filesystem-version-in-cmake
-            onetbb:shared=${TBB_SHARED}
+            # onetbb:shared=${TBB_SHARED}
             boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
     BUILD missing
   )
+
+  # Enable revisions in the conan config
+  execute_process(COMMAND ${CONAN_CMD} config set general.revisions_enabled=1 RESULT_VARIABLE RET_CODE)
+  if(NOT "${RET_CODE}" STREQUAL "0")
+    message(FATAL_ERROR "Error setting revisions for Conan: '${RET_CODE}'")
+  endif()
+
   # explicitly say Conan to use x86 dependencies if build for x86 platforms (https://github.com/conan-io/cmake-conan/issues/141)
   if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
     conan_cmake_run("${CONAN_ARGS};ARCH;x86")
@@ -389,7 +398,7 @@ if(ENABLE_CONAN)
   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}")
-  
+
 
   find_package(BZip2 REQUIRED)
   find_package(EXPAT REQUIRED)
@@ -462,6 +471,9 @@ 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_)
+
 add_definitions(${OSRM_DEFINES})
 include_directories(SYSTEM ${DEPENDENCIES_INCLUDE_DIRS})
 
@@ -639,6 +651,10 @@ install(TARGETS osrm_guidance DESTINATION lib)
 set(DefaultProfilesDir profiles)
 install(DIRECTORY ${DefaultProfilesDir} DESTINATION share/osrm)
 
+# Install data geojson files to /usr/local/share/osrm/data by default
+set(DefaultProfilesDir data)
+install(DIRECTORY ${DefaultProfilesDir} DESTINATION share/osrm)
+
 # Setup exporting variables for pkgconfig and subproject
 #
 
@@ -733,23 +749,23 @@ if (ENABLE_FUZZING)
   add_subdirectory(fuzz)
 endif ()
 
-# add headers sanity check target that includes all headers independently	
-set(check_headers_dir "${PROJECT_BINARY_DIR}/check-headers")	
-file(GLOB_RECURSE headers_to_check	
-  ${PROJECT_BINARY_DIR}/*.hpp	
-  ${PROJECT_SOURCE_DIR}/include/*.hpp)	
-foreach(header ${headers_to_check})	
+# add headers sanity check target that includes all headers independently
+set(check_headers_dir "${PROJECT_BINARY_DIR}/check-headers")
+file(GLOB_RECURSE headers_to_check
+  ${PROJECT_BINARY_DIR}/*.hpp
+  ${PROJECT_SOURCE_DIR}/include/*.hpp)
+foreach(header ${headers_to_check})
   if ("${header}" MATCHES ".*/include/nodejs/.*")
     # we do not check NodeJS bindings headers
     continue()
   endif()
-  get_filename_component(filename ${header} NAME_WE)	
-  set(filename "${check_headers_dir}/${filename}.cpp")	
-  if (NOT EXISTS ${filename})	
-    file(WRITE ${filename} "#include \"${header}\"\n")	
-  endif()	
-  list(APPEND sources ${filename})	
-endforeach()	
-add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})	
-set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})	
+  get_filename_component(filename ${header} NAME_WE)
+  set(filename "${check_headers_dir}/${filename}.cpp")
+  if (NOT EXISTS ${filename})
+    file(WRITE ${filename} "#include \"${header}\"\n")
+  endif()
+  list(APPEND sources ${filename})
+endforeach()
+add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
+set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
 

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 `3.8` to consistently format the code base. There is a helper script under `scripts/format.sh`.
+We use `clang-format` version `15` 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,12 +15,12 @@ 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 [this guide about mapping for navigation](https://www.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 [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/).
 
 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
 - [osrm-text-instructions](https://github.com/Project-OSRM/osrm-text-instructions) - Text instructions from OSRM route response
-- [osrm-backend-docker](https://hub.docker.com/r/osrm/osrm-backend/) - Ready to use Docker images
+- [osrm-backend-docker](https://github.com/project-osrm/osrm-backend/pkgs/container/osrm-backend) - Ready to use Docker images
 
 ## Documentation
 

appveyor.yml

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

@@ -1,32 +0,0 @@
-@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%

docs/http.md

@@ -35,7 +35,7 @@ To pass parameters to each location some options support an array-like encoding:
 |radiuses        |`{radius};{radius}[;{radius} ...]`                      |Limits the search to given radius in meters.                                                                                                                                                               |
 |generate\_hints |`true` (default), `false`                               |Adds a Hint to the response which can be used in subsequent requests, see `hints` parameter.                                                                                                               |
 |hints           |`{hint};{hint}[;{hint} ...]`                            |Hint from previous request to derive position in street network.                                                                                                                                           |
-|approaches      |`{approach};{approach}[;{approach} ...]`                |Keep waypoints on curbside.                                                                                                                                                                               |
+|approaches      |`{approach};{approach}[;{approach} ...]`                |Restrict the direction on the road network at a waypoint, relative to the input coordinate.                                                                                                                    |
 |exclude         |`{class}[,{class}]`                                     |Additive list of classes to avoid, the order does not matter.                                                                                                                                                  |
 |snapping        |`default` (default), `any`                              |Default snapping avoids is_startpoint (see profile) edges, `any` will snap to any edge in the graph                                                                                                        |
 |skip_waypoints  |`true`, `false` (default)                               |Removes waypoints from the response. Waypoints are still calculated, but not serialized. Could be useful in case you are interested in some other part of the response and do not want to transfer waste data. |
@@ -47,7 +47,7 @@ Where the elements follow the following format:
 |bearing     |`{value},{range}` `integer 0 .. 360,integer 0 .. 180`   |
 |radius      |`double >= 0` or `unlimited` (default)                  |
 |hint        |Base64 `string`                                         |
-|approach    |`curb` or `unrestricted` (default)                      |
+|approach    |`curb`, `opposite` or `unrestricted` (default)          |
 |class       |A class name determined by the profile or `none`.       |
 
 ```

docs/nodejs/api.md

@@ -63,7 +63,7 @@ Returns the fastest route between two or more coordinates while visiting the way
     -   `options.geometries` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
     -   `options.overview` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
     -   `options.continue_straight` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile.
-    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Restrict the direction on the road network at a waypoint, relative to the input coordinate. Can be `null` (unrestricted, default), `curb` or `opposite`.
                          `null`/`true`/`false`
     -   `options.waypoints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints. If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
     -   `options.format` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which output format to use, either `json`, or [`flatbuffers`](https://github.com/Project-OSRM/osrm-backend/tree/master/include/engine/api/flatbuffers).
@@ -101,7 +101,7 @@ Note: `coordinates` in the general options only supports a single `{longitude},{
     -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
     -   `options.number` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)** Number of nearest segments that should be returned.
         Must be an integer greater than or equal to `1`. (optional, default `1`)
-    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Restrict the direction on the road network at a waypoint, relative to the input coordinate. Can be `null` (unrestricted, default), `curb` or `opposite`.
     -   `options.format` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which output format to use, either `json`, or [`flatbuffers`](https://github.com/Project-OSRM/osrm-backend/tree/master/include/engine/api/flatbuffers).
     -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
@@ -141,7 +141,7 @@ Optionally returns distance table.
     -   `options.sources` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer < #coordinates`) to use
                                          location with given index as source. Default is to use all.
     -   `options.destinations` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer < #coordinates`) to use location with given index as destination. Default is to use all.
-    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Restrict the direction on the road network at a waypoint, relative to the input coordinate.. Can be `null` (unrestricted, default), `curb` or `opposite`.
     -   `options.fallback_speed` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Replace `null` responses in result with as-the-crow-flies estimates based on `fallback_speed`.  Value is in metres/second.
     -   `options.fallback_coordinate` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Either `input` (default) or `snapped`.  If using a `fallback_speed`, use either the user-supplied coordinate (`input`), or the snapped coordinate (`snapped`) for calculating the as-the-crow-flies distance between two points.
     -   `options.scale_factor` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Multiply the table duration values in the table by this number for more controlled input into a route optimization solver.
@@ -298,7 +298,7 @@ Right now, the following combinations are possible:
     -   `options.roundtrip` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route is a roundtrip. (optional, default `true`)
     -   `options.source` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route starts at `any` or `first` coordinate. (optional, default `any`)
     -   `options.destination` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route ends at `any` or `last` coordinate. (optional, default `any`)
-    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Restrict the direction on the road network at a waypoint, relative to the input coordinate. Can be `null` (unrestricted, default), `curb` or `opposite`.
     -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`. `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
 

features/car/traffic_light_penalties.feature

@@ -32,14 +32,14 @@ Feature: Car - Handle traffic lights
             | l    | traffic_signals |
 
         When I route I should get
-            | from | to | time   | # |
+            | from | to | time   | #                             |
             | 1    | 2  |  11.1s | no turn with no traffic light |
             | 3    | 4  |  13.1s | no turn with traffic light    |
             | g    | j  |  18.7s | turn with no traffic light    |
             | k    | n  |  20.7s | turn with traffic light       |
 
 
-    Scenario: Car - Traffic signal direction
+    Scenario: Car - Traffic signal direction straight
         Given the node map
             """
             a-1-b-2-c
@@ -112,14 +112,14 @@ Feature: Car - Handle traffic lights
 
 
 
-    Scenario: Car - Encounters a traffic light
+    Scenario: Car - Encounters a traffic light direction
         Given the node map
             """
-              a      f      k
-              |      |      |
-            b-c-d  h-g-i  l-m-n
-              |      |      |
-              e      j      o
+              a      f      k      p
+              |      |      |      |
+            b-c-d  h-g-i  l-m-n  q-r-s
+              |      |      |      |
+              e      j      o      t
 
             """
 
@@ -131,53 +131,70 @@ Feature: Car - Handle traffic lights
             | fgj   | primary |
             | lmn   | primary |
             | kmo   | primary |
+            | qrs   | primary |
+            | prt   | primary |
 
         And the nodes
             | node | highway         | traffic_signals:direction |
-            | g    | traffic_signals | forward                   |
-            | m    | traffic_signals | backward                  |
+            | g    | traffic_signals |                           |
+            | m    | traffic_signals | forward                   |
+            | r    | traffic_signals | backward                  |
 
 
         When I route I should get
+            # Base case
             | from | to | time   | #                             |
-            | a    | d  | 21.9s  | no turn with no traffic light |
-            | a    | e  | 22.2s  | no turn with traffic light    |
             | a    | b  | 18.7s  | turn with no traffic light    |
-            | e    | b  | 21.9s  | no turn with no traffic light |
-            | e    | a  | 22.2s  | no turn with traffic light    |
+            | a    | e  | 22.2s  | no turn with no traffic light |
+            | a    | d  | 21.9s  | turn with no traffic light    |
+            | e    | b  | 21.9s  | turn with no traffic light    |
+            | e    | a  | 22.2s  | no turn with no traffic light |
             | e    | d  | 18.7s  | turn with no traffic light    |
-            | d    | e  | 21.9s  | no turn with no traffic light |
-            | d    | b  | 11s    | no turn with traffic light    |
+            | d    | e  | 21.9s  | turn with no traffic light    |
+            | d    | b  | 11s    | no turn with no traffic light |
             | d    | a  | 18.7s  | turn with no traffic light    |
-            | b    | a  | 21.9s  | no turn with no traffic light |
-            | b    | d  | 11s    | no turn with traffic light    |
+            | b    | a  | 21.9s  | turn with no traffic light    |
+            | b    | d  | 11s    | no turn with no traffic light |
             | b    | e  | 18.7s  | turn with no traffic light    |
-
-            | f    | i  | 23.9s  | no turn with no traffic light |
+            # All have traffic lights - 2s penalty
+            | f    | h  | 20.7s  | turn with traffic light       |
             | f    | j  | 24.2s  | no turn with traffic light    |
-            | f    | h  | 20.7s  | turn with no traffic light    |
-            | j    | h  | 21.9s  | no turn with no traffic light |
-            | j    | f  | 22.2s  | no turn with traffic light    |
-            | j    | i  | 18.7s  | turn with no traffic light    |
-            | i    | j  | 21.9s  | no turn with no traffic light |
-            | i    | h  | 11s    | no turn with traffic light    |
-            | i    | f  | 18.7s  | turn with no traffic light    |
-            | h    | f  | 23.9s  | no turn with no traffic light |
+            | f    | i  | 23.9s  | turn with traffic light       |
+            | j    | h  | 23.9s  | turn with traffic light       |
+            | j    | f  | 24.2s  | no turn with traffic light    |
+            | j    | i  | 20.7s  | turn with traffic light       |
+            | i    | j  | 23.9s  | turn with traffic light       |
+            | i    | h  | 13s    | no turn with traffic light    |
+            | i    | f  | 20.7s  | turn with traffic light       |
+            | h    | f  | 23.9s  | turn with traffic light       |
             | h    | i  | 13s    | no turn with traffic light    |
-            | h    | j  | 20.7s  | turn with no traffic light    |
-
-            | k    | n  | 21.9s  | no turn with no traffic light |
-            | k    | o  | 22.2s  | no turn with traffic light    |
-            | k    | l  | 18.7s  | turn with no traffic light    |
-            | o    | l  | 23.9s  | no turn with no traffic light |
-            | o    | k  | 24.2s  | no turn with traffic light    |
-            | o    | n  | 20.7s  | turn with no traffic light    |
-            | n    | o  | 23.9s  | no turn with no traffic light |
-            | n    | l  | 13s    | no turn with traffic light    |
-            | n    | k  | 20.7s  | turn with no traffic light    |
-            | l    | k  | 21.9s  | no turn with no traffic light |
-            | l    | n  | 11s    | no turn with traffic light    |
-            | l    | o  | 18.7s  | turn with no traffic light    |
+            | h    | j  | 20.7s  | turn with traffic light       |
+            # Front direction have traffic lights - 2s penalty
+            | k    | l  | 20.7s  | turn with traffic light       |
+            | k    | o  | 24.2s  | no turn with traffic light    |
+            | k    | n  | 23.9s  | turn with traffic light       |
+            | o    | l  | 21.9s  | turn with no traffic light    |
+            | o    | k  | 22.2s  | no turn with no traffic light |
+            | o    | n  | 18.7s  | turn with no traffic light    |
+            | n    | o  | 21.9s  | turn with no traffic light    |
+            | n    | l  | 11s    | no turn with no traffic light |
+            | n    | k  | 18.7s  | turn with no traffic light    |
+            | l    | k  | 23.9s  | turn with traffic light       |
+            | l    | n  | 13s    | no turn with traffic light    |
+            | l    | o  | 20.7s  | turn with traffic light       |
+            # Reverse direction have traffic lights - 2s penalty
+            | p    | q  | 18.7s  | turn with no traffic light    |
+            | p    | t  | 22.2s  | no turn with no traffic light |
+            | p    | s  | 21.9s  | turn with no traffic light    |
+            | t    | q  | 23.9s  | turn with traffic light       |
+            | t    | p  | 24.2s  | no turn with traffic light    |
+            | t    | s  | 20.7s  | turn with traffic light       |
+            | s    | t  | 23.9s  | turn with traffic light       |
+            | s    | q  | 13s    | no turn with traffic light    |
+            | s    | p  | 20.7s  | turn with traffic light       |
+            | q    | p  | 21.9s  | turn with no traffic light    |
+            | q    | s  | 11s    | no turn with no traffic light |
+            | q    | t  | 18.7s  | turn with no traffic light    |
 
 
     Scenario: Traffic Signal Geometry
@@ -343,3 +360,106 @@ Feature: Car - Handle traffic lights
           | from | to | route   | speed   | weights | time  | distances | a:datasources | a:nodes | a:speed | a:duration |  a:weight |
           | a    | c  | abc,abc | 65 km/h | 22.2,0  | 22.2s | 400m,0m   |           1:0 |  1:2:3  |   18:18 |  11.1:11.1 | 11.1:11.1 |
           | c    | a  | abc,abc | 60 km/h | 24.2,0  | 24.2s | 400m,0m   |           0:1 |  3:2:1  |   18:18 |  11.1:11.1 | 11.1:11.1 |
+
+
+    Scenario: Car - Traffic signal straight direction with edge compression
+        Given the node map
+            """
+            a-1-b - c - d-2-e
+
+            """
+
+        And the ways
+            | nodes | highway |
+            | abcde | primary |
+
+        And the nodes
+            | node | highway         | traffic_signals:direction |
+            | c    | traffic_signals | forward                   |
+
+        When I route I should get
+            | from | to | time   | weight | #                             |
+            | 1    | 2  |  35.3s | 35.3   | no turn with traffic light    |
+            | 2    | 1  |  33.3s | 33.3   | no turn with no traffic light |
+
+
+    Scenario: Car - Traffic signal turn direction with edge compression
+        Given the node map
+            """
+                        d
+                        |
+                        2
+                        |
+            a-1-b - c - f
+                        |
+                        e
+
+                        j
+                        |
+                        4
+                        |
+            g-3-h - i - k
+                        |
+                        l
+
+            """
+
+        And the ways
+            | nodes | highway |
+            | abc   | primary |
+            | cf    | primary |
+            | fd    | primary |
+            | fe    | primary |
+            | ghi   | primary |
+            | ik    | primary |
+            | kj    | primary |
+            | kl    | primary |
+
+        And the nodes
+            | node | highway         | traffic_signals:direction |
+            | k    | traffic_signals | forward                   |
+
+        When I route I should get
+            | from | to | time   | weight | #                          |
+            | 1    | 2  |  44.2s | 44.2   | turn with no traffic light |
+            | 2    | 1  |  41s   | 41     | turn with no traffic light |
+            | 3    | 4  |  46.2s | 46.2   | turn with traffic light    |
+            | 4    | 3  |  41s   | 41     | turn with no traffic light |
+
+
+    Scenario: Car - Traffic signal turn direction with turn restriction
+        Given the node map
+            """
+                        d
+                        |
+                        2
+                        |
+            a-1-b - c - f
+                        |
+                        e
+
+            """
+
+        And the ways
+            | nodes | highway |
+            | abc   | primary |
+            | cf    | primary |
+            | fd    | primary |
+            | fe    | primary |
+
+        And the nodes
+            | node | highway         | traffic_signals:direction |
+            | f    | traffic_signals | forward                   |
+
+        And the relations
+            | type        | way:from | way:to | way:via  | restriction   |
+            | restriction | abc      | fe     | cf       | no_right_turn |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction     |
+            | restriction | df       | fc     | f        | right_turn_only |
+
+        When I route I should get
+            | from | to | time   | weight | #                          |
+            | 1    | 2  |  46.2s | 46.2   | turn with traffic light    |
+            | 2    | 1  |  41s   | 41     | turn with no traffic light |

features/options/extract/lua.feature

@@ -154,3 +154,27 @@ Feature: osrm-extract lua ways:get_nodes()
         Then it should exit successfully
         And stdout should contain "node 42"
         And stdout should contain "way 42"
+
+    Scenario: osrm-extract flags accessible in process_segment function
+        Given the profile file
+        """
+        functions = require('testbot')
+
+        functions.process_segment = function (profile, segment)
+            print('segment forward ' .. tostring(segment.flags.forward) .. ' backward ' .. tostring(segment.flags.backward))
+        end
+
+        return functions
+        """
+
+        And the node map
+            """
+            a b
+            """
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+        And the data has been saved to disk
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        And stdout should contain "segment forward true backward false"

features/options/routed/help.feature

@@ -23,6 +23,7 @@ Feature: osrm-routed command line options: help
         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
@@ -44,6 +45,7 @@ Feature: osrm-routed command line options: help
         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
@@ -65,4 +67,5 @@ Feature: osrm-routed command line options: help
         And stdout should contain "--max-table-size"
         And stdout should contain "--max-matching-size"
         And stdout should contain "--default-radius"
+        And stdout should contain "--keepalive-timeout"
         And it should exit successfully

features/testbot/approaches.feature

@@ -38,7 +38,41 @@ Feature: Approach parameter
             | from | to | approaches        | route    |
             | s    | e  | unrestricted curb | ab,bc,bc |
 
-    Scenario: Start End opposite approach, option unrestricted for Start and End
+    Scenario: Start End same approach, option unrestricted for Start and opposite for End
+        Given the profile "testbot"
+        And the node map
+            """
+               s        e
+            a------b------c
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches            | route |
+            | s    | e  | unrestricted opposite | ab,bc |
+
+    Scenario: Start End same approach, option opposite for Start and curb for End
+        Given the profile "testbot"
+        And the node map
+            """
+               s        e
+            a------b------c
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches            | route    |
+            | s    | e  | opposite curb         | ab,bc,bc |
+
+    Scenario: Start End different approach, option unrestricted for Start and End
         Given the profile "testbot"
         And the node map
             """
@@ -56,7 +90,7 @@ Feature: Approach parameter
             | from | to | approaches                | route |
             | s    | e  | unrestricted unrestricted | ab,bc |
 
-    Scenario: Start End opposite approach, option unrestricted for Start and curb for End
+    Scenario: Start End different approach, option unrestricted for Start and curb for End
         Given the profile "testbot"
         And the node map
             """
@@ -74,6 +108,43 @@ Feature: Approach parameter
             | from | to | approaches        | route |
             | s    | e  | unrestricted curb | ab,bc |
 
+    Scenario: Start End different approach, option unrestricted for Start and opposite for End
+        Given the profile "testbot"
+        And the node map
+            """
+               s
+            a------b------c
+                        e
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches            | route    |
+            | s    | e  | unrestricted opposite | ab,bc,bc |
+
+    Scenario: Start End different approach, option curb for Start and opposite for End
+        Given the profile "testbot"
+        And the node map
+            """
+               e
+            a------b------c-----------d
+                              s
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | cd    |
+
+        When I route I should get
+            | from | to | approaches    | route       |
+            | s    | e  | curb opposite | cd,cd,ab,ab |
+
 
     ###############
     # Oneway Test #
@@ -111,10 +182,44 @@ Feature: Approach parameter
             | bc    | yes    |
 
         When I route I should get
-            | from | to | approaches        | route    |
+            | from | to | approaches        | route |
             | s    | e  | unrestricted curb | ab,bc |
 
-    Scenario: Test on oneway segment, Start End opposite approach, option unrestricted for Start and End
+    Scenario: Test on oneway segment, Start End same approach, option unrestricted for Start and opposite for End
+        Given the profile "testbot"
+        And the node map
+            """
+               s        e
+            a------b------c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bc    | yes    |
+
+        When I route I should get
+            | from | to | approaches            | route |
+            | s    | e  | unrestricted opposite | ab,bc |
+
+    Scenario: Test on oneway segment, Start End same approach, option opposite for Start and curb for End
+        Given the profile "testbot"
+        And the node map
+            """
+               s        e
+            a------b------c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bc    | yes    |
+
+        When I route I should get
+            | from | to | approaches    | route |
+            | s    | e  | opposite curb | ab,bc |
+
+    Scenario: Test on oneway segment, Start End different approach, option unrestricted for Start and End
         Given the profile "testbot"
         And the node map
             """
@@ -132,7 +237,7 @@ Feature: Approach parameter
             | from | to | approaches                | route |
             | s    | e  | unrestricted unrestricted | ab,bc |
 
-    Scenario: Test on oneway segment, Start End opposite approach, option unrestricted for Start and curb for End
+    Scenario: Test on oneway segment, Start End different approach, option unrestricted for Start and curb for End
         Given the profile "testbot"
         And the node map
             """
@@ -150,6 +255,42 @@ Feature: Approach parameter
             | from | to | approaches        | route |
             | s    | e  | unrestricted curb | ab,bc |
 
+    Scenario: Test on oneway segment, Start End different approach, option unrestricted for Start and opposite for End
+        Given the profile "testbot"
+        And the node map
+            """
+               s
+            a------b------c
+                        e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bc    | yes    |
+
+        When I route I should get
+            | from | to | approaches            | route |
+            | s    | e  | unrestricted opposite | ab,bc |
+
+    Scenario: Test on oneway segment, Start End different approach, option curb for Start and opposite for End
+        Given the profile "testbot"
+        And the node map
+            """
+               s
+            a------b------c
+                        e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bc    | yes    |
+
+        When I route I should get
+            | from | to | approaches    | route |
+            | s    | e  | curb opposite | ab,bc |
+
     ##############
     # UTurn Test #
     ##############
@@ -175,6 +316,27 @@ Feature: Approach parameter
             | from | to | approaches        | route |
             | s    | e  | unrestricted curb |       |
 
+    Scenario: UTurn test, router can find a route because uturn authorized to reach opposite side
+        Given the profile "testbot"
+        And the node map
+            """
+               e        s
+            a------b------c
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction |
+            | restriction | bc       | bc     | c        | no_u_turn   |
+
+        When I route I should get
+            | from | to | approaches    | route     |
+            | s    | e  | curb opposite | bc,ab,ab  |
+
 
     Scenario: UTurn test, router can find a route because he can use the roundabout
         Given the profile "testbot"
@@ -198,8 +360,9 @@ Feature: Approach parameter
             | restriction | bc       | bc     | c        | no_u_turn   |
 
         When I route I should get
-            | from | to | approaches        | route    |
-            | s    | e  | unrestricted curb | ab,bc,bc |
+            | from | to | approaches         | route    |
+            | s    | e  | unrestricted curb  | ab,bc,bc |
+            | s    | e  | opposite curb      | ab,bc,bc |
 
 
     Scenario: Start End same approach, option unrestricted for Start and curb for End, left-hand driving
@@ -228,6 +391,32 @@ Feature: Approach parameter
             | from | to | approaches        | route |
             | s    | e  | unrestricted curb | ab,bc |
 
+    Scenario: Start End same approach, option unrestricted for Start and opposite for End, left-hand driving
+        Given the profile file
+        """
+        local functions = require('testbot')
+        local testbot_process_way = functions.process_way
+        functions.process_way = function(profile, way, result)
+          testbot_process_way(profile, way, result)
+          result.is_left_hand_driving = true
+        end
+        return functions
+        """
+        And the node map
+            """
+               s        e
+            a------b------c
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches            | route    |
+            | s    | e  | unrestricted opposite | ab,bc,bc |
+
 
     #######################
     # Left-side countries #
@@ -260,9 +449,8 @@ Feature: Approach parameter
         """
         And the node map
             """
-               s
+               s       e
             a------b------c
-                       e
             """
 
         And the ways
@@ -271,10 +459,50 @@ Feature: Approach parameter
             | bc    |
 
         When I route I should get
-            | from | to | approaches        | route    |
-            | s    | e  | unrestricted curb | ab,bc,bc |
+            | from | to | approaches        | route |
+            | s    | e  | unrestricted curb | ab,bc |
 
-    Scenario: [Left-hand-side] Start End opposite approach, option unrestricted for Start and End
+    Scenario: [Left-hand-side] Start End same approach, option unrestricted for Start and opposite for End
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+        And the node map
+            """
+               s       e
+            a------b------c
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches             | route    |
+            | s    | e  | unrestricted opposite  | ab,bc,bc |
+
+    Scenario: [Left-hand-side] Start End same approach, option opposite for Start and curb for End
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+        And the node map
+            """
+               e      s
+            a------b------c
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches     | route    |
+            | s    | e  | opposite curb  | bc,ab,ab |
+
+    Scenario: [Left-hand-side] Start End different approach, option unrestricted for Start and End
         Given the profile file "car" initialized with
         """
         profile.properties.left_hand_driving = true
@@ -295,15 +523,16 @@ Feature: Approach parameter
             | from | to | approaches                | route |
             | s    | e  | unrestricted unrestricted | ab,bc |
 
-    Scenario: [Left-hand-side] Start End opposite approach, option unrestricted for Start and curb for End
+    Scenario: [Left-hand-side] Start End different approach, option unrestricted for Start and curb for End
         Given the profile file "car" initialized with
         """
         profile.properties.left_hand_driving = true
         """
         And the node map
             """
-               s      e
+               s
             a------b------c
+                      e
             """
 
         And the ways
@@ -312,5 +541,122 @@ Feature: Approach parameter
             | bc    |
 
         When I route I should get
-            | from | to | approaches        | route |
-            | s    | e  | unrestricted curb | ab,bc |
+            | from | to | approaches        | route    |
+            | s    | e  | unrestricted curb | ab,bc,bc |
+
+    Scenario: [Left-hand-side] Start End different approach, option unrestricted for Start and opposite for End
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+        And the node map
+            """
+               s
+            a------b------c
+                      e
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches            | route |
+            | s    | e  | unrestricted opposite | ab,bc |
+
+    Scenario: [Left-hand-side] Start End different approach, option curb for Start and opposite for End
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+        And the node map
+            """
+               s
+            a------b------c
+                      e
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches       | route |
+            | s    | e  | curb opposite    | ab,bc |
+
+
+
+    Scenario: Routes with more than two waypoints - uturns allowed
+        Given the profile "testbot"
+        And the node map
+            """
+               2                 1
+            a------b------c-----------d
+                   |
+               3   |             4
+            e------f------g-----------h
+            |
+            |
+            i
+
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | cd    |
+            | bf    |
+            | ef    |
+            | fg    |
+            | gh    |
+            | ei    |
+
+        And the query options
+            | continue_straight | false |
+
+        When I route I should get
+            | waypoints | approaches                                  | locations             | #                                                   |
+            | 1,2,3,4   | curb curb curb curb                         | _,_,_,a,b,f,_,_,i,h,_ | 1,2,2,a,b,f,3,3,i,h,4 (Only u-turn at end of roads) |
+            | 1,2,3,4   | curb unrestricted unrestricted curb         | _,_,_,b,f,_,_,h,_     | 1,2,2,b,f,3,3,h,4     (Can u-turn at 2 and 3)       |
+            | 1,2,3,4   | opposite opposite opposite opposite         | _,d,a,_,_,b,f,i,_,_,_ | 1,d,a,2,2,b,f,i,3,3,4 (Only u-turn at end of roads) |
+            | 1,2,3,4   | opposite unrestricted unrestricted opposite | _,d,_,_,b,f,_,_,_     | 1,d,2,2,b,f,3,3,4     (Can u-turn at 2 and 3)       |
+
+
+    Scenario: Routes with more than two waypoints - uturns forbidden
+        Given the profile "testbot"
+        And the node map
+            """
+               2                 1
+            a------b------c-----------d
+                   |
+               3   |             4
+            e------f------g-----------h
+            |
+            |
+            i
+
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | cd    |
+            | bf    |
+            | ef    |
+            | fg    |
+            | gh    |
+            | ei    |
+
+        And the query options
+            | continue_straight | true |
+
+        When I route I should get
+            | waypoints | approaches                                  |  locations            | #                                                   |
+            | 1,2,3,4   | curb curb curb curb                         | _,_,_,a,b,f,_,_,i,h,_ | 1,2,2,a,b,f,3,3,i,h,4 (Only u-turn at end of roads) |
+            | 1,2,3,4   | curb opposite opposite curb                 | _,a,_,_,b,f,i,_,_,h,_ | 1,a,2,2,b,f,i,3,3,h,4 (switches stops with u-turns) |
+            | 1,2,3,4   | opposite opposite opposite opposite         | _,d,a,_,_,b,f,i,_,_,_ | 1,d,a,2,2,b,f,i,3,3,4 (Only u-turn at end of roads) |
+            | 1,2,3,4   | opposite curb curb opposite                 | _,d,_,_,a,b,f,_,_,i,_ | 1,d,2,2,a,b,f,3,3,i,4 (switches stops with u-turns) |

features/testbot/force_step.feature

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

include/contractor/contract_excludable_graph.hpp

@@ -61,10 +61,12 @@ 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(), non_core_edges.end(), [&](const auto &edge) {
-                    return is_shared_core[edge.source] && is_shared_core[edge.target];
-                });
+            auto new_end = std::remove_if(non_core_edges.begin(),
+                                          non_core_edges.end(),
+                                          [&](const auto &edge) {
+                                              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));
 
@@ -75,8 +77,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) { return is_shared_core[node]; });
+        shared_core_graph = contractor_graph.Filter([&is_shared_core](const NodeID node)
+                                                    { return is_shared_core[node]; });
     }
 
     for (const auto &filter : filters)

include/contractor/contracted_edge_container.hpp

@@ -89,37 +89,40 @@ 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(), 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))
-                {
-                    return false;
-                }
+            std::remove_if(new_edges.begin(),
+                           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))
+                               {
+                                   return false;
+                               }
 
-                // find the first old edge that is equal or greater then the new edge
-                while (edge_iter != edge_end && mergeCompare(*edge_iter, edge))
-                {
-                    BOOST_ASSERT(flags_iter != flags.end());
-                    edge_iter++;
-                    flags_iter++;
-                }
+                               // find the first old edge that is equal or greater then the new edge
+                               while (edge_iter != edge_end && mergeCompare(*edge_iter, edge))
+                               {
+                                   BOOST_ASSERT(flags_iter != flags.end());
+                                   edge_iter++;
+                                   flags_iter++;
+                               }
 
-                // all new edges will be sorted after the old edges
-                if (edge_iter == edge_end)
-                {
-                    return false;
-                }
+                               // all new edges will be sorted after the old edges
+                               if (edge_iter == edge_end)
+                               {
+                                   return false;
+                               }
 
-                BOOST_ASSERT(edge_iter != edge_end);
-                if (mergable(edge, *edge_iter))
-                {
-                    *flags_iter = *flags_iter | flag;
-                    return true;
-                }
-                BOOST_ASSERT(mergeCompare(edge, *edge_iter));
-                return false;
-            });
+                               BOOST_ASSERT(edge_iter != edge_end);
+                               if (mergable(edge, *edge_iter))
+                               {
+                                   *flags_iter = *flags_iter | flag;
+                                   return true;
+                               }
+                               BOOST_ASSERT(mergeCompare(edge, *edge_iter));
+                               return false;
+                           });
 
         // append new edges
         edges.insert(edges.end(), new_edges.begin(), new_end);
@@ -132,10 +135,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(), ordering.end(), [&](const auto lhs_idx, const auto rhs_idx) {
-                return mergeCompare(edges[lhs_idx], edges[rhs_idx]);
-            });
+        tbb::parallel_sort(ordering.begin(),
+                           ordering.end(),
+                           [&](const auto lhs_idx, const auto rhs_idx)
+                           { return mergeCompare(edges[lhs_idx], edges[rhs_idx]); });
         auto permutation = util::orderingToPermutation(ordering);
 
         util::inplacePermutation(edges.begin(), edges.end(), permutation);

include/customizer/cell_customizer.hpp

@@ -122,7 +122,8 @@ 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/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,
-            waypoints.values.begin(),
-            [this](const PhantomNodeCandidates &candidates) { return MakeWaypoint(candidates); });
+        boost::range::transform(waypoint_candidates,
+                                waypoints.values.begin(),
+                                [this](const PhantomNodeCandidates &candidates)
+                                { return MakeWaypoint(candidates); });
         return waypoints;
     }
 
@@ -104,9 +104,8 @@ class BaseAPI
         std::transform(waypoint_candidates.begin(),
                        waypoint_candidates.end(),
                        waypoints.begin(),
-                       [this, builder](const PhantomNodeCandidates &candidates) {
-                           return MakeWaypoint(builder, candidates)->Finish();
-                       });
+                       [this, builder](const PhantomNodeCandidates &candidates)
+                       { return MakeWaypoint(builder, candidates)->Finish(); });
         return builder->CreateVector(waypoints);
     }
 

include/engine/api/base_parameters.hpp

@@ -52,7 +52,8 @@ namespace osrm::engine::api
  *              optional per coordinate
  *  - bearings: limits the search for segments in the road network to given bearing(s) in degree
  *              towards true north in clockwise direction, optional per coordinate
- *  - approaches: force the phantom node to start towards the node with the road country side.
+ *  - approaches: force the phantom node to start towards the node with the road country side or
+ *                its opposite
  *
  * \see OSRM, Coordinate, Hint, Bearing, RouteParameters, TableParameters,
  *      NearestParameters, TripParameters, MatchParameters and TileParameters
@@ -111,7 +112,8 @@ struct BaseParameters
                (approaches.empty() || approaches.size() == coordinates.size()) &&
                std::all_of(bearings.begin(),
                            bearings.end(),
-                           [](const boost::optional<Bearing> &bearing_and_range) {
+                           [](const boost::optional<Bearing> &bearing_and_range)
+                           {
                                if (bearing_and_range)
                                {
                                    return bearing_and_range->IsValid();

include/engine/api/match_api.hpp

@@ -52,9 +52,10 @@ class MatchAPI final : public RouteAPI
             data_version_string = fb_result.CreateString(data_timestamp);
         }
 
-        auto response = MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_matchings]() {
-            return MakeTracepoints(fb_result, sub_matchings);
-        });
+        auto response = MakeFBResponse(sub_routes,
+                                       fb_result,
+                                       [this, &fb_result, &sub_matchings]()
+                                       { return MakeTracepoints(fb_result, sub_matchings); });
 
         if (!data_timestamp.empty())
         {

include/engine/api/match_parameters.hpp

@@ -67,7 +67,7 @@ struct MatchParameters : public RouteParameters
     MatchParameters(const std::vector<unsigned> &timestamps_,
                     GapsType gaps_,
                     bool tidy_,
-                    Args &&... args_)
+                    Args &&...args_)
         : MatchParameters(timestamps_, gaps_, tidy_, {}, std::forward<Args>(args_)...)
     {
     }
@@ -77,7 +77,7 @@ struct MatchParameters : public RouteParameters
                     GapsType gaps_,
                     bool tidy_,
                     const std::vector<std::size_t> &waypoints_,
-                    Args &&... args_)
+                    Args &&...args_)
         : RouteParameters{std::forward<Args>(args_)..., waypoints_}, timestamps{std::move(
                                                                          timestamps_)},
           gaps(gaps_), tidy(tidy_)

include/engine/api/nearest_api.hpp

@@ -57,20 +57,20 @@ class NearestAPI final : public BaseAPI
         {
             std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
             waypoints.resize(phantom_nodes.front().size());
-            std::transform(
-                phantom_nodes.front().begin(),
-                phantom_nodes.front().end(),
-                waypoints.begin(),
-                [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance) {
-                    auto &phantom_node = phantom_with_distance.phantom_node;
+            std::transform(phantom_nodes.front().begin(),
+                           phantom_nodes.front().end(),
+                           waypoints.begin(),
+                           [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance)
+                           {
+                               auto &phantom_node = phantom_with_distance.phantom_node;
 
-                    auto node_values = MakeNodes(phantom_node);
-                    fbresult::Uint64Pair nodes{node_values.first, node_values.second};
+                               auto node_values = MakeNodes(phantom_node);
+                               fbresult::Uint64Pair nodes{node_values.first, node_values.second};
 
-                    auto waypoint = MakeWaypoint(&fb_result, {phantom_node});
-                    waypoint->add_nodes(&nodes);
-                    return waypoint->Finish();
-                });
+                               auto waypoint = MakeWaypoint(&fb_result, {phantom_node});
+                               waypoint->add_nodes(&nodes);
+                               return waypoint->Finish();
+                           });
 
             waypoints_vector = fb_result.CreateVector(waypoints);
         }
@@ -94,7 +94,8 @@ 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});
 

include/engine/api/route_api.hpp

@@ -77,9 +77,10 @@ class RouteAPI : public BaseAPI
         }
 
         auto response =
-            MakeFBResponse(raw_routes, fb_result, [this, &waypoint_candidates, &fb_result]() {
-                return BaseAPI::MakeWaypoints(&fb_result, waypoint_candidates);
-            });
+            MakeFBResponse(raw_routes,
+                           fb_result,
+                           [this, &waypoint_candidates, &fb_result]()
+                           { return BaseAPI::MakeWaypoints(&fb_result, waypoint_candidates); });
 
         if (!data_timestamp.empty())
         {
@@ -171,10 +172,15 @@ class RouteAPI : public BaseAPI
         }
         std::vector<fbresult::Position> coordinates;
         coordinates.resize(std::distance(begin, end));
-        std::transform(begin, end, coordinates.begin(), [](const Coordinate &c) {
-            return fbresult::Position{static_cast<float>(util::toFloating(c.lon).__value),
-                                      static_cast<float>(util::toFloating(c.lat).__value)};
-        });
+        std::transform(begin,
+                       end,
+                       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);
     }
 
@@ -354,9 +360,8 @@ class RouteAPI : public BaseAPI
                 std::transform(leg.steps.begin(),
                                leg.steps.end(),
                                legSteps.begin(),
-                               [this, &fb_result, &leg_geometry](auto &step) {
-                                   return this->MakeFBStep(fb_result, leg_geometry, step);
-                               });
+                               [this, &fb_result, &leg_geometry](auto &step)
+                               { return this->MakeFBStep(fb_result, leg_geometry, step); });
             }
             auto steps_vector = fb_result.CreateVector(legSteps);
 
@@ -441,7 +446,8 @@ class RouteAPI : public BaseAPI
             speed =
                 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;
@@ -459,37 +465,37 @@ class RouteAPI : public BaseAPI
         flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration;
         if (requested_annotations & RouteParameters::AnnotationsType::Duration)
         {
-            duration = GetAnnotations<uint32_t>(
-                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                    return anno.duration;
-                });
+            duration = GetAnnotations<uint32_t>(fb_result,
+                                                leg_geometry,
+                                                [](const guidance::LegGeometry::Annotation &anno)
+                                                { return anno.duration; });
         }
 
         flatbuffers::Offset<flatbuffers::Vector<uint32_t>> distance;
         if (requested_annotations & RouteParameters::AnnotationsType::Distance)
         {
-            distance = GetAnnotations<uint32_t>(
-                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                    return anno.distance;
-                });
+            distance = GetAnnotations<uint32_t>(fb_result,
+                                                leg_geometry,
+                                                [](const guidance::LegGeometry::Annotation &anno)
+                                                { return anno.distance; });
         }
 
         flatbuffers::Offset<flatbuffers::Vector<uint32_t>> weight;
         if (requested_annotations & RouteParameters::AnnotationsType::Weight)
         {
-            weight = GetAnnotations<uint32_t>(
-                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                    return anno.weight;
-                });
+            weight = GetAnnotations<uint32_t>(fb_result,
+                                              leg_geometry,
+                                              [](const guidance::LegGeometry::Annotation &anno)
+                                              { return anno.weight; });
         }
 
         flatbuffers::Offset<flatbuffers::Vector<uint32_t>> datasources;
         if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
         {
-            datasources = GetAnnotations<uint32_t>(
-                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                    return anno.datasource;
-                });
+            datasources = GetAnnotations<uint32_t>(fb_result,
+                                                   leg_geometry,
+                                                   [](const guidance::LegGeometry::Annotation &anno)
+                                                   { return anno.datasource; });
         }
         std::vector<uint32_t> nodes;
         if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
@@ -653,7 +659,8 @@ 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))
                 {
@@ -681,11 +688,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(),
-                    intersection.classes.end(),
-                    classes.begin(),
-                    [&fb_result](const std::string &cls) { return fb_result.CreateString(cls); });
+                std::transform(intersection.classes.begin(),
+                               intersection.classes.end(),
+                               classes.begin(),
+                               [&fb_result](const std::string &cls)
+                               { return fb_result.CreateString(cls); });
                 auto classes_vector = fb_result.CreateVector(classes);
                 auto entry_vector = fb_result.CreateVector(intersection.entry);
 
@@ -720,9 +727,10 @@ class RouteAPI : public BaseAPI
 
         std::vector<util::json::Value> step_geometries;
         const auto total_step_count =
-            std::accumulate(legs.begin(), legs.end(), 0, [](const auto &v, const auto &leg) {
-                return v + leg.steps.size();
-            });
+            std::accumulate(legs.begin(),
+                            legs.end(),
+                            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()))
@@ -733,7 +741,8 @@ 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>(
@@ -778,7 +787,9 @@ class RouteAPI : public BaseAPI
                 {
                     double prev_speed = 0;
                     annotation.values["speed"] = GetAnnotations(
-                        leg_geometry, [&prev_speed](const guidance::LegGeometry::Annotation &anno) {
+                        leg_geometry,
+                        [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                        {
                             if (anno.duration < std::numeric_limits<double>::min())
                             {
                                 return prev_speed;
@@ -794,17 +805,17 @@ class RouteAPI : public BaseAPI
 
                 if (requested_annotations & RouteParameters::AnnotationsType::Duration)
                 {
-                    annotation.values["duration"] = GetAnnotations(
-                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                            return anno.duration;
-                        });
+                    annotation.values["duration"] =
+                        GetAnnotations(leg_geometry,
+                                       [](const guidance::LegGeometry::Annotation &anno)
+                                       { return anno.duration; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Distance)
                 {
-                    annotation.values["distance"] = GetAnnotations(
-                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                            return anno.distance;
-                        });
+                    annotation.values["distance"] =
+                        GetAnnotations(leg_geometry,
+                                       [](const guidance::LegGeometry::Annotation &anno)
+                                       { return anno.distance; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Weight)
                 {
@@ -814,10 +825,10 @@ class RouteAPI : public BaseAPI
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
                 {
-                    annotation.values["datasources"] = GetAnnotations(
-                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                            return anno.datasource;
-                        });
+                    annotation.values["datasources"] =
+                        GetAnnotations(leg_geometry,
+                                       [](const guidance::LegGeometry::Annotation &anno)
+                                       { return anno.datasource; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
                 {

include/engine/api/route_parameters.hpp

@@ -83,7 +83,7 @@ struct RouteParameters : public BaseParameters
                     const GeometriesType geometries_,
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
-                    Args &&... args_)
+                    Args &&...args_)
         // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one
         // below.
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
@@ -101,7 +101,7 @@ struct RouteParameters : public BaseParameters
                     const GeometriesType geometries_,
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
-                    Args &&... args_)
+                    Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
           annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
@@ -119,7 +119,7 @@ struct RouteParameters : public BaseParameters
                     const GeometriesType geometries_,
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
-                    Args &&... args_)
+                    Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u},
           annotations{annotations_ != AnnotationsType::None}, annotations_type{annotations_},
@@ -137,7 +137,7 @@ struct RouteParameters : public BaseParameters
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
-                    const Args &&... args_)
+                    const Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
           annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
@@ -155,7 +155,7 @@ struct RouteParameters : public BaseParameters
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
-                    Args &&... args_)
+                    Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_ !=
                                                                        AnnotationsType::None},
@@ -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(), waypoints.end(), [this](const auto &w) {
-                return w < coordinates.size();
-            });
+            std::all_of(waypoints.begin(),
+                        waypoints.end(),
+                        [this](const auto &w) { return w < coordinates.size(); });
         return coordinates_ok && base_params_ok && valid_waypoints;
     }
 };

include/engine/api/table_api.hpp

@@ -245,9 +245,8 @@ class TableAPI final : public BaseAPI
 
         boost::range::transform(candidates,
                                 std::back_inserter(waypoints),
-                                [this, &builder](const PhantomNodeCandidates &candidates) {
-                                    return BaseAPI::MakeWaypoint(&builder, candidates)->Finish();
-                                });
+                                [this, &builder](const PhantomNodeCandidates &candidates)
+                                { return BaseAPI::MakeWaypoint(&builder, candidates)->Finish(); });
         return builder.CreateVector(waypoints);
     }
 
@@ -261,7 +260,8 @@ 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();
             });
@@ -274,14 +274,17 @@ class TableAPI final : public BaseAPI
     {
         std::vector<float> distance_table;
         distance_table.resize(values.size());
-        std::transform(
-            values.begin(), values.end(), distance_table.begin(), [](const EdgeDuration duration) {
-                if (duration == MAXIMAL_EDGE_DURATION)
-                {
-                    return 0.;
-                }
-                return from_alias<double>(duration) / 10.;
-            });
+        std::transform(values.begin(),
+                       values.end(),
+                       distance_table.begin(),
+                       [](const EdgeDuration duration)
+                       {
+                           if (duration == MAXIMAL_EDGE_DURATION)
+                           {
+                               return 0.;
+                           }
+                           return from_alias<double>(duration) / 10.;
+                       });
         return builder.CreateVector(distance_table);
     }
 
@@ -291,14 +294,17 @@ class TableAPI final : public BaseAPI
     {
         std::vector<float> duration_table;
         duration_table.resize(values.size());
-        std::transform(
-            values.begin(), values.end(), duration_table.begin(), [](const EdgeDistance distance) {
-                if (distance == INVALID_EDGE_DISTANCE)
-                {
-                    return 0.;
-                }
-                return std::round(from_alias<double>(distance) * 10) / 10.;
-            });
+        std::transform(values.begin(),
+                       values.end(),
+                       duration_table.begin(),
+                       [](const EdgeDistance distance)
+                       {
+                           if (distance == INVALID_EDGE_DISTANCE)
+                           {
+                               return 0.;
+                           }
+                           return std::round(from_alias<double>(distance) * 10) / 10.;
+                       });
         return builder.CreateVector(duration_table);
     }
 
@@ -308,11 +314,13 @@ 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(), fallback_speed_cells.end(), [&](const auto &cell) {
-                fb_table.push_back(cell.row);
-                fb_table.push_back(cell.column);
-            });
+        std::for_each(fallback_speed_cells.begin(),
+                      fallback_speed_cells.end(),
+                      [&](const auto &cell)
+                      {
+                          fb_table.push_back(cell.row);
+                          fb_table.push_back(cell.column);
+                      });
         return builder.CreateVector(fb_table);
     }
 
@@ -325,9 +333,8 @@ class TableAPI final : public BaseAPI
 
         boost::range::transform(candidates,
                                 std::back_inserter(json_waypoints.values),
-                                [this](const PhantomNodeCandidates &candidates) {
-                                    return BaseAPI::MakeWaypoint(candidates);
-                                });
+                                [this](const PhantomNodeCandidates &candidates)
+                                { return BaseAPI::MakeWaypoint(candidates); });
         return json_waypoints;
     }
 
@@ -338,7 +345,8 @@ 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]);
                                 });
@@ -359,7 +367,8 @@ 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());
@@ -387,7 +396,8 @@ 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());
@@ -405,13 +415,15 @@ class TableAPI final : public BaseAPI
     MakeEstimatesTable(const std::vector<TableCellRef> &fallback_speed_cells) const
     {
         util::json::Array json_table;
-        std::for_each(
-            fallback_speed_cells.begin(), fallback_speed_cells.end(), [&](const auto &cell) {
-                util::json::Array row;
-                row.values.push_back(util::json::Number(cell.row));
-                row.values.push_back(util::json::Number(cell.column));
-                json_table.values.push_back(std::move(row));
-            });
+        std::for_each(fallback_speed_cells.begin(),
+                      fallback_speed_cells.end(),
+                      [&](const auto &cell)
+                      {
+                          util::json::Array row;
+                          row.values.push_back(util::json::Number(cell.row));
+                          row.values.push_back(util::json::Number(cell.column));
+                          json_table.values.push_back(std::move(row));
+                      });
         return json_table;
     }
 

include/engine/api/table_parameters.hpp

@@ -81,7 +81,7 @@ struct TableParameters : public BaseParameters
     template <typename... Args>
     TableParameters(std::vector<std::size_t> sources_,
                     std::vector<std::size_t> destinations_,
-                    Args &&... args_)
+                    Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
           destinations{std::move(destinations_)}
     {
@@ -91,7 +91,7 @@ struct TableParameters : public BaseParameters
     TableParameters(std::vector<std::size_t> sources_,
                     std::vector<std::size_t> destinations_,
                     const AnnotationsType annotations_,
-                    Args &&... args_)
+                    Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
           destinations{std::move(destinations_)}, annotations{annotations_}
     {
@@ -104,7 +104,7 @@ struct TableParameters : public BaseParameters
                     double fallback_speed_,
                     FallbackCoordinateType fallback_coordinate_type_,
                     double scale_factor_,
-                    Args &&... args_)
+                    Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
           destinations{std::move(destinations_)}, fallback_speed{fallback_speed_},
           fallback_coordinate_type{fallback_coordinate_type_}, annotations{annotations_},

include/engine/api/trip_api.hpp

@@ -50,10 +50,10 @@ class TripAPI final : public RouteAPI
             data_version_string = fb_result.CreateString(data_timestamp);
         }
 
-        auto response =
-            MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_trips, &candidates]() {
-                return MakeWaypoints(fb_result, sub_trips, candidates);
-            });
+        auto response = MakeFBResponse(sub_routes,
+                                       fb_result,
+                                       [this, &fb_result, &sub_trips, &candidates]()
+                                       { return MakeWaypoints(fb_result, sub_trips, candidates); });
 
         if (!data_timestamp.empty())
         {

include/engine/api/trip_parameters.hpp

@@ -60,7 +60,7 @@ struct TripParameters : public RouteParameters
     TripParameters(SourceType source_,
                    DestinationType destination_,
                    bool roundtrip_,
-                   Args &&... args_)
+                   Args &&...args_)
         : RouteParameters{std::forward<Args>(args_)...}, source{source_},
           destination{destination_}, roundtrip{roundtrip_}
     {

include/engine/approach.hpp

@@ -36,7 +36,8 @@ namespace osrm::engine
 enum class Approach : std::uint8_t
 {
     CURB = 0,
-    UNRESTRICTED = 1
+    UNRESTRICTED = 1,
+    OPPOSITE = 2
 
 };
 } // namespace osrm::engine

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -375,7 +375,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         BOOST_ASSERT(m_geospatial_query.get());
 
         return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, boost::none, max_distance, bearing, use_all_edges);
+            input_coordinate, approach, max_distance, bearing, use_all_edges);
     }
 
     std::vector<PhantomNodeWithDistance>
@@ -440,9 +440,11 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto indexes = extractor::getClassIndexes(class_data);
         std::vector<std::string> classes(indexes.size());
-        std::transform(indexes.begin(), indexes.end(), classes.begin(), [this](const auto index) {
-            return m_profile_properties->GetClassName(index);
-        });
+        std::transform(indexes.begin(),
+                       indexes.end(),
+                       classes.begin(),
+                       [this](const auto index)
+                       { return m_profile_properties->GetClassName(index); });
 
         return classes;
     }
@@ -600,15 +602,19 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         auto found_range = std::equal_range(
             m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});
 
-        std::for_each(found_range.first, found_range.second, [&](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,
-                                                          override.direction});
-        });
+        std::for_each(found_range.first,
+                      found_range.second,
+                      [&](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,
+                                                                        override.direction});
+                      });
         return results;
     }
 };

include/engine/geospatial_query.hpp

@@ -12,6 +12,8 @@
 
 #include "osrm/coordinate.hpp"
 
+#include <boost/optional.hpp>
+
 #include <algorithm>
 #include <cmath>
 #include <iterator>
@@ -47,12 +49,42 @@ 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 boost::optional<Bearing> bearing_with_range,
+                        const boost::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 boost::optional<size_t> max_results,
+                        const size_t max_results,
                         const boost::optional<double> max_distance,
                         const boost::optional<Bearing> bearing_with_range,
                         const boost::optional<bool> use_all_edges) const
@@ -60,7 +92,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         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)
@@ -69,9 +102,10 @@ 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,
-                                                                  const CandidateSegment &segment) {
-                return (max_results && num_results >= *max_results) ||
+            [this, &max_distance, max_results, input_coordinate](const std::size_t num_results,
+                                                                 const CandidateSegment &segment)
+            {
+                return (num_results >= max_results) ||
                        (max_distance && max_distance != -1.0 &&
                         CheckSegmentDistance(input_coordinate, segment, *max_distance));
             });
@@ -107,7 +141,8 @@ 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;
@@ -159,7 +194,8 @@ 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;
@@ -190,13 +226,17 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         PhantomNodeCandidates nearest_phantoms;
         PhantomNodeCandidates big_component_phantoms;
 
-        const auto add_to_candidates = [this, &input_coordinate](PhantomNodeCandidates &candidates,
-                                                                 const EdgeData data) {
+        const auto add_to_candidates =
+            [this, &input_coordinate](PhantomNodeCandidates &candidates, const EdgeData data)
+        {
             auto candidate_it =
-                std::find_if(candidates.begin(), 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;
-                });
+                std::find_if(candidates.begin(),
+                             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;
+                             });
             if (candidate_it == candidates.end())
             {
                 // First candidate from this segment
@@ -259,17 +299,20 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             }
         };
 
-        std::for_each(results.begin(), results.end(), [&](const CandidateSegment &segment) {
-            if (segment.fixed_projected_coordinate == nearest_coord)
-            {
-                add_to_candidates(nearest_phantoms, segment.data);
-            }
-            else
-            {
-                // Can only be from a big component for the alternative candidates
-                add_to_candidates(big_component_phantoms, segment.data);
-            }
-        });
+        std::for_each(results.begin(),
+                      results.end(),
+                      [&](const CandidateSegment &segment)
+                      {
+                          if (segment.fixed_projected_coordinate == nearest_coord)
+                          {
+                              add_to_candidates(nearest_phantoms, segment.data);
+                          }
+                          else
+                          {
+                              // Can only be from a big component for the alternative candidates
+                              add_to_candidates(big_component_phantoms, segment.data);
+                          }
+                      });
         return std::make_pair(std::move(nearest_phantoms), std::move(big_component_phantoms));
     }
 
@@ -281,9 +324,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         std::transform(results.begin(),
                        results.end(),
                        distance_and_phantoms.begin(),
-                       [this, &input_coordinate](const CandidateSegment &segment) {
-                           return MakePhantomNode(input_coordinate, segment.data);
-                       });
+                       [this, &input_coordinate](const CandidateSegment &segment)
+                       { return MakePhantomNode(input_coordinate, segment.data); });
         return distance_and_phantoms;
     }
 
@@ -400,9 +442,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         }
 
         // check phantom node segments validity
-        auto areSegmentsValid = [](auto first, auto last) -> bool {
-            return std::find(first, last, INVALID_SEGMENT_WEIGHT) == last;
-        };
+        auto areSegmentsValid = [](auto first, auto last) -> bool
+        { 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(
@@ -558,7 +599,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     {
         bool isOnewaySegment =
             !(segment.data.forward_segment_id.enabled && segment.data.reverse_segment_id.enabled);
-        if (!isOnewaySegment && approach == Approach::CURB)
+        if (!isOnewaySegment && (approach == Approach::CURB || approach == Approach::OPPOSITE))
         {
             // Check the counter clockwise
             //
@@ -573,6 +614,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             if (datafacade.IsLeftHandDriving(segment.data.forward_segment_id.id))
                 input_coordinate_is_at_right = !input_coordinate_is_at_right;
 
+            if (approach == Approach::OPPOSITE)
+                input_coordinate_is_at_right = !input_coordinate_is_at_right;
+
             return std::make_pair(input_coordinate_is_at_right, (!input_coordinate_is_at_right));
         }
         return std::make_pair(true, true);

include/engine/guidance/assemble_leg.hpp

@@ -43,7 +43,8 @@ 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();
 
@@ -75,7 +76,8 @@ 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)};
@@ -87,33 +89,37 @@ 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(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
-            return lhs.name_id < rhs.name_id ||
-                   (lhs.name_id == rhs.name_id && lhs.position < rhs.position);
-        });
+    std::sort(segments.begin(),
+              segments.end(),
+              [](const NamedSegment &lhs, const NamedSegment &rhs)
+              {
+                  return lhs.name_id < rhs.name_id ||
+                         (lhs.name_id == rhs.name_id && lhs.position < rhs.position);
+              });
     auto new_end = collapse_segments(segments);
     segments.resize(new_end - segments.begin());
 
     // Filter out segments with an empty name (name_id == 0)
-    new_end = std::remove_if(segments.begin(), segments.end(), [](const NamedSegment &segment) {
-        return segment.name_id == 0;
-    });
+    new_end = std::remove_if(segments.begin(),
+                             segments.end(),
+                             [](const NamedSegment &segment) { return segment.name_id == 0; });
     segments.resize(new_end - segments.begin());
 
     // sort descending
-    std::sort(
-        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
-            return lhs.duration > rhs.duration ||
-                   (lhs.duration == rhs.duration && lhs.position < rhs.position);
-        });
+    std::sort(segments.begin(),
+              segments.end(),
+              [](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(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
-            return lhs.position < rhs.position;
-        });
+    std::sort(segments.begin(),
+              segments.end(),
+              [](const NamedSegment &lhs, const NamedSegment &rhs)
+              { return lhs.position < rhs.position; });
 
     std::array<std::uint32_t, SegmentNumber> summary;
     std::fill(summary.begin(), summary.end(), EMPTY_NAMEID);
@@ -138,7 +144,8 @@ 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);
@@ -178,14 +185,16 @@ 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(), route_data.end(), 0, [](const double sum, const PathData &data) {
-            return sum + from_alias<double>(data.duration_until_turn);
-        });
-    auto weight = std::accumulate(
-        route_data.begin(), route_data.end(), 0, [](const double sum, const PathData &data) {
-            return sum + from_alias<double>(data.weight_until_turn);
-        });
+    auto duration = std::accumulate(route_data.begin(),
+                                    route_data.end(),
+                                    0,
+                                    [](const double sum, const PathData &data)
+                                    { return sum + from_alias<double>(data.duration_until_turn); });
+    auto weight = std::accumulate(route_data.begin(),
+                                  route_data.end(),
+                                  0,
+                                  [](const double sum, const PathData &data)
+                                  { return sum + from_alias<double>(data.weight_until_turn); });
 
     //                 s
     //                 |

include/engine/guidance/collapse_scenario_detection.hpp

@@ -16,7 +16,7 @@ bool basicCollapsePreconditions(const RouteStepIterator first,
 
 // Staggered intersection are very short zig-zags of a few meters.
 // We do not want to announce these short left-rights or right-lefts:
-// 
+//  
 //      * -> b      a -> *
 //      |       or       |       becomes  a   ->   b
 // a -> *                * -> b
@@ -26,7 +26,7 @@ bool isStaggeredIntersection(const RouteStepIterator step_prior_to_intersection,
 
 // Two two turns following close after another, we can announce them as a U-Turn if both end up
 // involving the same (segregated) road.
-// 
+//  
 // b < - y
 //       |      will be represented by at x, turn around instead of turn left at x, turn left at y
 // a - > x
@@ -42,11 +42,11 @@ bool isNameOszillation(const RouteStepIterator step_prior_to_intersection,
 
 // Sometimes, segments names don't match the perceived turns. We try to detect these additional
 // name changes and issue a combined turn.
-// 
+//  
 //  |  e  |
 // a - b - c
 //         d
-// 
+//  
 // can have `a-b` as one name, `b-c-d` as a second. At `b` we would issue a new name, even though
 // the road turns right after. The offset would only be there due to the broad road at `e`
 bool maneuverPreceededByNameChange(const RouteStepIterator step_prior_to_intersection,
@@ -73,11 +73,11 @@ bool doubleChoiceless(const RouteStepIterator step_entering_intersection,
 
 // Due to obvious detection, sometimes we can have straight turns followed by a different turn right
 // next to each other. We combine both turns into one, if the second turn is without choice
-// 
-//         e
+//  
+//          e
 // a - b - c
 //       ' d
-// 
+//  
 // with a main road `abd`, the turn `continue straight` at `b` and `turn left at `c` will become a
 // `turn left` at `b`
 bool straightTurnFollowedByChoiceless(const RouteStepIterator step_entering_intersection,

include/engine/guidance/collapsing_utility.hpp

@@ -122,9 +122,8 @@ 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) {
-        return !step.name.empty() || !step.ref.empty();
-    };
+    const auto has_name_or_ref = [](auto const &step)
+    { return !step.name.empty() || !step.ref.empty(); };
 
     // make sure empty is not involved
     if (!has_name_or_ref(lhs) || !has_name_or_ref(rhs))
@@ -151,12 +150,14 @@ 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);
     };
@@ -174,7 +175,8 @@ inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> st
     // 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;
     };
@@ -225,7 +227,8 @@ 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/postprocessing_toolkit.hpp

@@ -20,14 +20,16 @@ template <typename Iter, typename Fn> inline Fn forEachRoundabout(Iter first, It
 {
     while (first != last)
     {
-        const auto enter = std::find_if(first, last, [](const RouteStep &step) {
-            return entersRoundabout(step.maneuver.instruction);
-        });
+        const auto enter = std::find_if(first,
+                                        last,
+                                        [](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, last, [](const RouteStep &step) {
-            return leavesRoundabout(step.maneuver.instruction);
-        });
+        const auto leave = std::find_if(enter,
+                                        last,
+                                        [](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/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(), candidates.end(), [component_id](const PhantomNode &node) {
-            return node.component.id == component_id;
-        });
+    return std::any_of(candidates.begin(),
+                       candidates.end(),
+                       [component_id](const PhantomNode &node)
+                       { return node.component.id == component_id; });
 }
 
 struct PhantomEndpoints

include/engine/plugins/plugin_base.hpp

@@ -33,10 +33,10 @@ class BasePlugin
 
     bool CheckAllCoordinates(const std::vector<util::Coordinate> &coordinates) const
     {
-        return !std::any_of(
-            std::begin(coordinates), std::end(coordinates), [](const util::Coordinate coordinate) {
-                return !coordinate.IsValid();
-            });
+        return !std::any_of(std::begin(coordinates),
+                            std::end(coordinates),
+                            [](const util::Coordinate coordinate)
+                            { return !coordinate.IsValid(); });
     }
 
     bool CheckAlgorithms(const api::BaseParameters &params,
@@ -105,45 +105,45 @@ class BasePlugin
     {
         // are all phantoms from a tiny cc?
         const auto all_in_same_tiny_component =
-            [](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) {
-                        if (!phantom.component.is_tiny)
-                        {
-                            return false;
-                        }
-                        const auto component_id = phantom.component.id;
-                        return std::all_of(
-                            std::next(alts_list.begin()),
-                            std::end(alts_list),
-                            [component_id](const PhantomCandidateAlternatives &alternatives) {
-                                return candidatesHaveComponent(alternatives.first, component_id);
-                            });
-                    });
-            };
+            [](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)
+                {
+                    if (!phantom.component.is_tiny)
+                    {
+                        return false;
+                    }
+                    const auto component_id = phantom.component.id;
+                    return std::all_of(
+                        std::next(alts_list.begin()),
+                        std::end(alts_list),
+                        [component_id](const PhantomCandidateAlternatives &alternatives)
+                        { 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) {
-            return std::move(alternatives.first);
-        };
+        const auto use_closed_phantom = [](PhantomCandidateAlternatives &alternatives)
+        { return std::move(alternatives.first); };
 
         const auto no_alternatives =
             std::all_of(alternatives_list.begin(),
                         alternatives_list.end(),
-                        [](const PhantomCandidateAlternatives &alternatives) {
-                            return alternatives.second.empty();
-                        });
+                        [](const PhantomCandidateAlternatives &alternatives)
+                        { return alternatives.second.empty(); });
 
         std::vector<PhantomNodeCandidates> snapped_phantoms;
         snapped_phantoms.reserve(alternatives_list.size());
@@ -313,12 +313,12 @@ 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) {
-                                                     return phantom.input_location == coordinate;
-                                                 });
+                                                 [&](const auto &phantom)
+                                                 { 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 ") +

include/engine/polyline_compressor.hpp

@@ -39,7 +39,8 @@ std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter
         begin,
         end,
         [&delta_numbers, &current_lat, &current_lon, coordinate_to_polyline](
-            const util::Coordinate loc) {
+            const util::Coordinate loc)
+        {
             const int lat_diff =
                 std::round(static_cast<int>(loc.lat) * coordinate_to_polyline) - current_lat;
             const int lon_diff =

include/engine/routing_algorithms/routing_base.hpp

@@ -71,24 +71,27 @@ 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 loop forcing
+// Identify nodes in the forward(reverse) search direction that will require step forcing
 // e.g. if source and destination nodes are on the same segment.
-std::vector<NodeID> getForwardLoopNodes(const PhantomEndpointCandidates &candidates);
-std::vector<NodeID> getForwardLoopNodes(const PhantomCandidatesToTarget &candidates);
-std::vector<NodeID> getBackwardLoopNodes(const PhantomEndpointCandidates &candidates);
-std::vector<NodeID> getBackwardLoopNodes(const PhantomCandidatesToTarget &candidates);
+std::vector<NodeID> getForwardForceNodes(const PhantomEndpointCandidates &candidates);
+std::vector<NodeID> getForwardForceNodes(const PhantomCandidatesToTarget &candidates);
+std::vector<NodeID> getBackwardForceNodes(const PhantomEndpointCandidates &candidates);
+std::vector<NodeID> getBackwardForceNodes(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 force_loop(const std::vector<NodeID> &force_nodes, const HeapNodeT &heap_node)
+inline bool shouldForceStep(const std::vector<NodeID> &force_nodes,
+                            const HeapNodeT &forward_heap_node,
+                            const HeapNodeT &reverse_heap_node)
 {
-    // if loops are forced, they are so at the source
-    return !force_nodes.empty() &&
-           std::find(force_nodes.begin(), force_nodes.end(), heap_node.node) != force_nodes.end() &&
-           heap_node.data.parent == heap_node.node;
+    // routing steps are forced when the node is a source of both forward and reverse search heaps.
+    return forward_heap_node.data.parent == forward_heap_node.node &&
+           reverse_heap_node.data.parent == reverse_heap_node.node &&
+           std::find(force_nodes.begin(), force_nodes.end(), forward_heap_node.node) !=
+               force_nodes.end();
 }
 
 template <typename Heap>
@@ -190,8 +193,10 @@ 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 copy = [](auto &vector, const auto range) {
+    const auto get_segment_geometry = [&](const auto geometry_index)
+    {
+        const auto copy = [](auto &vector, const auto range)
+        {
             vector.resize(range.size());
             std::copy(range.begin(), range.end(), vector.begin());
         };

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -112,8 +112,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
                  NodeID &middle_node_id,
                  EdgeWeight &upper_bound,
                  EdgeWeight min_edge_offset,
-                 const std::vector<NodeID> &force_loop_forward_nodes,
-                 const std::vector<NodeID> &force_loop_reverse_nodes)
+                 const std::vector<NodeID> &force_step_nodes)
 {
     auto heapNode = forward_heap.DeleteMinGetHeapNode();
     const auto reverseHeapNode = reverse_heap.GetHeapNodeIfWasInserted(heapNode.node);
@@ -123,13 +122,13 @@ void routingStep(const DataFacade<Algorithm> &facade,
         const EdgeWeight new_weight = reverseHeapNode->weight + heapNode.weight;
         if (new_weight < upper_bound)
         {
-            if (force_loop(force_loop_forward_nodes, heapNode) ||
-                force_loop(force_loop_reverse_nodes, heapNode) ||
+            if (shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) ||
                 // 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})
             {
-                // check whether there is a loop present at the node
+                // Before forcing step, 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);
@@ -294,9 +293,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), std::get<1>(edge), [](const auto &data) {
-                    return data.forward;
-                });
+                facade.FindSmallestEdge(std::get<0>(edge),
+                                        std::get<1>(edge),
+                                        [](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,
@@ -381,7 +380,8 @@ 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,23 +420,22 @@ 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 loop first.
-// A forced loop might be necessary, if source and target are on the same segment.
+// In case additional offsets are supplied, you might have to force a routing step first.
+// A forced step 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 loop is required (e.g. source_phantom.forward_segment_id ==
+// then a force step is required (e.g. source_phantom.forward_segment_id ==
 // target_phantom.forward_segment_id
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
-// a force loop, if the heaps have been initialized with positive offsets.
+// a force step, 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_loop_forward_node,
-            const std::vector<NodeID> &force_loop_reverse_node,
+            const std::vector<NodeID> &force_step_nodes,
             const EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT);
 
 template <typename PhantomEndpointT>
@@ -446,8 +445,7 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             EdgeWeight &weight,
             std::vector<NodeID> &packed_leg,
-            const std::vector<NodeID> &force_loop_forward_node,
-            const std::vector<NodeID> &force_loop_reverse_node,
+            const std::vector<NodeID> &force_step_nodes,
             const PhantomEndpointT & /*endpoints*/,
             const EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT)
 {
@@ -458,14 +456,13 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
                   reverse_heap,
                   weight,
                   packed_leg,
-                  force_loop_forward_node,
-                  force_loop_reverse_node,
+                  force_step_nodes,
                   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_loop parameters might be required
+// the addition of force_step 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

@@ -30,7 +30,8 @@ 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;
@@ -59,7 +60,8 @@ 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));
@@ -76,7 +78,8 @@ 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(),
@@ -119,7 +122,8 @@ 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;
     };
@@ -128,7 +132,8 @@ 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));
@@ -151,9 +156,11 @@ 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.end(), init, [&](LevelID level, size_t index) {
-            return std::min(level, getNodeQueryLevel(partition, node, candidates_list[index]));
-        });
+        phantom_indices.begin(),
+        phantom_indices.end(),
+        init,
+        [&](LevelID level, size_t index)
+        { return std::min(level, getNodeQueryLevel(partition, node, candidates_list[index])); });
     return result;
 }
 } // namespace
@@ -266,7 +273,7 @@ template <bool DIRECTION, typename Algorithm, typename... Args>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                         typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                         const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
-                        const Args &... args)
+                        const Args &...args)
 {
     const auto &partition = facade.GetMultiLevelPartition();
     const auto &cells = facade.GetCellStorage();
@@ -382,9 +389,8 @@ void routingStep(const DataFacade<Algorithm> &facade,
                  typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                  NodeID &middle_node,
                  EdgeWeight &path_upper_bound,
-                 const std::vector<NodeID> &force_loop_forward_nodes,
-                 const std::vector<NodeID> &force_loop_reverse_nodes,
-                 const Args &... args)
+                 const std::vector<NodeID> &force_step_nodes,
+                 const Args &...args)
 {
     const auto heapNode = forward_heap.DeleteMinGetHeapNode();
     const auto weight = heapNode.weight;
@@ -402,11 +408,8 @@ void routingStep(const DataFacade<Algorithm> &facade,
         auto reverse_weight = reverseHeapNode->weight;
         auto path_weight = weight + reverse_weight;
 
-        // MLD uses loops forcing only to prune single node paths in forward and/or
-        // 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))
+        if (!shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) &&
+            (path_weight >= EdgeWeight{0}) && (path_weight < path_upper_bound))
         {
             middle_node = heapNode.node;
             path_upper_bound = path_weight;
@@ -431,10 +434,9 @@ 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_loop_forward_nodes,
-                    const std::vector<NodeID> &force_loop_reverse_nodes,
+                    const std::vector<NodeID> &force_step_nodes,
                     EdgeWeight weight_upper_bound,
-                    const Args &... args)
+                    const Args &...args)
 {
     if (forward_heap.Empty() || reverse_heap.Empty())
     {
@@ -456,27 +458,15 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
     {
         if (!forward_heap.Empty())
         {
-            routingStep<FORWARD_DIRECTION>(facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           middle,
-                                           weight,
-                                           force_loop_forward_nodes,
-                                           force_loop_reverse_nodes,
-                                           args...);
+            routingStep<FORWARD_DIRECTION>(
+                facade, forward_heap, reverse_heap, middle, weight, force_step_nodes, args...);
             if (!forward_heap.Empty())
                 forward_heap_min = forward_heap.MinKey();
         }
         if (!reverse_heap.Empty())
         {
-            routingStep<REVERSE_DIRECTION>(facade,
-                                           reverse_heap,
-                                           forward_heap,
-                                           middle,
-                                           weight,
-                                           force_loop_reverse_nodes,
-                                           force_loop_forward_nodes,
-                                           args...);
+            routingStep<REVERSE_DIRECTION>(
+                facade, reverse_heap, forward_heap, middle, weight, force_step_nodes, args...);
             if (!reverse_heap.Empty())
                 reverse_heap_min = reverse_heap.MinKey();
         }
@@ -505,9 +495,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
 
     for (auto const &packed_edge : packed_path)
     {
-        NodeID source, target;
-        bool overlay_edge;
-        std::tie(source, target, overlay_edge) = packed_edge;
+        auto [source, target, overlay_edge] = packed_edge;
         if (!overlay_edge)
         { // a base graph edge
             unpacked_nodes.push_back(target);
@@ -527,21 +515,14 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
             forward_heap.Insert(source, {0}, {source});
             reverse_heap.Insert(target, {0}, {target});
 
-            // 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_loop_forward_nodes,
-                       force_loop_reverse_nodes,
-                       INVALID_EDGE_WEIGHT,
-                       sublevel,
-                       parent_cell_id);
+            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
+                                                                         facade,
+                                                                         forward_heap,
+                                                                         reverse_heap,
+                                                                         force_step_nodes,
+                                                                         INVALID_EDGE_WEIGHT,
+                                                                         sublevel,
+                                                                         parent_cell_id);
             BOOST_ASSERT(!subpath_edges.empty());
             BOOST_ASSERT(subpath_nodes.size() > 1);
             BOOST_ASSERT(subpath_nodes.front() == source);
@@ -563,8 +544,7 @@ 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_loop_forward_node,
-                   const std::vector<NodeID> &force_loop_reverse_node,
+                   const std::vector<NodeID> &force_step_nodes,
                    const PhantomEndpointT &endpoints,
                    const EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
@@ -573,8 +553,7 @@ inline void search(SearchEngineData<Algorithm> &engine_working_data,
                                                            facade,
                                                            forward_heap,
                                                            reverse_heap,
-                                                           force_loop_forward_node,
-                                                           force_loop_reverse_node,
+                                                           force_step_nodes,
                                                            weight_upper_bound,
                                                            endpoints);
 }
@@ -601,7 +580,8 @@ 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));
             });
@@ -625,28 +605,46 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
     const PhantomEndpoints endpoints{source_phantom, target_phantom};
     insertNodesInHeaps(forward_heap, reverse_heap, endpoints);
 
-    EdgeWeight weight = INVALID_EDGE_WEIGHT;
-    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);
+    auto [weight, unpacked_nodes, unpacked_edges] = search(
+        engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);
 
     if (weight == INVALID_EDGE_WEIGHT)
     {
         return std::numeric_limits<double>::max();
     }
 
-    std::vector<PathData> unpacked_path;
+    BOOST_ASSERT(unpacked_nodes.size() >= 1);
 
-    annotatePath(facade, endpoints, unpacked_nodes, unpacked_edges, unpacked_path);
+    EdgeDistance distance = {0.0};
 
-    return getPathDistance(facade, unpacked_path, source_phantom, target_phantom);
+    if (source_phantom.forward_segment_id.id == unpacked_nodes.front())
+    {
+        BOOST_ASSERT(source_phantom.forward_segment_id.enabled);
+        distance = EdgeDistance{0} - source_phantom.GetForwardDistance();
+    }
+    else if (source_phantom.reverse_segment_id.id == unpacked_nodes.front())
+    {
+        BOOST_ASSERT(source_phantom.reverse_segment_id.enabled);
+        distance = EdgeDistance{0} - source_phantom.GetReverseDistance();
+    }
+
+    for (size_t index = 0; index < unpacked_nodes.size() - 1; ++index)
+    {
+        distance += facade.GetNodeDistance(unpacked_nodes[index]);
+    }
+
+    if (target_phantom.forward_segment_id.id == unpacked_nodes.back())
+    {
+        BOOST_ASSERT(target_phantom.forward_segment_id.enabled);
+        distance += target_phantom.GetForwardDistance();
+    }
+    else if (target_phantom.reverse_segment_id.id == unpacked_nodes.back())
+    {
+        BOOST_ASSERT(target_phantom.reverse_segment_id.enabled);
+        distance += target_phantom.GetReverseDistance();
+    }
+
+    return from_alias<double>(distance);
 }
 
 } // namespace osrm::engine::routing_algorithms::mld

include/engine/routing_algorithms/shortest_path_impl.hpp

@@ -19,8 +19,7 @@ void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
                      typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                      typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                      const PhantomEndpointCandidates &candidates,
-                     const EdgeWeight &total_weight,
-                     EdgeWeight &new_total_weight,
+                     EdgeWeight &leg_weight,
                      std::vector<NodeID> &leg_packed_path)
 {
     forward_heap.Clear();
@@ -31,14 +30,14 @@ void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
         if (source.IsValidForwardSource())
         {
             forward_heap.Insert(source.forward_segment_id.id,
-                                total_weight - source.GetForwardWeightPlusOffset(),
+                                EdgeWeight{0} - source.GetForwardWeightPlusOffset(),
                                 source.forward_segment_id.id);
         }
 
         if (source.IsValidReverseSource())
         {
             forward_heap.Insert(source.reverse_segment_id.id,
-                                total_weight - source.GetReverseWeightPlusOffset(),
+                                EdgeWeight{0} - source.GetReverseWeightPlusOffset(),
                                 source.reverse_segment_id.id);
         }
     }
@@ -62,10 +61,9 @@ void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
            facade,
            forward_heap,
            reverse_heap,
-           new_total_weight,
+           leg_weight,
            leg_packed_path,
-           getForwardLoopNodes(candidates),
-           getBackwardLoopNodes(candidates),
+           {},
            candidates);
 }
 
@@ -125,8 +123,7 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
                reverse_heap,
                new_total_weight_to_forward,
                leg_packed_path_forward,
-               getForwardLoopNodes(candidates),
-               {},
+               getForwardForceNodes(candidates),
                candidates);
     }
 
@@ -165,8 +162,7 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
                reverse_heap,
                new_total_weight_to_reverse,
                leg_packed_path_reverse,
-               {},
-               getBackwardLoopNodes(candidates),
+               getBackwardForceNodes(candidates),
                candidates);
     }
 }
@@ -248,7 +244,8 @@ 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);
                          });
@@ -257,7 +254,8 @@ 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);
                          });
@@ -302,7 +300,7 @@ shortestPathWithWaypointUTurns(SearchEngineData<Algorithm> &engine_working_data,
         PhantomEndpointCandidates search_candidates{waypoint_candidates[i],
                                                     waypoint_candidates[i + 1]};
         std::vector<NodeID> packed_leg;
-        EdgeWeight new_total_weight = INVALID_EDGE_WEIGHT;
+        EdgeWeight leg_weight = INVALID_EDGE_WEIGHT;
 
         // We have a valid path up to this leg
         BOOST_ASSERT(total_weight != INVALID_EDGE_WEIGHT);
@@ -311,16 +309,15 @@ shortestPathWithWaypointUTurns(SearchEngineData<Algorithm> &engine_working_data,
                         forward_heap,
                         reverse_heap,
                         search_candidates,
-                        total_weight,
-                        new_total_weight,
+                        leg_weight,
                         packed_leg);
 
-        if (new_total_weight == INVALID_EDGE_WEIGHT)
+        if (leg_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 = new_total_weight;
+        total_weight += leg_weight;
     };
 
     // Add sentinel
@@ -466,16 +463,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(),
-            init_candidates.end(),
-            std::back_inserter(last.reached_forward_node_target),
-            [](const PhantomNode &phantom_node) { return phantom_node.IsValidForwardSource(); });
-        std::transform(
-            init_candidates.begin(),
-            init_candidates.end(),
-            std::back_inserter(last.reached_reverse_node_target),
-            [](const PhantomNode &phantom_node) { return phantom_node.IsValidReverseSource(); });
+        std::transform(init_candidates.begin(),
+                       init_candidates.end(),
+                       std::back_inserter(last.reached_forward_node_target),
+                       [](const PhantomNode &phantom_node)
+                       { return phantom_node.IsValidForwardSource(); });
+        std::transform(init_candidates.begin(),
+                       init_candidates.end(),
+                       std::back_inserter(last.reached_reverse_node_target),
+                       [](const PhantomNode &phantom_node)
+                       { return phantom_node.IsValidReverseSource(); });
     }
 
     bool completeLeg()
@@ -613,15 +610,21 @@ 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(forward_range.begin(), forward_range.end(), [&](size_t a, size_t b) {
+        auto forward_min = std::min_element(
+            forward_range.begin(),
+            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(reverse_range.begin(), reverse_range.end(), [&](size_t a, size_t b) {
+        auto reverse_min = std::min_element(
+            reverse_range.begin(),
+            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]));

include/extractor/class_data.hpp

@@ -27,9 +27,9 @@ inline auto getClassData(const std::size_t index)
 
 inline bool isValidClassName(const std::string &name)
 {
-    return std::find_if_not(name.begin(), name.end(), [](const auto c) {
-               return std::isalnum(c);
-           }) == name.end();
+    return std::find_if_not(name.begin(),
+                            name.end(),
+                            [](const auto c) { return std::isalnum(c); }) == name.end();
 }
 } // namespace osrm::extractor
 

include/extractor/extraction_helper_functions.hpp

@@ -125,9 +125,8 @@ inline std::string canonicalizeStringList(std::string strlist, const std::string
 
     // collapse spaces; this is needed in case we expand "; X" => ";  X" above
     // but also makes sense to do irregardless of the fact - canonicalizing strings.
-    const auto spaces = [](unsigned char lhs, unsigned char rhs) {
-        return ::isspace(lhs) && ::isspace(rhs);
-    };
+    const auto spaces = [](unsigned char lhs, unsigned char rhs)
+    { return ::isspace(lhs) && ::isspace(rhs); };
     auto it = std::unique(begin(strlist), end(strlist), spaces);
     strlist.erase(it, end(strlist));
 

include/extractor/extraction_relation.hpp

@@ -133,7 +133,8 @@ class ExtractionRelationContainer
             (void)res; // prevent unused warning in release
         }
 
-        auto MergeRefMap = [&](RelationRefMap &source, RelationRefMap &target) {
+        auto MergeRefMap = [&](RelationRefMap &source, RelationRefMap &target)
+        {
             for (auto it : source)
             {
                 auto &v = target[it.first];
@@ -151,7 +152,8 @@ class ExtractionRelationContainer
     const RelationIDList &GetRelations(const OsmIDTyped &member_id) const
     {
         auto getFromMap = [this](std::uint64_t id,
-                                 const RelationRefMap &map) -> const RelationIDList & {
+                                 const RelationRefMap &map) -> const RelationIDList &
+        {
             auto it = map.find(id);
             if (it != map.end())
                 return it->second;

include/extractor/extraction_segment.hpp

@@ -1,6 +1,7 @@
 #ifndef OSRM_EXTRACTION_SEGMENT_HPP
 #define OSRM_EXTRACTION_SEGMENT_HPP
 
+#include <extractor/node_based_edge.hpp>
 #include <util/coordinate.hpp>
 
 namespace osrm::extractor
@@ -12,9 +13,10 @@ struct ExtractionSegment
                       const osrm::util::Coordinate target_,
                       double distance_,
                       double weight_,
-                      double duration_)
+                      double duration_,
+                      const NodeBasedEdgeClassification flags_)
         : source(source_), target(target_), distance(distance_), weight(weight_),
-          duration(duration_)
+          duration(duration_), flags(flags_)
     {
     }
 
@@ -23,6 +25,7 @@ struct ExtractionSegment
     const double distance;
     double weight;
     double duration;
+    const NodeBasedEdgeClassification flags;
 };
 } // namespace osrm::extractor
 

include/extractor/files.hpp

@@ -453,7 +453,8 @@ void readRawNBGraph(const boost::filesystem::path &path,
     coordinates.resize(number_of_nodes);
     osm_node_ids.reserve(number_of_nodes);
     auto index = 0;
-    auto decode = [&](const auto &current_node) {
+    auto decode = [&](const auto &current_node)
+    {
         coordinates[index].lon = current_node.lon;
         coordinates[index].lat = current_node.lat;
         osm_node_ids.push_back(current_node.node_id);

include/extractor/graph_compressor.hpp

@@ -24,7 +24,7 @@ class GraphCompressor
 
   public:
     void Compress(const std::unordered_set<NodeID> &barrier_nodes,
-                  const TrafficSignals &traffic_signals,
+                  TrafficSignals &traffic_signals,
                   ScriptingEnvironment &scripting_environment,
                   std::vector<TurnRestriction> &turn_restrictions,
                   std::vector<UnresolvedManeuverOverride> &maneuver_overrides,

include/extractor/intersection/intersection_view.hpp

@@ -26,16 +26,14 @@ namespace osrm::extractor::intersection
 
 inline auto makeCompareAngularDeviation(const double angle)
 {
-    return [angle](const auto &lhs, const auto &rhs) {
-        return util::angularDeviation(lhs.angle, angle) < util::angularDeviation(rhs.angle, angle);
-    };
+    return [angle](const auto &lhs, const auto &rhs)
+    { return util::angularDeviation(lhs.angle, angle) < util::angularDeviation(rhs.angle, angle); };
 }
 
 inline auto makeExtractLanesForRoad(const util::NodeBasedDynamicGraph &node_based_graph)
 {
-    return [&node_based_graph](const auto &road) {
-        return node_based_graph.GetEdgeData(road.eid).road_classification.GetNumberOfLanes();
-    };
+    return [&node_based_graph](const auto &road)
+    { return node_based_graph.GetEdgeData(road.eid).road_classification.GetNumberOfLanes(); };
 }
 
 // When viewing an intersection from an incoming edge, we can transform a shape into a view which
@@ -63,7 +61,10 @@ template <typename Self> struct EnableShapeOps
     auto FindClosestBearing(double base_bearing) const
     {
         return std::min_element(
-            self()->begin(), self()->end(), [base_bearing](const auto &lhs, const auto &rhs) {
+            self()->begin(),
+            self()->end(),
+            [base_bearing](const auto &lhs, const auto &rhs)
+            {
                 return util::angularDeviation(lhs.perceived_bearing, base_bearing) <
                        util::angularDeviation(rhs.perceived_bearing, base_bearing);
             });
@@ -81,7 +82,8 @@ template <typename Self> struct EnableShapeOps
         BOOST_ASSERT(!self()->empty());
         auto initial = converter(self()->front());
 
-        const auto extract_maximal_value = [&initial, converter](const auto &road) {
+        const auto extract_maximal_value = [&initial, converter](const auto &road)
+        {
             initial = std::max(initial, converter(road));
             return false;
         };
@@ -191,8 +193,10 @@ template <typename Self> struct EnableIntersectionOps
     auto findClosestTurn(const double angle, const UnaryPredicate filter) const
     {
         BOOST_ASSERT(!self()->empty());
-        const auto candidate =
-            boost::range::min_element(*self(), [angle, &filter](const auto &lhs, const auto &rhs) {
+        const auto candidate = boost::range::min_element(
+            *self(),
+            [angle, &filter](const auto &lhs, const auto &rhs)
+            {
                 const auto filtered_lhs = filter(lhs), filtered_rhs = filter(rhs);
                 const auto deviation_lhs = util::angularDeviation(lhs.angle, angle),
                            deviation_rhs = util::angularDeviation(rhs.angle, angle);

include/extractor/intersection/node_based_graph_walker.hpp

@@ -11,8 +11,8 @@
 #include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
 #include <cstdint>
+#include <optional>
 #include <utility>
 
 namespace osrm::extractor::intersection
@@ -42,10 +42,10 @@ class NodeBasedGraphWalker
      * selector not provinding any further edge to traverse)
      */
     template <class accumulator_type, class selector_type>
-    boost::optional<std::pair<NodeID, EdgeID>> TraverseRoad(NodeID starting_at_node_id,
-                                                            EdgeID following_edge_id,
-                                                            accumulator_type &accumulator,
-                                                            const selector_type &selector) const;
+    std::optional<std::pair<NodeID, EdgeID>> TraverseRoad(NodeID starting_at_node_id,
+                                                          EdgeID following_edge_id,
+                                                          accumulator_type &accumulator,
+                                                          const selector_type &selector) const;
 
   private:
     const util::NodeBasedDynamicGraph &node_based_graph;
@@ -111,11 +111,11 @@ struct SelectRoadByNameOnlyChoiceAndStraightness
      * traversal. If no such edge is found, return {} is allowed. Usually you want to choose some
      * form of obious turn to follow.
      */
-    boost::optional<EdgeID> operator()(const NodeID nid,
-                                       const EdgeID via_edge_id,
-                                       const IntersectionView &intersection,
-                                       const util::NodeBasedDynamicGraph &node_based_graph,
-                                       const EdgeBasedNodeDataContainer &node_data_container) const;
+    std::optional<EdgeID> operator()(const NodeID nid,
+                                     const EdgeID via_edge_id,
+                                     const IntersectionView &intersection,
+                                     const util::NodeBasedDynamicGraph &node_based_graph,
+                                     const EdgeBasedNodeDataContainer &node_data_container) const;
 
   private:
     const NameID desired_name_id;
@@ -138,11 +138,11 @@ struct SelectStraightmostRoadByNameAndOnlyChoice
      * traversal. If no such edge is found, return {} is allowed. Usually you want to choose some
      * form of obious turn to follow.
      */
-    boost::optional<EdgeID> operator()(const NodeID nid,
-                                       const EdgeID via_edge_id,
-                                       const IntersectionView &intersection,
-                                       const util::NodeBasedDynamicGraph &node_based_graph,
-                                       const EdgeBasedNodeDataContainer &node_data_container) const;
+    std::optional<EdgeID> operator()(const NodeID nid,
+                                     const EdgeID via_edge_id,
+                                     const IntersectionView &intersection,
+                                     const util::NodeBasedDynamicGraph &node_based_graph,
+                                     const EdgeBasedNodeDataContainer &node_data_container) const;
 
   private:
     const NameID desired_name_id;
@@ -187,7 +187,7 @@ struct IntersectionFinderAccumulator
 };
 
 template <class accumulator_type, class selector_type>
-boost::optional<std::pair<NodeID, EdgeID>>
+std::optional<std::pair<NodeID, EdgeID>>
 NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
                                    EdgeID current_edge_id,
                                    accumulator_type &accumulator,
@@ -254,19 +254,19 @@ NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
 
 struct SkipTrafficSignalBarrierRoadSelector
 {
-    boost::optional<EdgeID> operator()(const NodeID,
-                                       const EdgeID,
-                                       const IntersectionView &intersection,
-                                       const util::NodeBasedDynamicGraph &,
-                                       const EdgeBasedNodeDataContainer &) const
+    std::optional<EdgeID> operator()(const NodeID,
+                                     const EdgeID,
+                                     const IntersectionView &intersection,
+                                     const util::NodeBasedDynamicGraph &,
+                                     const EdgeBasedNodeDataContainer &) const
     {
         if (intersection.isTrafficSignalOrBarrier())
         {
-            return boost::make_optional(intersection[1].eid);
+            return std::make_optional(intersection[1].eid);
         }
         else
         {
-            return boost::none;
+            return std::nullopt;
         }
     }
 };

include/extractor/maneuver_override_relation_parser.hpp

@@ -3,7 +3,7 @@
 
 #include "maneuver_override.hpp"
 
-#include <boost/optional.hpp>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -55,7 +55,7 @@ class ManeuverOverrideRelationParser
 {
   public:
     ManeuverOverrideRelationParser();
-    boost::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
+    std::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
 };
 } // namespace osrm::extractor
 

include/extractor/node_based_graph_factory.hpp

@@ -39,7 +39,7 @@ class NodeBasedGraphFactory
     NodeBasedGraphFactory(ScriptingEnvironment &scripting_environment,
                           std::vector<TurnRestriction> &turn_restrictions,
                           std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
-                          const TrafficSignals &traffic_signals,
+                          TrafficSignals &traffic_signals,
                           std::unordered_set<NodeID> &&barriers,
                           std::vector<util::Coordinate> &&coordinates,
                           extractor::PackedOSMIDs &&osm_node_ids,
@@ -71,7 +71,7 @@ class NodeBasedGraphFactory
     void Compress(ScriptingEnvironment &scripting_environment,
                   std::vector<TurnRestriction> &turn_restrictions,
                   std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
-                  const TrafficSignals &traffic_signals);
+                  TrafficSignals &traffic_signals);
 
     // Most ways are bidirectional, making the geometry in forward and backward direction the same,
     // except for reversal. We make use of this fact by keeping only one representation of the

include/extractor/node_restriction_map.hpp

@@ -32,9 +32,8 @@ template <typename RestrictionFilter> class NodeRestrictionMap
     // Find all restrictions applicable to (from,via,to) turns
     auto Restrictions(NodeID from, NodeID via, NodeID to) const
     {
-        const auto turnFilter = [this, to](const auto &restriction) {
-            return index_filter(restriction) && restriction->IsTurnRestricted(to);
-        };
+        const auto turnFilter = [this, to](const auto &restriction)
+        { return index_filter(restriction) && restriction->IsTurnRestricted(to); };
         return getRange(from, via) | boost::adaptors::filtered(turnFilter);
     };
 

include/extractor/profile_properties.hpp

@@ -7,11 +7,11 @@
 
 #include <boost/assert.hpp>
 #include <boost/numeric/conversion/cast.hpp>
-#include <boost/optional.hpp>
 
 #include <algorithm>
 #include <array>
 #include <cstdint>
+#include <optional>
 
 namespace osrm::extractor
 {
@@ -80,7 +80,7 @@ struct ProfileProperties
     }
 
     // Check if this classes are excludable
-    boost::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
+    std::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
     {
         auto iter = std::find(excludable_classes.begin(), excludable_classes.end(), classes);
         if (iter != excludable_classes.end())

include/extractor/traffic_signals.hpp

@@ -19,6 +19,21 @@ struct TrafficSignals
     {
         return bidirectional_nodes.count(to) > 0 || unidirectional_segments.count({from, to}) > 0;
     }
+
+    void Compress(NodeID from, NodeID via, NodeID to)
+    {
+        bidirectional_nodes.erase(via);
+        if (unidirectional_segments.count({via, to}))
+        {
+            unidirectional_segments.erase({via, to});
+            unidirectional_segments.insert({from, to});
+        }
+        if (unidirectional_segments.count({via, from}))
+        {
+            unidirectional_segments.erase({via, from});
+            unidirectional_segments.insert({to, from});
+        }
+    }
 };
 } // namespace osrm::extractor
 

include/guidance/intersection_handler.hpp

@@ -15,11 +15,10 @@
 
 #include <algorithm>
 #include <cstddef>
+#include <optional>
 #include <utility>
 #include <vector>
 
-#include <boost/optional.hpp>
-
 namespace osrm::guidance
 {
 
@@ -129,7 +128,7 @@ class IntersectionHandler
     //     ^ via
     //
     // For this scenario returns intersection at `b` and `b`.
-    boost::optional<IntersectionHandler::IntersectionViewAndNode>
+    std::optional<IntersectionHandler::IntersectionViewAndNode>
     getNextIntersection(const NodeID at, const EdgeID via) const;
 
     bool isSameName(const EdgeID source_edge_id, const EdgeID target_edge_id) const;
@@ -187,11 +186,11 @@ IntersectionHandler::IsDistinctNarrowTurn(const EdgeID via_edge,
         node_data_container.GetAnnotation(candidate_data.annotation_data);
     auto const candidate_deviation = util::angularDeviation(candidate->angle, STRAIGHT_ANGLE);
 
-    auto const num_lanes = [](auto const &data) {
-        return data.flags.road_classification.GetNumberOfLanes();
-    };
+    auto const num_lanes = [](auto const &data)
+    { return data.flags.road_classification.GetNumberOfLanes(); };
 
-    auto const lanes_number_equal = [&](auto const &compare_data) {
+    auto const lanes_number_equal = [&](auto const &compare_data)
+    {
         // Check if the lanes number is the same going from the inbound edge to the compare road
         return num_lanes(compare_data) > 0 && num_lanes(compare_data) == num_lanes(via_edge_data);
     };
@@ -210,7 +209,8 @@ IntersectionHandler::IsDistinctNarrowTurn(const EdgeID via_edge,
 
     // check if there are other narrow turns are not considered passing a low category or simply
     // a link of the same type as the potentially obvious turn
-    auto const is_similar_turn = [&](auto const &road) {
+    auto const is_similar_turn = [&](auto const &road)
+    {
         // 1. Skip the candidate road
         if (road.eid == candidate->eid)
         {
@@ -405,7 +405,8 @@ IntersectionHandler::IsDistinctWideTurn(const EdgeID via_edge,
     // Deviation is larger than NARROW_TURN_ANGLE0 here for the candidate
     // check if there is any turn, that might look just as obvious, even though it might not
     // be allowed. Entry-allowed isn't considered a valid distinction criterion here
-    auto const is_similar_turn = [&](auto const &road) {
+    auto const is_similar_turn = [&](auto const &road)
+    {
         // 1. Skip over our candidate
         if (road.eid == candidate->eid)
             return false;
@@ -503,7 +504,8 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
         node_data_container.GetAnnotation(via_edge_data.annotation_data);
 
     // implement a filter, taking out all roads of lower class or different names
-    auto const continues_on_name_with_higher_class = [&](auto const &road) {
+    auto const continues_on_name_with_higher_class = [&](auto const &road)
+    {
         // it needs to be possible to enter the road
         if (!road.entry_allowed)
             return true;
@@ -550,7 +552,8 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
 
     // this check is not part of the main conditions, so that if the turn looks obvious from all
     // other perspectives, a mode change will not result in different classification
-    auto const to_index_if_valid = [&](auto const iterator) -> std::size_t {
+    auto const to_index_if_valid = [&](auto const iterator) -> std::size_t
+    {
         auto const &from_data = node_based_graph.GetEdgeData(via_edge);
         auto const &to_data = node_based_graph.GetEdgeData(iterator->eid);
 
@@ -577,7 +580,8 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
 
     // opposed to before, we do not care about name changes, again: this is a filter, so internal
     // false/true will be negated for selection
-    auto const valid_of_higher_or_same_category = [&](auto const &road) {
+    auto const valid_of_higher_or_same_category = [&](auto const &road)
+    {
         if (!road.entry_allowed)
             return true;
 
@@ -640,7 +644,8 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
     const auto all_roads_have_same_name =
         std::all_of(intersection.begin(),
                     intersection.end(),
-                    [id = via_edge_annotation.name_id, this](auto const &road) {
+                    [id = via_edge_annotation.name_id, this](auto const &road)
+                    {
                         auto const data_id = node_based_graph.GetEdgeData(road.eid).annotation_data;
                         auto const name_id = node_data_container.GetAnnotation(data_id).name_id;
                         return (name_id != EMPTY_NAMEID) && (name_id == id);

include/guidance/parsing_toolkit.hpp

@@ -71,7 +71,7 @@ trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t co
 OSRM_ATTR_WARN_UNUSED
 inline std::string applyAccessTokens(std::string lane_string, const std::string &access_tokens)
 {
-    typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
+    using tokenizer = boost::tokenizer<boost::char_separator<char>>;
     boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
     tokenizer tokens(lane_string, sep);
     tokenizer access(access_tokens, sep);

include/guidance/sliproad_handler.hpp

@@ -9,10 +9,9 @@
 
 #include "util/node_based_graph.hpp"
 
+#include <optional>
 #include <vector>
 
-#include <boost/optional.hpp>
-
 namespace osrm::guidance
 {
 
@@ -43,9 +42,9 @@ class SliproadHandler final : public IntersectionHandler
                             Intersection intersection) const override final;
 
   private:
-    boost::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
-                                                              const Intersection &intersection,
-                                                              const NodeID at) const;
+    std::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
+                                                            const Intersection &intersection,
+                                                            const NodeID at) const;
 
     // Next intersection from `start` onto `onto` is too far away for a Siproad scenario
     bool nextIntersectionIsTooFarAway(const NodeID start, const EdgeID onto) const;

include/guidance/turn_handler.hpp

@@ -11,9 +11,8 @@
 #include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"
 
-#include <boost/optional.hpp>
-
 #include <cstddef>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -72,7 +71,7 @@ class TurnHandler final : public IntersectionHandler
 
     bool hasObvious(const EdgeID &via_edge, const Fork &fork) const;
 
-    boost::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
+    std::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
 
     bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;
 
@@ -96,7 +95,7 @@ class TurnHandler final : public IntersectionHandler
     handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const;
 
     // Classification
-    boost::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
+    std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
 
     OSRM_ATTR_WARN_UNUSED
     Intersection assignLeftTurns(const EdgeID via_edge,

include/guidance/turn_instruction.hpp

@@ -1,13 +1,14 @@
 #ifndef OSRM_GUIDANCE_TURN_INSTRUCTION_HPP_
 #define OSRM_GUIDANCE_TURN_INSTRUCTION_HPP_
 
-#include <algorithm>
-#include <cstdint>
-
 #include "guidance/roundabout_type.hpp"
 #include "util/attributes.hpp"
 #include "util/typedefs.hpp"
 
+#include <algorithm>
+#include <array>
+#include <cstdint>
+
 namespace osrm::guidance
 {
 
@@ -154,24 +155,23 @@ inline bool operator==(const TurnInstruction lhs, const TurnInstruction rhs)
 inline bool hasRoundaboutType(const TurnInstruction instruction)
 {
     using namespace guidance::TurnType;
-    const constexpr TurnType::Enum valid_types[] = {TurnType::EnterRoundabout,
-                                                    TurnType::EnterAndExitRoundabout,
-                                                    TurnType::EnterRotary,
-                                                    TurnType::EnterAndExitRotary,
-                                                    TurnType::EnterRoundaboutIntersection,
-                                                    TurnType::EnterAndExitRoundaboutIntersection,
-                                                    TurnType::EnterRoundaboutAtExit,
-                                                    TurnType::ExitRoundabout,
-                                                    TurnType::EnterRotaryAtExit,
-                                                    TurnType::ExitRotary,
-                                                    TurnType::EnterRoundaboutIntersectionAtExit,
-                                                    TurnType::ExitRoundaboutIntersection,
-                                                    TurnType::StayOnRoundabout};
+    const constexpr std::array<TurnType::Enum, 13> valid_types = {
+        TurnType::EnterRoundabout,
+        TurnType::EnterAndExitRoundabout,
+        TurnType::EnterRotary,
+        TurnType::EnterAndExitRotary,
+        TurnType::EnterRoundaboutIntersection,
+        TurnType::EnterAndExitRoundaboutIntersection,
+        TurnType::EnterRoundaboutAtExit,
+        TurnType::ExitRoundabout,
+        TurnType::EnterRotaryAtExit,
+        TurnType::ExitRotary,
+        TurnType::EnterRoundaboutIntersectionAtExit,
+        TurnType::ExitRoundaboutIntersection,
+        TurnType::StayOnRoundabout};
 
-    const auto *first = valid_types;
-    const auto *last = first + sizeof(valid_types) / sizeof(valid_types[0]);
-
-    return std::find(first, last, instruction.type) != last;
+    return std::find(valid_types.cbegin(), valid_types.cend(), instruction.type) !=
+           valid_types.cend();
 }
 
 inline bool entersRoundabout(const guidance::TurnInstruction instruction)

include/nodejs/node_osrm_support.hpp

@@ -560,6 +560,10 @@ inline bool argumentsToParameter(const Napi::CallbackInfo &args,
                 {
                     params->approaches.push_back(osrm::Approach::CURB);
                 }
+                else if (approach_str == "opposite")
+                {
+                    params->approaches.push_back(osrm::Approach::OPPOSITE);
+                }
                 else if (approach_str == "unrestricted")
                 {
                     params->approaches.push_back(osrm::Approach::UNRESTRICTED);
@@ -567,13 +571,14 @@ inline bool argumentsToParameter(const Napi::CallbackInfo &args,
                 else
                 {
                     ThrowError(args.Env(),
-                               "'approaches' param must be one of [curb, unrestricted]");
+                               "'approaches' param must be one of [curb, opposite, unrestricted]");
                     return false;
                 }
             }
             else
             {
-                ThrowError(args.Env(), "Approach must be a string: [curb, unrestricted] or null");
+                ThrowError(args.Env(),
+                           "Approach must be a string: [curb, opposite, unrestricted] or null");
                 return false;
             }
         }

include/partitioner/bisection_graph.hpp

@@ -65,8 +65,8 @@ inline BisectionGraph makeBisectionGraph(const std::vector<util::Coordinate> &co
     result_edges.reserve(edges.size());
 
     // find the end of edges that belong to node_id
-    const auto advance_edge_itr = [&edges, &result_edges](const std::size_t node_id,
-                                                          auto edge_itr) {
+    const auto advance_edge_itr = [&edges, &result_edges](const std::size_t node_id, auto edge_itr)
+    {
         while (edge_itr != edges.end() && edge_itr->source == node_id)
         {
             result_edges.push_back(edge_itr->Reduce());
@@ -76,9 +76,9 @@ inline BisectionGraph makeBisectionGraph(const std::vector<util::Coordinate> &co
     };
 
     // create a bisection node, requires the ID of the node as well as the lower bound to its edges
-    const auto make_bisection_node = [&edges, &coordinates](const std::size_t node_id,
-                                                            const auto begin_itr,
-                                                            const auto end_itr) {
+    const auto make_bisection_node =
+        [&edges, &coordinates](const std::size_t node_id, const auto begin_itr, const auto end_itr)
+    {
         std::size_t range_begin = std::distance(edges.begin(), begin_itr);
         std::size_t range_end = std::distance(edges.begin(), end_itr);
         return BisectionGraph::NodeT(range_begin, range_end, coordinates[node_id], node_id);
@@ -102,9 +102,12 @@ std::vector<BisectionInputEdge> adaptToBisectionEdge(std::vector<InputEdge> edge
     std::vector<BisectionInputEdge> result;
     result.reserve(edges.size());
 
-    std::transform(begin(edges), end(edges), std::back_inserter(result), [](const auto &edge) {
-        return BisectionInputEdge{edge.source, edge.target};
-    });
+    std::transform(begin(edges),
+                   end(edges),
+                   std::back_inserter(result),
+                   [](const auto &edge) {
+                       return BisectionInputEdge{edge.source, edge.target};
+                   });
 
     return result;
 }

include/partitioner/cell_storage.hpp

@@ -298,7 +298,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
                                                                    auto set_num_nodes_fn,
                                                                    auto set_boundary_offset_fn,
                                                                    auto begin,
-                                                                   auto end) {
+                                                                   auto end)
+            {
                 BOOST_ASSERT(std::distance(begin, end) > 0);
 
                 const auto cell_id = begin->first;
@@ -316,7 +317,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
             util::for_each_range(
                 level_source_boundary.begin(),
                 level_source_boundary.end(),
-                [this, insert_cell_boundary](auto begin, auto end) {
+                [this, insert_cell_boundary](auto begin, auto end)
+                {
                     insert_cell_boundary(
                         source_boundary,
                         [](auto &cell, auto value) { cell.num_source_nodes = value; },
@@ -327,7 +329,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
             util::for_each_range(
                 level_destination_boundary.begin(),
                 level_destination_boundary.end(),
-                [this, insert_cell_boundary](auto begin, auto end) {
+                [this, insert_cell_boundary](auto begin, auto end)
+                {
                     insert_cell_boundary(
                         destination_boundary,
                         [](auto &cell, auto value) { cell.num_destination_nodes = value; },

include/partitioner/edge_based_graph_reader.hpp

@@ -64,10 +64,13 @@ std::vector<OutputEdgeT> prepareEdgesForUsageInGraph(std::vector<extractor::Edge
     // sort into blocks of edges with same source + target
     // the we partition by the forward flag to sort all edges with a forward direction first.
     // the we sort by weight to ensure the first forward edge is the smallest forward edge
-    std::sort(begin(edges), end(edges), [](const auto &lhs, const auto &rhs) {
-        return std::tie(lhs.source, lhs.target, rhs.data.forward, lhs.data.weight) <
-               std::tie(rhs.source, rhs.target, lhs.data.forward, rhs.data.weight);
-    });
+    std::sort(begin(edges),
+              end(edges),
+              [](const auto &lhs, const auto &rhs)
+              {
+                  return std::tie(lhs.source, lhs.target, rhs.data.forward, lhs.data.weight) <
+                         std::tie(rhs.source, rhs.target, lhs.data.forward, rhs.data.weight);
+              });
 
     std::vector<OutputEdgeT> output_edges;
     output_edges.reserve(edges.size());
@@ -77,10 +80,11 @@ std::vector<OutputEdgeT> prepareEdgesForUsageInGraph(std::vector<extractor::Edge
         const NodeID source = begin_interval->source;
         const NodeID target = begin_interval->target;
 
-        auto end_interval =
-            std::find_if_not(begin_interval, edges.end(), [source, target](const auto &edge) {
-                return std::tie(edge.source, edge.target) == std::tie(source, target);
-            });
+        auto end_interval = std::find_if_not(
+            begin_interval,
+            edges.end(),
+            [source, target](const auto &edge)
+            { return std::tie(edge.source, edge.target) == std::tie(source, target); });
         BOOST_ASSERT(begin_interval != end_interval);
 
         // remove eigenloops
@@ -144,7 +148,8 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
     auto max_turn_id = tbb::parallel_reduce(
         range,
         NodeID{0},
-        [&edge_based_graph](const auto range, NodeID initial) {
+        [&edge_based_graph](const auto range, NodeID initial)
+        {
             NodeID max_turn_id = initial;
             for (auto node = range.begin(); node < range.end(); ++node)
             {
@@ -159,26 +164,29 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
         [](const NodeID lhs, const NodeID rhs) { return std::max(lhs, rhs); });
 
     std::vector<extractor::EdgeBasedEdge> edges(max_turn_id + 1);
-    tbb::parallel_for(range, [&](const auto range) {
-        for (auto node = range.begin(); node < range.end(); ++node)
+    tbb::parallel_for(
+        range,
+        [&](const auto range)
         {
-            for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
+            for (auto node = range.begin(); node < range.end(); ++node)
             {
-                const auto &data = edge_based_graph.GetEdgeData(edge);
-                // we only need to save the forward edges, since the read method will
-                // convert from forward to bi-directional edges again
-                if (data.forward)
+                for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
                 {
-                    auto target = edge_based_graph.GetTarget(edge);
-                    BOOST_ASSERT(data.turn_id <= max_turn_id);
-                    edges[data.turn_id] = extractor::EdgeBasedEdge{node, target, data};
-                    // only save the forward edge
-                    edges[data.turn_id].data.forward = true;
-                    edges[data.turn_id].data.backward = false;
+                    const auto &data = edge_based_graph.GetEdgeData(edge);
+                    // we only need to save the forward edges, since the read method will
+                    // convert from forward to bi-directional edges again
+                    if (data.forward)
+                    {
+                        auto target = edge_based_graph.GetTarget(edge);
+                        BOOST_ASSERT(data.turn_id <= max_turn_id);
+                        edges[data.turn_id] = extractor::EdgeBasedEdge{node, target, data};
+                        // only save the forward edge
+                        edges[data.turn_id].data.forward = true;
+                        edges[data.turn_id].data.backward = false;
+                    }
                 }
             }
-        }
-    });
+        });
 
     return edges;
 }

include/partitioner/multi_level_graph.hpp

@@ -159,10 +159,11 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
     auto GetHighestBorderLevel(const MultiLevelPartition &mlp, const ContainerT &edges) const
     {
         std::vector<LevelID> highest_border_level(edges.size());
-        std::transform(
-            edges.begin(), edges.end(), highest_border_level.begin(), [&mlp](const auto &edge) {
-                return mlp.GetHighestDifferentLevel(edge.source, edge.target);
-            });
+        std::transform(edges.begin(),
+                       edges.end(),
+                       highest_border_level.begin(),
+                       [&mlp](const auto &edge)
+                       { return mlp.GetHighestDifferentLevel(edge.source, edge.target); });
         return highest_border_level;
     }
 
@@ -175,7 +176,8 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
         tbb::parallel_sort(
             permutation.begin(),
             permutation.end(),
-            [&edges, &highest_border_level](const auto &lhs, const auto &rhs) {
+            [&edges, &highest_border_level](const auto &lhs, const auto &rhs)
+            {
                 // sort by source node and then by level in ascending order
                 return std::tie(edges[lhs].source, highest_border_level[lhs], edges[lhs].target) <
                        std::tie(edges[rhs].source, highest_border_level[rhs], edges[rhs].target);
@@ -201,11 +203,12 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
             auto level_begin = iter;
             for (auto level : util::irange<LevelID>(0, mlp.GetNumberOfLevels()))
             {
-                iter = std::find_if(
-                    iter, edge_and_level_end, [node, level](const auto &edge_and_level) {
-                        return boost::get<0>(edge_and_level).source != node ||
-                               boost::get<1>(edge_and_level) != level;
-                    });
+                iter = std::find_if(iter,
+                                    edge_and_level_end,
+                                    [node, level](const auto &edge_and_level) {
+                                        return boost::get<0>(edge_and_level).source != node ||
+                                               boost::get<1>(edge_and_level) != level;
+                                    });
                 EdgeOffset offset = std::distance(level_begin, iter);
                 node_to_edge_offset.push_back(offset);
             }

include/partitioner/multi_level_partition.hpp

@@ -207,7 +207,8 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
         auto lidx = 0UL;
         util::for_each_pair(level_offsets.begin(),
                             level_offsets.begin() + num_level,
-                            [&](const auto offset, const auto next_offset) {
+                            [&](const auto offset, const auto next_offset)
+                            {
                                 // create mask that has `bits` ones at its LSBs.
                                 // 000011
                                 BOOST_ASSERT(offset <= NUM_PARTITION_BITS);
@@ -274,9 +275,8 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
         {
             std::stable_sort(permutation.begin(),
                              permutation.end(),
-                             [&partition](const auto lhs, const auto rhs) {
-                                 return partition[lhs] < partition[rhs];
-                             });
+                             [&partition](const auto lhs, const auto rhs)
+                             { return partition[lhs] < partition[rhs]; });
         }
 
         // top down assign new cell ids

include/partitioner/partition_graph.hpp

@@ -21,7 +21,7 @@ template <typename Base> class NodeEntryWrapper : public Base
 {
   public:
     template <typename... Args>
-    NodeEntryWrapper(std::size_t edges_begin_, std::size_t edges_end_, Args &&... args)
+    NodeEntryWrapper(std::size_t edges_begin_, std::size_t edges_end_, Args &&...args)
         : Base(std::forward<Args>(args)...), edges_begin(edges_begin_), edges_end(edges_end_)
     {
     }
@@ -41,7 +41,7 @@ template <typename Base> class GraphConstructionWrapper : public Base
 {
   public:
     template <typename... Args>
-    GraphConstructionWrapper(const NodeID source_, Args &&... args)
+    GraphConstructionWrapper(const NodeID source_, Args &&...args)
         : Base(std::forward<Args>(args)...), source(source_)
     {
     }

include/partitioner/remove_unconnected.hpp

@@ -59,11 +59,13 @@ std::size_t removeUnconnectedBoundaryNodes(const GraphT &edge_based_graph,
 
                 if (level_index < static_cast<int>(partitions.size() - 1))
                 {
-                    auto new_end = std::remove_if(
-                        witnesses.begin(), witnesses.end(), [&](const auto &witness) {
-                            return partitions[level_index + 1][node] !=
-                                   partitions[level_index + 1][witness.id];
-                        });
+                    auto new_end =
+                        std::remove_if(witnesses.begin(),
+                                       witnesses.end(),
+                                       [&](const auto &witness) {
+                                           return partitions[level_index + 1][node] !=
+                                                  partitions[level_index + 1][witness.id];
+                                       });
                     witnesses.resize(new_end - witnesses.begin());
                 }
                 if (witnesses.size() == 0)
@@ -87,10 +89,12 @@ std::size_t removeUnconnectedBoundaryNodes(const GraphT &edge_based_graph,
                     }
                 }
 
-                auto best_witness = std::min_element(
-                    witnesses.begin(), witnesses.end(), [](const auto &lhs, const auto &rhs) {
-                        return lhs.induced_border_edges < rhs.induced_border_edges;
-                    });
+                auto best_witness =
+                    std::min_element(witnesses.begin(),
+                                     witnesses.end(),
+                                     [](const auto &lhs, const auto &rhs) {
+                                         return lhs.induced_border_edges < rhs.induced_border_edges;
+                                     });
                 BOOST_ASSERT(best_witness != witnesses.end());
 
                 // assign `node` to same subcells as `best_witness`

include/partitioner/reorder_first_last.hpp

@@ -30,10 +30,10 @@ void reorderFirstLast(RandomIt first, RandomIt last, std::size_t n, Comparator c
     // requirements.
     std::reverse_iterator<RandomIt> rfirst{last}, rlast{first + n};
 
-    const auto flipped = [](auto fn) {
-        return [fn](auto &&lhs, auto &&rhs) {
-            return fn(std::forward<decltype(lhs)>(rhs), std::forward<decltype(rhs)>(lhs));
-        };
+    const auto flipped = [](auto fn)
+    {
+        return [fn](auto &&lhs, auto &&rhs)
+        { return fn(std::forward<decltype(lhs)>(rhs), std::forward<decltype(rhs)>(lhs)); };
     };
 
     std::nth_element(rfirst, rfirst + (n - 1), rlast, flipped(comp));

include/server/api/base_parameters_grammar.hpp

@@ -74,16 +74,16 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
         : BaseParametersGrammar::base_type(root_rule)
     {
         const auto add_hint = [](engine::api::BaseParameters &base_parameters,
-                                 const std::vector<std::string> &hint_strings) {
+                                 const std::vector<std::string> &hint_strings)
+        {
             if (!hint_strings.empty())
             {
                 std::vector<engine::SegmentHint> location_hints(hint_strings.size());
                 std::transform(hint_strings.begin(),
                                hint_strings.end(),
                                location_hints.begin(),
-                               [](const auto &hint_string) {
-                                   return engine::SegmentHint::FromBase64(hint_string);
-                               });
+                               [](const auto &hint_string)
+                               { return engine::SegmentHint::FromBase64(hint_string); });
                 base_parameters.hints.push_back(engine::Hint{std::move(location_hints)});
             }
             else
@@ -94,15 +94,16 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
 
         const auto add_bearing =
             [](engine::api::BaseParameters &base_parameters,
-               boost::optional<boost::fusion::vector2<short, short>> bearing_range) {
-                boost::optional<engine::Bearing> bearing;
-                if (bearing_range)
-                {
-                    bearing = engine::Bearing{boost::fusion::at_c<0>(*bearing_range),
-                                              boost::fusion::at_c<1>(*bearing_range)};
-                }
-                base_parameters.bearings.push_back(std::move(bearing));
-            };
+               boost::optional<boost::fusion::vector2<short, short>> bearing_range)
+        {
+            boost::optional<engine::Bearing> bearing;
+            if (bearing_range)
+            {
+                bearing = engine::Bearing{boost::fusion::at_c<0>(*bearing_range),
+                                          boost::fusion::at_c<1>(*bearing_range)};
+            }
+            base_parameters.bearings.push_back(std::move(bearing));
+        };
 
         polyline_chars = qi::char_("a-zA-Z0-9_.--[]{}@?|\\%~`^");
         base64_char = qi::char_("a-zA-Z0-9--_=");
@@ -118,7 +119,8 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
 
         location_rule = (double_ > qi::lit(',') >
                          double_)[qi::_val = ph::bind(
-                                      [](double lon, double lat) {
+                                      [](double lon, double lat)
+                                      {
                                           return util::Coordinate(
                                               util::toFixed(util::UnsafeFloatLongitude{lon}),
                                               util::toFixed(util::UnsafeFloatLatitude{lat}));
@@ -126,19 +128,17 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
                                       qi::_1,
                                       qi::_2)];
 
-        polyline_rule = qi::as_string[qi::lit("polyline(") > +polyline_chars > ')']
-                                     [qi::_val = ph::bind(
-                                          [](const std::string &polyline) {
-                                              return engine::decodePolyline(polyline);
-                                          },
-                                          qi::_1)];
+        polyline_rule =
+            qi::as_string[qi::lit("polyline(") > +polyline_chars > ')']
+                         [qi::_val = ph::bind([](const std::string &polyline)
+                                              { return engine::decodePolyline(polyline); },
+                                              qi::_1)];
 
-        polyline6_rule = qi::as_string[qi::lit("polyline6(") > +polyline_chars > ')']
-                                      [qi::_val = ph::bind(
-                                           [](const std::string &polyline) {
-                                               return engine::decodePolyline<1000000>(polyline);
-                                           },
-                                           qi::_1)];
+        polyline6_rule =
+            qi::as_string[qi::lit("polyline6(") > +polyline_chars > ')']
+                         [qi::_val = ph::bind([](const std::string &polyline)
+                                              { return engine::decodePolyline<1000000>(polyline); },
+                                              qi::_1)];
 
         query_rule =
             ((location_rule % ';') | polyline_rule |
@@ -166,8 +166,9 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
             qi::lit("bearings=") >
             (-(qi::short_ > ',' > qi::short_))[ph::bind(add_bearing, qi::_r1, qi::_1)] % ';';
 
-        approach_type.add("unrestricted", engine::Approach::UNRESTRICTED)("curb",
-                                                                          engine::Approach::CURB);
+        approach_type.add("unrestricted", engine::Approach::UNRESTRICTED)(
+            "curb", engine::Approach::CURB)("opposite", engine::Approach::OPPOSITE);
+
         approach_rule = qi::lit("approaches=") >
                         (-approach_type %
                          ';')[ph::bind(&engine::api::BaseParameters::approaches, qi::_r1) = qi::_1];

include/server/api/route_parameters_grammar.hpp

@@ -54,8 +54,9 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
 #endif
         using AnnotationsType = engine::api::RouteParameters::AnnotationsType;
 
-        const auto add_annotation = [](engine::api::RouteParameters &route_parameters,
-                                       AnnotationsType route_param) {
+        const auto add_annotation =
+            [](engine::api::RouteParameters &route_parameters, AnnotationsType route_param)
+        {
             route_parameters.annotations_type = route_parameters.annotations_type | route_param;
             route_parameters.annotations =
                 route_parameters.annotations_type != AnnotationsType::None;

include/server/connection.hpp

@@ -14,18 +14,6 @@
 #include <memory>
 #include <vector>
 
-// workaround for incomplete std::shared_ptr compatibility in old boost versions
-#if BOOST_VERSION < 105300 || defined BOOST_NO_CXX11_SMART_PTR
-
-namespace boost
-{
-template <class T> const T *get_pointer(std::shared_ptr<T> const &p) { return p.get(); }
-
-template <class T> T *get_pointer(std::shared_ptr<T> &p) { return p.get(); }
-} // namespace boost
-
-#endif
-
 namespace osrm::server
 {
 
@@ -35,7 +23,9 @@ class RequestHandler;
 class Connection : public std::enable_shared_from_this<Connection>
 {
   public:
-    explicit Connection(boost::asio::io_context &io_context, RequestHandler &handler);
+    explicit Connection(boost::asio::io_context &io_context,
+                        RequestHandler &handler,
+                        short keepalive_timeout);
     Connection(const Connection &) = delete;
     Connection &operator=(const Connection &) = delete;
 

include/server/server.hpp

@@ -31,18 +31,24 @@ class Server
 {
   public:
     // Note: returns a shared instead of a unique ptr as it is captured in a lambda somewhere else
-    static std::shared_ptr<Server>
-    CreateServer(std::string &ip_address, int ip_port, unsigned requested_num_threads)
+    static std::shared_ptr<Server> CreateServer(std::string &ip_address,
+                                                int ip_port,
+                                                unsigned requested_num_threads,
+                                                short keepalive_timeout)
     {
         util::Log() << "http 1.1 compression handled by zlib version " << zlibVersion();
         const unsigned hardware_threads = std::max(1u, std::thread::hardware_concurrency());
         const unsigned real_num_threads = std::min(hardware_threads, requested_num_threads);
-        return std::make_shared<Server>(ip_address, ip_port, real_num_threads);
+        return std::make_shared<Server>(ip_address, ip_port, real_num_threads, keepalive_timeout);
     }
 
-    explicit Server(const std::string &address, const int port, const unsigned thread_pool_size)
-        : thread_pool_size(thread_pool_size), acceptor(io_context),
-          new_connection(std::make_shared<Connection>(io_context, request_handler))
+    explicit Server(const std::string &address,
+                    const int port,
+                    const unsigned thread_pool_size,
+                    const short keepalive_timeout)
+        : thread_pool_size(thread_pool_size), keepalive_timeout(keepalive_timeout),
+          acceptor(io_context), new_connection(std::make_shared<Connection>(
+                                    io_context, request_handler, keepalive_timeout))
     {
         const auto port_string = std::to_string(port);
 
@@ -94,7 +100,8 @@ class Server
         if (!e)
         {
             new_connection->start();
-            new_connection = std::make_shared<Connection>(io_context, request_handler);
+            new_connection =
+                std::make_shared<Connection>(io_context, request_handler, keepalive_timeout);
             acceptor.async_accept(
                 new_connection->socket(),
                 boost::bind(&Server::HandleAccept, this, boost::asio::placeholders::error));
@@ -107,6 +114,7 @@ class Server
 
     RequestHandler request_handler;
     unsigned thread_pool_size;
+    short keepalive_timeout;
     boost::asio::io_context io_context;
     boost::asio::ip::tcp::acceptor acceptor;
     std::shared_ptr<Connection> new_connection;

include/storage/serialization.hpp

@@ -66,7 +66,8 @@ void readBoolVector(tar::FileReader &reader, const std::string &name, VectorT &d
     using BlockType = std::uint64_t;
     constexpr std::uint64_t BLOCK_BITS = CHAR_BIT * sizeof(BlockType);
 
-    const auto decode = [&](const BlockType block) {
+    const auto decode = [&](const BlockType block)
+    {
         auto read_size = std::min<std::size_t>(count - index, BLOCK_BITS);
         unpackBits<VectorT, BlockType>(data, index, read_size, block);
         index += BLOCK_BITS;
@@ -87,7 +88,8 @@ void writeBoolVector(tar::FileWriter &writer, const std::string &name, const Vec
 
     // FIXME on old boost version the function_input_iterator does not work with lambdas
     // so we need to wrap it in a function here.
-    const std::function<BlockType()> encode_function = [&]() -> BlockType {
+    const std::function<BlockType()> encode_function = [&]() -> BlockType
+    {
         auto write_size = std::min<std::size_t>(count - index, BLOCK_BITS);
         auto packed = packBits<VectorT, BlockType>(data, index, write_size);
         index += BLOCK_BITS;

include/storage/shared_data_index.hpp

@@ -28,10 +28,10 @@ class SharedDataIndex
         // Build mapping from block name to region
         for (auto index : util::irange<std::uint32_t>(0, regions.size()))
         {
-            regions[index].layout->List("",
-                                        boost::make_function_output_iterator([&](const auto &name) {
-                                            block_to_region[name] = index;
-                                        }));
+            regions[index].layout->List(
+                "",
+                boost::make_function_output_iterator([&](const auto &name)
+                                                     { block_to_region[name] = index; }));
         }
     }
 

include/storage/shared_datatype.hpp

@@ -223,9 +223,12 @@ struct SharedRegionRegister
     // Returns the key of the region with the given name
     RegionID Find(const std::string &name) const
     {
-        auto iter = std::find_if(regions.begin(), regions.end(), [&](const auto &region) {
-            return std::strncmp(region.name, name.c_str(), SharedRegion::MAX_NAME_LENGTH) == 0;
-        });
+        auto iter = std::find_if(
+            regions.begin(),
+            regions.end(),
+            [&](const auto &region) {
+                return std::strncmp(region.name, name.c_str(), SharedRegion::MAX_NAME_LENGTH) == 0;
+            });
 
         if (iter == regions.end())
         {

include/storage/shared_memory.hpp

@@ -113,7 +113,8 @@ class SharedMemory
     {
         auto shmid = shm.get_shmid();
         ::shmid_ds xsi_ds;
-        const auto errorToMessage = [](int error) -> std::string {
+        const auto errorToMessage = [](int error) -> std::string
+        {
             switch (error)
             {
             case EPERM:

include/storage/view_factory.hpp

@@ -241,9 +241,9 @@ inline auto make_contracted_metric_view(const SharedDataIndex &index, const std:
 
     std::vector<util::vector_view<bool>> edge_filter;
     index.List(name + "/exclude",
-               boost::make_function_output_iterator([&](const auto &filter_name) {
-                   edge_filter.push_back(make_vector_view<bool>(index, filter_name));
-               }));
+               boost::make_function_output_iterator(
+                   [&](const auto &filter_name)
+                   { edge_filter.push_back(make_vector_view<bool>(index, filter_name)); }));
 
     return contractor::ContractedMetricView{{node_list, edge_list}, std::move(edge_filter)};
 }

include/updater/csv_file_parser.hpp

@@ -39,38 +39,43 @@ template <typename Key, typename Value> struct CSVFilesParser
     {
     }
 
-    // Operator returns a lambda function that maps input Key to boost::optional<Value>.
+    // Operator returns a lambda function that maps input Key to std::optional<Value>.
     auto operator()(const std::vector<std::string> &csv_filenames) const
     {
         try
         {
             tbb::spin_mutex mutex;
             std::vector<std::pair<Key, Value>> lookup;
-            tbb::parallel_for(std::size_t{0}, csv_filenames.size(), [&](const std::size_t idx) {
-                auto local = ParseCSVFile(csv_filenames[idx], start_index + idx);
+            tbb::parallel_for(std::size_t{0},
+                              csv_filenames.size(),
+                              [&](const std::size_t idx)
+                              {
+                                  auto local = ParseCSVFile(csv_filenames[idx], start_index + idx);
 
-                { // Merge local CSV results into a flat global vector
-                    tbb::spin_mutex::scoped_lock _{mutex};
-                    lookup.insert(end(lookup),
-                                  std::make_move_iterator(begin(local)),
-                                  std::make_move_iterator(end(local)));
-                }
-            });
+                                  { // Merge local CSV results into a flat global vector
+                                      tbb::spin_mutex::scoped_lock _{mutex};
+                                      lookup.insert(end(lookup),
+                                                    std::make_move_iterator(begin(local)),
+                                                    std::make_move_iterator(end(local)));
+                                  }
+                              });
 
             // With flattened map-ish view of all the files, make a stable sort on key and source
             // and unique them on key to keep only the value with the largest file index
             // and the largest line number in a file.
             // The operands order is swapped to make descending ordering on (key, source)
-            tbb::parallel_sort(begin(lookup), end(lookup), [](const auto &lhs, const auto &rhs) {
-                return std::tie(rhs.first, rhs.second.source) <
-                       std::tie(lhs.first, lhs.second.source);
-            });
+            tbb::parallel_sort(begin(lookup),
+                               end(lookup),
+                               [](const auto &lhs, const auto &rhs) {
+                                   return std::tie(rhs.first, rhs.second.source) <
+                                          std::tie(lhs.first, lhs.second.source);
+                               });
 
             // Unique only on key to take the source precedence into account and remove duplicates.
-            const auto it =
-                std::unique(begin(lookup), end(lookup), [](const auto &lhs, const auto &rhs) {
-                    return lhs.first == rhs.first;
-                });
+            const auto it = std::unique(begin(lookup),
+                                        end(lookup),
+                                        [](const auto &lhs, const auto &rhs)
+                                        { return lhs.first == rhs.first; });
             lookup.erase(it, end(lookup));
 
             util::Log() << "In total loaded " << csv_filenames.size() << " file(s) with a total of "

include/updater/source.hpp

@@ -3,8 +3,7 @@
 
 #include "util/typedefs.hpp"
 
-#include <boost/optional.hpp>
-
+#include <optional>
 #include <vector>
 
 namespace osrm::updater
@@ -12,13 +11,14 @@ namespace osrm::updater
 
 template <typename Key, typename Value> struct LookupTable
 {
-    boost::optional<Value> operator()(const Key &key) const
+    std::optional<Value> operator()(const Key &key) const
     {
-        using Result = boost::optional<Value>;
-        const auto it = std::lower_bound(
-            lookup.begin(), lookup.end(), key, [](const auto &lhs, const auto &rhs) {
-                return rhs < lhs.first;
-            });
+        using Result = std::optional<Value>;
+        const auto it =
+            std::lower_bound(lookup.begin(),
+                             lookup.end(),
+                             key,
+                             [](const auto &lhs, const auto &rhs) { return rhs < lhs.first; });
         return it != std::end(lookup) && !(it->first < key) ? Result(it->second) : Result();
     }
 
@@ -49,7 +49,7 @@ struct SpeedSource final
 {
     SpeedSource() : speed(0.), rate() {}
     double speed;
-    boost::optional<double> rate;
+    std::optional<double> rate;
     std::uint8_t source;
 };
 

include/util/alias.hpp

@@ -46,7 +46,7 @@ template <typename From, typename Tag> struct Alias final
     static_assert(std::is_arithmetic<From>::value, "Needs to be based on an arithmetic type");
 
     From __value;
-    friend std::ostream &operator<<<From, Tag>(std::ostream &stream, const Alias &inst);
+    friend std::ostream &operator<< <From, Tag>(std::ostream &stream, const Alias &inst);
 
     explicit operator From &() { return __value; }
     explicit operator From() const { return __value; }

include/util/coordinate.hpp

@@ -72,12 +72,20 @@ using FloatLongitude = Alias<double, tag::longitude>;
 // range checks on these (toFixed/toFloat, etc)
 using UnsafeFloatLatitude = Alias<double, tag::unsafelatitude>;
 using UnsafeFloatLongitude = Alias<double, tag::unsafelongitude>;
-static_assert(std::is_pod<FixedLatitude>(), "FixedLatitude is not a valid alias");
-static_assert(std::is_pod<FixedLongitude>(), "FixedLongitude is not a valid alias");
-static_assert(std::is_pod<FloatLatitude>(), "FloatLatitude is not a valid alias");
-static_assert(std::is_pod<FloatLongitude>(), "FloatLongitude is not a valid alias");
-static_assert(std::is_pod<UnsafeFloatLatitude>(), "UnsafeFloatLatitude is not a valid alias");
-static_assert(std::is_pod<UnsafeFloatLongitude>(), "UnsafeFloatLongitude is not a valid alias");
+static_assert(std::is_standard_layout<FixedLatitude>() && std::is_trivial<FixedLatitude>(),
+              "FixedLatitude is not a valid alias");
+static_assert(std::is_standard_layout<FixedLongitude>() && std::is_trivial<FixedLongitude>(),
+              "FixedLongitude is not a valid alias");
+static_assert(std::is_standard_layout<FloatLatitude>() && std::is_trivial<FloatLatitude>(),
+              "FloatLatitude is not a valid alias");
+static_assert(std::is_standard_layout<FloatLongitude>() && std::is_trivial<FloatLongitude>(),
+              "FloatLongitude is not a valid alias");
+static_assert(std::is_standard_layout<UnsafeFloatLatitude>() &&
+                  std::is_trivial<UnsafeFloatLatitude>(),
+              "UnsafeFloatLatitude is not a valid alias");
+static_assert(std::is_standard_layout<UnsafeFloatLongitude>() &&
+                  std::is_trivial<UnsafeFloatLongitude>(),
+              "UnsafeFloatLongitude is not a valid alias");
 
 /**
  * Converts a typed latitude from floating to fixed representation.

include/util/coordinate_calculation.hpp

@@ -4,11 +4,11 @@
 #include "util/coordinate.hpp"
 
 #include <boost/math/constants/constants.hpp>
-#include <boost/optional.hpp>
 
 #include <algorithm>
 #include <cmath>
 #include <numeric>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -36,6 +36,13 @@ inline double radToDeg(const double radian)
 }
 } // namespace detail
 
+const constexpr static double METERS_PER_DEGREE_LAT = 110567.0;
+
+inline double metersPerLngDegree(const FixedLatitude lat)
+{
+    return std::cos(detail::degToRad(static_cast<double>(toFloating(lat)))) * METERS_PER_DEGREE_LAT;
+}
+
 //! Takes the squared euclidean distance of the input coordinates. Does not return meters!
 std::uint64_t squaredEuclideanDistance(const Coordinate lhs, const Coordinate rhs);
 
@@ -102,9 +109,9 @@ double bearing(const Coordinate first_coordinate, const Coordinate second_coordi
 double computeAngle(const Coordinate first, const Coordinate second, const Coordinate third);
 
 // find the center of a circle through three coordinates
-boost::optional<Coordinate> circleCenter(const Coordinate first_coordinate,
-                                         const Coordinate second_coordinate,
-                                         const Coordinate third_coordinate);
+std::optional<Coordinate> circleCenter(const Coordinate first_coordinate,
+                                       const Coordinate second_coordinate,
+                                       const Coordinate third_coordinate);
 
 // find the radius of a circle through three coordinates
 double circleRadius(const Coordinate first_coordinate,
@@ -179,12 +186,14 @@ template <class BinaryOperation, typename iterator_type>
 double getLength(iterator_type begin, const iterator_type end, BinaryOperation op)
 {
     double result = 0;
-    const auto functor = [&result, op](const Coordinate lhs, const Coordinate rhs) {
+    const auto functor = [&result, op](const Coordinate lhs, const Coordinate rhs)
+    {
         result += op(lhs, rhs);
         return false;
     };
     // side-effect find adding up distances
-    std::adjacent_find(begin, end, functor);
+    // Ignore return value, we are only interested in the side-effect
+    [[maybe_unused]] auto _ = std::adjacent_find(begin, end, functor);
 
     return result;
 }
@@ -196,13 +205,15 @@ findClosestDistance(const Coordinate coordinate, const iterator_type begin, cons
     double current_min = std::numeric_limits<double>::max();
 
     // comparator updating current_min without ever finding an element
-    const auto compute_minimum_distance = [&current_min, coordinate](const Coordinate lhs,
-                                                                     const Coordinate rhs) {
+    const auto compute_minimum_distance =
+        [&current_min, coordinate](const Coordinate lhs, const Coordinate rhs)
+    {
         current_min = std::min(current_min, findClosestDistance(coordinate, lhs, rhs));
         return false;
     };
 
-    std::adjacent_find(begin, end, compute_minimum_distance);
+    // Ignore return value, we are only interested in the side-effect
+    [[maybe_unused]] auto _ = std::adjacent_find(begin, end, compute_minimum_distance);
     return current_min;
 }
 
@@ -214,8 +225,9 @@ double findClosestDistance(const iterator_type lhs_begin,
 {
     double current_min = std::numeric_limits<double>::max();
 
-    const auto compute_minimum_distance_in_rhs = [&current_min, rhs_begin, rhs_end](
-                                                     const Coordinate coordinate) {
+    const auto compute_minimum_distance_in_rhs =
+        [&current_min, rhs_begin, rhs_end](const Coordinate coordinate)
+    {
         current_min = std::min(current_min, findClosestDistance(coordinate, rhs_begin, rhs_end));
         return false;
     };
@@ -231,13 +243,11 @@ std::pair<Coordinate, Coordinate> leastSquareRegression(const iterator_type begi
     // following the formulas of https://faculty.elgin.edu/dkernler/statistics/ch04/4-2.html
     const auto number_of_coordinates = std::distance(begin, end);
     BOOST_ASSERT(number_of_coordinates >= 2);
-    const auto extract_lon = [](const Coordinate coordinate) {
-        return static_cast<double>(toFloating(coordinate.lon));
-    };
+    const auto extract_lon = [](const Coordinate coordinate)
+    { return static_cast<double>(toFloating(coordinate.lon)); };
 
-    const auto extract_lat = [](const Coordinate coordinate) {
-        return static_cast<double>(toFloating(coordinate.lat));
-    };
+    const auto extract_lat = [](const Coordinate coordinate)
+    { return static_cast<double>(toFloating(coordinate.lat)); };
 
     double min_lon = extract_lon(*begin);
     double max_lon = extract_lon(*begin);
@@ -260,19 +270,21 @@ std::pair<Coordinate, Coordinate> leastSquareRegression(const iterator_type begi
     {
         std::vector<util::Coordinate> rotated_coordinates(number_of_coordinates);
         // rotate all coordinates to the right
-        std::transform(begin, end, rotated_coordinates.begin(), [](const auto coordinate) {
-            return rotateCCWAroundZero(coordinate, detail::degToRad(-90));
-        });
+        std::transform(begin,
+                       end,
+                       rotated_coordinates.begin(),
+                       [](const auto coordinate)
+                       { return rotateCCWAroundZero(coordinate, detail::degToRad(-90)); });
         const auto rotated_regression =
             leastSquareRegression(rotated_coordinates.begin(), rotated_coordinates.end());
         return {rotateCCWAroundZero(rotated_regression.first, detail::degToRad(90)),
                 rotateCCWAroundZero(rotated_regression.second, detail::degToRad(90))};
     }
 
-    const auto make_accumulate = [](const auto extraction_function) {
-        return [extraction_function](const double sum_so_far, const Coordinate coordinate) {
-            return sum_so_far + extraction_function(coordinate);
-        };
+    const auto make_accumulate = [](const auto extraction_function)
+    {
+        return [extraction_function](const double sum_so_far, const Coordinate coordinate)
+        { return sum_so_far + extraction_function(coordinate); };
     };
 
     const auto accumulated_lon = std::accumulate(begin, end, 0., make_accumulate(extract_lon));
@@ -281,8 +293,10 @@ std::pair<Coordinate, Coordinate> leastSquareRegression(const iterator_type begi
 
     const auto mean_lon = accumulated_lon / number_of_coordinates;
     const auto mean_lat = accumulated_lat / number_of_coordinates;
-    const auto make_variance = [](const auto mean, const auto extraction_function) {
-        return [extraction_function, mean](const double sum_so_far, const Coordinate coordinate) {
+    const auto make_variance = [](const auto mean, const auto extraction_function)
+    {
+        return [extraction_function, mean](const double sum_so_far, const Coordinate coordinate)
+        {
             const auto difference = extraction_function(coordinate) - mean;
             return sum_so_far + difference * difference;
         };
@@ -310,7 +324,8 @@ std::pair<Coordinate, Coordinate> leastSquareRegression(const iterator_type begi
         std::accumulate(begin,
                         end,
                         0.,
-                        [&](const auto sum_so_far, const auto current_coordinate) {
+                        [&](const auto sum_so_far, const auto current_coordinate)
+                        {
                             return sum_so_far + (extract_lon(current_coordinate) - mean_lon) *
                                                     (extract_lat(current_coordinate) - mean_lat) /
                                                     (sample_variance_lon * sample_variance_lat);
@@ -321,9 +336,8 @@ std::pair<Coordinate, Coordinate> leastSquareRegression(const iterator_type begi
     const auto intercept = mean_lat - slope * mean_lon;
 
     const auto GetLatAtLon = [intercept,
-                              slope](const util::FloatLongitude longitude) -> util::FloatLatitude {
-        return {intercept + slope * static_cast<double>((longitude))};
-    };
+                              slope](const util::FloatLongitude longitude) -> util::FloatLatitude
+    { return {intercept + slope * static_cast<double>((longitude))}; };
 
     const double offset = 0.00001;
     const Coordinate regression_first = {
@@ -357,7 +371,8 @@ bool areParallel(const iterator_type lhs_begin,
     const auto rotation_angle_radians = detail::degToRad(bearing_lhs - 90);
     const auto rotated_difference_rhs = rotateCCWAroundZero(difference_rhs, rotation_angle_radians);
 
-    const auto get_slope = [](const Coordinate from, const Coordinate to) {
+    const auto get_slope = [](const Coordinate from, const Coordinate to)
+    {
         const auto diff_lat = static_cast<int>(from.lat) - static_cast<int>(to.lat);
         const auto diff_lon = static_cast<int>(from.lon) - static_cast<int>(to.lon);
         if (diff_lon == 0)

include/util/deallocating_vector.hpp

@@ -254,7 +254,7 @@ template <typename ElementT> class DeallocatingVector
         ++current_size;
     }
 
-    template <typename... Ts> void emplace_back(Ts &&... element)
+    template <typename... Ts> void emplace_back(Ts &&...element)
     {
         const std::size_t current_capacity = capacity();
         if (current_size == current_capacity)

include/util/dynamic_graph.hpp

@@ -68,7 +68,7 @@ template <typename EdgeDataT> class DynamicGraph
         }
 
         template <typename... Ts>
-        InputEdge(NodeIterator source, NodeIterator target, Ts &&... data)
+        InputEdge(NodeIterator source, NodeIterator target, Ts &&...data)
             : source(source), target(target), data(std::forward<Ts>(data)...)
         {
         }
@@ -189,25 +189,28 @@ template <typename EdgeDataT> class DynamicGraph
         other.node_array.resize(node_array.size());
 
         NodeID node_id = 0;
-        std::transform(
-            node_array.begin(), node_array.end(), other.node_array.begin(), [&](const Node &node) {
-                const EdgeIterator first_edge = other.edge_list.size();
+        std::transform(node_array.begin(),
+                       node_array.end(),
+                       other.node_array.begin(),
+                       [&](const Node &node)
+                       {
+                           const EdgeIterator first_edge = other.edge_list.size();
 
-                BOOST_ASSERT(node_id < number_of_nodes);
-                if (filter(node_id++))
-                {
-                    std::copy_if(edge_list.begin() + node.first_edge,
-                                 edge_list.begin() + node.first_edge + node.edges,
-                                 std::back_inserter(other.edge_list),
-                                 [&](const auto &edge) { return filter(edge.target); });
-                    const unsigned num_edges = other.edge_list.size() - first_edge;
-                    return Node{first_edge, num_edges};
-                }
-                else
-                {
-                    return Node{first_edge, 0};
-                }
-            });
+                           BOOST_ASSERT(node_id < number_of_nodes);
+                           if (filter(node_id++))
+                           {
+                               std::copy_if(edge_list.begin() + node.first_edge,
+                                            edge_list.begin() + node.first_edge + node.edges,
+                                            std::back_inserter(other.edge_list),
+                                            [&](const auto &edge) { return filter(edge.target); });
+                               const unsigned num_edges = other.edge_list.size() - first_edge;
+                               return Node{first_edge, num_edges};
+                           }
+                           else
+                           {
+                               return Node{first_edge, 0};
+                           }
+                       });
 
         return other;
     }

include/util/filtered_graph.hpp

@@ -37,9 +37,9 @@ class FilteredGraphImpl<util::StaticGraph<EdgeDataT, Ownership>, Ownership>
     unsigned GetOutDegree(const NodeIterator n) const
     {
         auto range = graph.GetAdjacentEdgeRange(n);
-        return std::count_if(range.begin(), range.end(), [this](const EdgeIterator edge) {
-            return edge_filter[edge];
-        });
+        return std::count_if(range.begin(),
+                             range.end(),
+                             [this](const EdgeIterator edge) { return edge_filter[edge]; });
     }
 
     inline NodeIterator GetTarget(const EdgeIterator e) const

include/util/fingerprint.hpp

@@ -33,7 +33,8 @@ struct FingerPrint
 
 static_assert(sizeof(FingerPrint) == 8, "FingerPrint has unexpected size");
 static_assert(std::is_trivial<FingerPrint>::value, "FingerPrint needs to be trivial.");
-static_assert(std::is_pod<FingerPrint>::value, "FingerPrint needs to be a POD.");
+static_assert(std::is_standard_layout<FingerPrint>::value,
+              "FingerPrint needs have a standard layout.");
 } // namespace osrm::util
 
 #endif /* FingerPrint_H */

include/util/geojson_debug_logger.hpp

@@ -58,7 +58,7 @@ class GeojsonLogger
     }
 
     // writes a single feature into the Geojson file
-    template <typename... Args> static bool Write(Args &&... args)
+    template <typename... Args> static bool Write(Args &&...args)
     {
         // make sure to syncronize logging output, our writing should be sequential
         std::lock_guard<std::mutex> guard(lock);
@@ -146,7 +146,7 @@ class ScopedGeojsonLoggerGuard
 {
   public:
     template <typename... Args>
-    ScopedGeojsonLoggerGuard(const std::string &logfile, Args &&... args)
+    ScopedGeojsonLoggerGuard(const std::string &logfile, Args &&...args)
         : policy(std::forward<Args>(args)...)
     {
         GeojsonLogger<geojson_conversion_policy, scenario>::Open(logfile);
@@ -159,7 +159,7 @@ class ScopedGeojsonLoggerGuard
         GeojsonLogger<geojson_conversion_policy, scenario>::SetPolicy(nullptr);
     }
 
-    template <typename... Args> static bool Write(Args &&... args)
+    template <typename... Args> static bool Write(Args &&...args)
     {
         return GeojsonLogger<geojson_conversion_policy, scenario>::Write(
             std::forward<Args>(args)...);

include/util/geojson_debug_policies.hpp

@@ -1,6 +1,7 @@
 #ifndef OSRM_GEOJSON_DEBUG_POLICIES
 #define OSRM_GEOJSON_DEBUG_POLICIES
 
+#include <optional>
 #include <vector>
 
 #include "extractor/query_node.hpp"
@@ -9,8 +10,6 @@
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
 
-#include <boost/optional.hpp>
-
 namespace osrm::util
 {
 
@@ -20,7 +19,7 @@ struct NodeIdVectorToLineString
 
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<NodeID> &node_ids,
-                                  const boost::optional<json::Object> &properties = {}) const;
+                                  const std::optional<json::Object> &properties = {}) const;
 
     const std::vector<util::Coordinate> &node_coordinates;
 };
@@ -29,7 +28,7 @@ struct CoordinateVectorToLineString
 {
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<util::Coordinate> &coordinates,
-                                  const boost::optional<json::Object> &properties = {}) const;
+                                  const std::optional<json::Object> &properties = {}) const;
 };
 
 struct NodeIdVectorToMultiPoint
@@ -38,7 +37,7 @@ struct NodeIdVectorToMultiPoint
 
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<NodeID> &node_ids,
-                                  const boost::optional<json::Object> &properties = {}) const;
+                                  const std::optional<json::Object> &properties = {}) const;
 
     const std::vector<util::Coordinate> &node_coordinates;
 };
@@ -47,7 +46,7 @@ struct CoordinateVectorToMultiPoint
 {
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<util::Coordinate> &coordinates,
-                                  const boost::optional<json::Object> &properties = {}) const;
+                                  const std::optional<json::Object> &properties = {}) const;
 };
 
 } // namespace osrm::util

include/util/geojson_debug_policy_toolkit.hpp

@@ -7,8 +7,7 @@
 
 #include <algorithm>
 #include <iterator>
-
-#include <boost/optional.hpp>
+#include <optional>
 
 namespace osrm::util
 {
@@ -84,7 +83,7 @@ struct NodeIdToCoordinate
 
 inline util::json::Object makeFeature(std::string type,
                                       util::json::Array coordinates,
-                                      const boost::optional<util::json::Object> &properties = {})
+                                      const std::optional<util::json::Object> &properties = {})
 {
     util::json::Object result;
     result.values["type"] = "Feature";

include/util/guidance/name_announcements.hpp

@@ -63,14 +63,16 @@ template <typename StringView> inline auto decompose(const StringView &lhs, cons
     auto const lcs = longest_common_substring(lhs, rhs);
 
     // trim spaces, transform to lower
-    const auto trim = [](StringView view) {
+    const auto trim = [](StringView view)
+    {
         // we compare suffixes based on this value, it might break UTF chars, but as long as we are
         // consistent in handling, we do not create bad results
         std::string str;
         str.reserve(view.size());
-        std::transform(view.begin(), view.end(), std::back_inserter(str), [](unsigned char c) {
-            return std::tolower(c);
-        });
+        std::transform(view.begin(),
+                       view.end(),
+                       std::back_inserter(str),
+                       [](unsigned char c) { return std::tolower(c); });
         auto front = str.find_first_not_of(' ');
 
         if (front == std::string::npos)
@@ -131,13 +133,13 @@ inline bool requiresNameAnnounced(const StringView &from_name,
 
     const auto checkForPrefixOrSuffixChange = [](const std::string_view first,
                                                  const std::string_view second,
-                                                 const SuffixTable &suffix_table) {
+                                                 const SuffixTable &suffix_table)
+    {
         std::string first_prefix, first_suffix, second_prefix, second_suffix;
         std::tie(first_prefix, first_suffix, second_prefix, second_suffix) =
             decompose(first, second);
-        const auto checkTable = [&](const std::string &str) {
-            return str.empty() || suffix_table.isSuffix(str);
-        };
+        const auto checkTable = [&](const std::string &str)
+        { return str.empty() || suffix_table.isSuffix(str); };
 
         return checkTable(first_prefix) && checkTable(first_suffix) && checkTable(second_prefix) &&
                checkTable(second_suffix);

include/util/indexed_data.hpp

@@ -315,9 +315,8 @@ template <typename GroupBlockPolicy, storage::Ownership Ownership> struct Indexe
             values_byte_iter = block.WriteBlockPrefix(curr, next, values_byte_iter);
             std::advance(next, std::min<diff_type>(1, std::distance(next, sentinel)));
 
-            auto to_bytes = [&](const auto &data) {
-                values_byte_iter = std::copy_n(&data, sizeof(ValueType), values_byte_iter);
-            };
+            auto to_bytes = [&](const auto &data)
+            { values_byte_iter = std::copy_n(&data, sizeof(ValueType), values_byte_iter); };
             std::copy(data + *curr,
                       data + *next,
                       boost::make_function_output_iterator(std::cref(to_bytes)));

include/util/integer_range.hpp

@@ -43,11 +43,10 @@ class integer_iterator : public boost::iterator_facade<integer_iterator<Integer>
 
     difference_type distance_to(const integer_iterator &other) const
     {
-        return std::is_signed<value_type>::value
-                   ? (other.m_value - m_value)
-                   : (other.m_value >= m_value)
-                         ? static_cast<difference_type>(other.m_value - m_value)
-                         : -static_cast<difference_type>(m_value - other.m_value);
+        return std::is_signed<value_type>::value ? (other.m_value - m_value)
+               : (other.m_value >= m_value)
+                   ? static_cast<difference_type>(other.m_value - m_value)
+                   : -static_cast<difference_type>(m_value - other.m_value);
     }
 
     friend class ::boost::iterator_core_access;

include/util/lua_util.hpp

@@ -8,7 +8,7 @@ extern "C"
 #include <lualib.h>
 }
 
-#include <boost/filesystem/convenience.hpp>
+#include <boost/filesystem.hpp>
 
 #include <iostream>
 #include <string>

include/util/node_based_graph.hpp

@@ -79,7 +79,8 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
     auto edges_list = directedEdgesFromCompressed<NodeBasedDynamicGraph::InputEdge>(
         input_edge_list,
         [](NodeBasedDynamicGraph::InputEdge &output_edge,
-           const extractor::NodeBasedEdge &input_edge) {
+           const extractor::NodeBasedEdge &input_edge)
+        {
             output_edge.data.weight = input_edge.weight;
             output_edge.data.duration = input_edge.duration;
             output_edge.data.distance = input_edge.distance;

include/util/opening_hours.hpp

@@ -193,23 +193,20 @@ struct OpeningHours
                && (times.empty() ||
                    std::any_of(times.begin(),
                                times.end(),
-                               [&time, &use_curr_day, &use_next_day](const auto &x) {
-                                   return x.IsInRange(time, use_curr_day, use_next_day);
-                               }))
+                               [&time, &use_curr_day, &use_next_day](const auto &x)
+                               { return x.IsInRange(time, use_curr_day, use_next_day); }))
                // .. and if weekdays are not specified or matches weekdays range
                && (weekdays.empty() ||
                    std::any_of(weekdays.begin(),
                                weekdays.end(),
-                               [&time, use_curr_day, use_next_day](const auto &x) {
-                                   return x.IsInRange(time, use_curr_day, use_next_day);
-                               }))
+                               [&time, use_curr_day, use_next_day](const auto &x)
+                               { return x.IsInRange(time, use_curr_day, use_next_day); }))
                // .. and if month-day ranges are not specified or is in any month-day range
                && (monthdays.empty() ||
                    std::any_of(monthdays.begin(),
                                monthdays.end(),
-                               [&time, use_curr_day, use_next_day](const auto &x) {
-                                   return x.IsInRange(time, use_curr_day, use_next_day);
-                               }));
+                               [&time, use_curr_day, use_next_day](const auto &x)
+                               { return x.IsInRange(time, use_curr_day, use_next_day); }));
     }
 
     std::vector<TimeSpan> times;

include/util/query_heap.hpp

@@ -3,12 +3,12 @@
 
 #include <boost/assert.hpp>
 #include <boost/heap/d_ary_heap.hpp>
-#include <boost/optional.hpp>
 
 #include <algorithm>
 #include <cstdint>
 #include <limits>
 #include <map>
+#include <optional>
 #include <unordered_map>
 #include <vector>
 
@@ -290,26 +290,26 @@ class QueryHeap
         return inserted_nodes[index].node == node;
     }
 
-    boost::optional<HeapNode &> GetHeapNodeIfWasInserted(const NodeID node)
+    HeapNode *GetHeapNodeIfWasInserted(const NodeID node)
     {
         const auto index = node_index.peek_index(node);
         if (index >= static_cast<decltype(index)>(inserted_nodes.size()) ||
             inserted_nodes[index].node != node)
         {
-            return {};
+            return nullptr;
         }
-        return inserted_nodes[index];
+        return &inserted_nodes[index];
     }
 
-    boost::optional<const HeapNode &> GetHeapNodeIfWasInserted(const NodeID node) const
+    const HeapNode *GetHeapNodeIfWasInserted(const NodeID node) const
     {
         const auto index = node_index.peek_index(node);
         if (index >= static_cast<decltype(index)>(inserted_nodes.size()) ||
             inserted_nodes[index].node != node)
         {
-            return {};
+            return nullptr;
         }
-        return inserted_nodes[index];
+        return &inserted_nodes[index];
     }
 
     NodeID Min() const
@@ -345,9 +345,9 @@ class QueryHeap
     void DeleteAll()
     {
         auto const none_handle = heap.s_handle_from_iterator(heap.end());
-        std::for_each(inserted_nodes.begin(), inserted_nodes.end(), [&none_handle](auto &node) {
-            node.handle = none_handle;
-        });
+        std::for_each(inserted_nodes.begin(),
+                      inserted_nodes.end(),
+                      [&none_handle](auto &node) { node.handle = none_handle; });
         heap.clear();
     }
 

include/util/range_table.hpp

@@ -64,7 +64,8 @@ template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
     // construct table from length vector
     template <typename VectorT> explicit RangeTable(const VectorT &lengths)
     {
-        const unsigned number_of_blocks = [&lengths]() {
+        const unsigned number_of_blocks = [&lengths]()
+        {
             unsigned num = (lengths.size() + 1) / (BLOCK_SIZE + 1);
             if ((lengths.size() + 1) % (BLOCK_SIZE + 1) != 0)
             {

include/util/rectangle.hpp

@@ -3,7 +3,6 @@
 
 #include "util/coordinate.hpp"
 #include "util/coordinate_calculation.hpp"
-
 #include <boost/assert.hpp>
 
 #include <limits>
@@ -168,6 +167,18 @@ struct RectangleInt2D
                min_lat != FixedLatitude{std::numeric_limits<std::int32_t>::max()} &&
                max_lat != FixedLatitude{std::numeric_limits<std::int32_t>::min()};
     }
+
+    static RectangleInt2D ExpandMeters(const Coordinate &coordinate, const double meters)
+    {
+        const double lat_offset = meters / coordinate_calculation::METERS_PER_DEGREE_LAT;
+        const double lon_offset =
+            meters / coordinate_calculation::metersPerLngDegree(coordinate.lat);
+
+        return RectangleInt2D{coordinate.lon - toFixed(FloatLongitude{lon_offset}),
+                              coordinate.lon + toFixed(FloatLongitude{lon_offset}),
+                              coordinate.lat - toFixed(FloatLatitude{lat_offset}),
+                              coordinate.lat + toFixed(FloatLatitude{lat_offset})};
+    }
 };
 } // namespace osrm::util