Debug osrm-extract CI crash

.clang-tidy

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

.github/workflows/osrm-backend.yml

@@ -170,49 +170,52 @@ jobs:
             continue-on-error: false
             node: 20
             runs-on: ubuntu-24.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Debug
             CCOMPILER: gcc-13
             CUCUMBER_TIMEOUT: 20000
             CXXCOMPILER: g++-13
             ENABLE_COVERAGE: ON
 
-          - name: clang-18-debug-asan-ubsan
+          - name: clang-15-debug-asan-ubsan
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
             CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
             ENABLE_SANITIZER: ON
             TARGET_ARCH: x86_64-asan-ubsan
             OSRM_CONNECTION_RETRIES: 10
             OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
 
-          - name: clang-18-release
+          - name: clang-15-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
-          - name: clang-18-debug
+          - name: clang-15-debug
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
           - name: clang-18-debug-clang-tidy
             continue-on-error: false
             node: 18
             runs-on: ubuntu-24.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Debug
             CCOMPILER: clang-18
             CXXCOMPILER: clang++-18
@@ -220,51 +223,52 @@ jobs:
             ENABLE_CLANG_TIDY: ON
 
 
-          - name: clang-17-release
+          - name: clang-14-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-17
+            CCOMPILER: clang-14
-            CXXCOMPILER: clang++-17
+            CXXCOMPILER: clang++-14
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
-          - name: clang-16-release
+          - name: clang-13-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-16
+            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-16
+            CXXCOMPILER: clang++-13
             CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
 
           - name: conan-linux-debug-asan-ubsan
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
             ENABLE_CONAN: ON
             ENABLE_SANITIZER: ON
-            ENABLE_LTO: OFF
 
           - name: conan-linux-release
             continue-on-error: false
             node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Release
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
             ENABLE_CONAN: ON
-            ENABLE_LTO: OFF
 
           - name: gcc-14-release
             continue-on-error: false
             node: 20
             runs-on: ubuntu-24.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Release
             CCOMPILER: gcc-14
             CXXCOMPILER: g++-14
@@ -274,6 +278,7 @@ jobs:
             continue-on-error: false
             node: 20
             runs-on: ubuntu-24.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Release
             CCOMPILER: gcc-13
             CXXCOMPILER: g++-13
@@ -283,6 +288,7 @@ jobs:
             continue-on-error: false
             node: 20
             runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
             BUILD_TYPE: Release
             CCOMPILER: gcc-12
             CXXCOMPILER: g++-12
@@ -292,10 +298,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TYPE: Release
-            CCOMPILER: clang-16
+            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-16
+            CXXCOMPILER: clang++-13
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -303,10 +309,10 @@ jobs:
             build_node_package: true
             continue-on-error: false
             node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
             BUILD_TYPE: Debug
-            CCOMPILER: clang-16
+            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-16
+            CXXCOMPILER: clang++-13
             ENABLE_CONAN: ON
             NODE_PACKAGE_TESTS_ONLY: ON
 
@@ -338,6 +344,7 @@ jobs:
     continue-on-error: ${{ matrix.continue-on-error }}
     runs-on: ${{ matrix.runs-on }}
     env:
+      BUILD_TOOLS: ${{ matrix.BUILD_TOOLS }}
       BUILD_TYPE: ${{ matrix.BUILD_TYPE }}
       BUILD_SHARED_LIBS: ${{ matrix.BUILD_SHARED_LIBS }}
       CCOMPILER: ${{ matrix.CCOMPILER }}
@@ -354,7 +361,6 @@ jobs:
       TARGET_ARCH: ${{ matrix.TARGET_ARCH }}
       OSRM_CONNECTION_RETRIES: ${{ matrix.OSRM_CONNECTION_RETRIES }}
       OSRM_CONNECTION_EXP_BACKOFF_COEF: ${{ matrix.OSRM_CONNECTION_EXP_BACKOFF_COEF }}
-      ENABLE_LTO: ${{ matrix.ENABLE_LTO }}
     steps:
     - uses: actions/checkout@v4
     - name: Build machine architecture
@@ -482,13 +488,6 @@ jobs:
         tar zxvf onetbb.tgz
         sudo cp -a oneapi-tbb-${TBB_VERSION}/lib/. /usr/local/lib/
         sudo cp -a oneapi-tbb-${TBB_VERSION}/include/. /usr/local/include/
-    - name: Add Clang 18 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Clang 18
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.CCOMPILER == 'clang-18' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_linux_amd64 -O /usr/bin/yq && sudo chmod +x /usr/bin/yq
-
-        conan config init
-        yq eval '.compiler.clang.version += ["18"]' -i "$HOME/.conan/settings.yml"
     - name: Prepare build
       run: |
         mkdir ${OSRM_BUILD_DIR}
@@ -520,8 +519,8 @@ jobs:
                  -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
                  -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
                  -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
+                 -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
                  -DENABLE_CCACHE=ON \
-                 -DENABLE_LTO=${ENABLE_LTO:-ON} \
                  -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
         make --jobs=${JOBS}
 
@@ -536,6 +535,13 @@ jobs:
           echo "PKG_CONFIG_PATH=${OSRM_INSTALL_DIR}/lib/pkgconfig" >> $GITHUB_ENV
         fi
         popd
+    - name: Build example
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      run: |
+        mkdir example/build && pushd example/build
+        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
+        make --jobs=${JOBS}
+        popd
     - name: Run all tests
       if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
       run: |
@@ -543,6 +549,7 @@ jobs:
 
         # macOS SIP strips the linker path. Reset this inside the running shell
         export LD_LIBRARY_PATH=${{ env.LD_LIBRARY_PATH }}
+        ./example/build/osrm-example test/data/mld/monaco.osrm
 
         # All tests assume to be run from the build directory
         pushd ${OSRM_BUILD_DIR}
@@ -631,12 +638,12 @@ jobs:
   benchmarks:
     if: github.event_name == 'pull_request'
     needs: [format-taginfo-docs]
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     env:
-      CCOMPILER: clang-16
+      CCOMPILER: clang-13
-      CXXCOMPILER: clang++-16
+      CXXCOMPILER: clang++-13
-      CC: clang-16
+      CC: clang-13
-      CXX: clang++-16
+      CXX: clang++-13
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       PR_NUMBER: ${{ github.event.pull_request.number }}
       GITHUB_REPOSITORY: ${{ github.repository }}
@@ -671,7 +678,7 @@ jobs:
           path: pr
       - name: Install dependencies
         run: | 
-          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" --break-system-packages
+          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
           sudo apt-get update -y && sudo apt-get install ccache
       - name: Prepare data
         run: |
@@ -716,34 +723,14 @@ jobs:
           make -j$(nproc) benchmarks
           cd ..
           make -C test/data 
-      # we run benchmarks in tmpfs to avoid impact of disk IO
-      - name: Create folder for tmpfs 
-        run: mkdir -p /opt/benchmarks
       - name: Run PR Benchmarks 
         run: |
-          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
+          ./pr/scripts/ci/run_benchmarks.sh -f $(pwd)/pr -r $(pwd)/pr_results -s $(pwd)/pr -b $(pwd)/pr/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          cp -rf pr/build /opt/benchmarks/build
-          mkdir -p /opt/benchmarks/test
-          cp -rf pr/test/data /opt/benchmarks/test/data
-          cp -rf pr/profiles /opt/benchmarks/profiles
-
-          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount /opt/benchmarks
       - name: Run Base Benchmarks
         run: |
-          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
-          cp -rf base/build /opt/benchmarks/build
-          mkdir -p /opt/benchmarks/test
-          cp -rf base/test/data /opt/benchmarks/test/data
-          cp -rf base/profiles /opt/benchmarks/profiles
-
-          # TODO: remove it when base branch will have this file at needed location
-          if [ ! -f /opt/benchmarks/test/data/portugal_to_korea.json ]; then
-            cp base/src/benchmarks/portugal_to_korea.json /opt/benchmarks/test/data/portugal_to_korea.json
-          fi
           # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
-          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          ./pr/scripts/ci/run_benchmarks.sh -f $(pwd)/base -r $(pwd)/base_results -s $(pwd)/pr -b $(pwd)/base/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount /opt/benchmarks
+
       - name: Post Benchmark Results
         run: |
           python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results

.github/workflows/stale.yml

@@ -1,9 +1,5 @@
 name: 'Close stale issues'
 on:
-  # NOTE: uncomment if you want to test changes to this file in PRs CI
-  # pull_request:
-  #   branches:
-  #     - master
   schedule:
     - cron: '30 1 * * *' # every day at 1:30am
 permissions:
@@ -16,7 +12,6 @@ jobs:
     steps:
       - uses: actions/stale@v9
         with:
-          operations-per-run: 3000
           stale-issue-message: 'This issue seems to be stale. It will be closed in 30 days if no further activity occurs.'
           stale-pr-message: 'This PR seems to be stale. Is it still relevant?'
           days-before-issue-stale: 180 # 6 months

.gitignore

@@ -43,6 +43,7 @@ Thumbs.db
 #######################
 /_build*
 /build/
+/example/build/
 /test/data/monaco.osrm*
 /test/data/ch
 /test/data/corech

CHANGELOG.md

@@ -24,14 +24,6 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
-      - CHANGED: Add .reserve(...) to assembleGeometry function. [#6983](https://github.com/Project-OSRM/osrm-backend/pull/6983)
-      - CHANGED: Get rid of boost::optional leftovers. [#6977](https://github.com/Project-OSRM/osrm-backend/pull/6977)
-      - CHANGED: Use Link Time Optimisation whenever possible. [#6967](https://github.com/Project-OSRM/osrm-backend/pull/6967)
-      - CHANGED: Use struct instead of tuple to define UnpackedPath. [#6974](https://github.com/Project-OSRM/osrm-backend/pull/6974)
-      - CHANGED: Micro performance optimisation in map matching. [#6976](https://github.com/Project-OSRM/osrm-backend/pull/6976)
-      - CHANGED: Re-use priority queue in StaticRTree. [#6952](https://github.com/Project-OSRM/osrm-backend/pull/6952)
-      - CHANGED: Optimise encodePolyline function. [#6940](https://github.com/Project-OSRM/osrm-backend/pull/6940)
-      - CHANGED: Avoid reallocations in base64 encoding. [#6951](https://github.com/Project-OSRM/osrm-backend/pull/6951)
       - CHANGED: Get rid of unused Boost dependencies. [#6960](https://github.com/Project-OSRM/osrm-backend/pull/6960)
       - CHANGED: Apply micro-optimisation for Table & Trip APIs. [#6949](https://github.com/Project-OSRM/osrm-backend/pull/6949)
       - CHANGED: Apply micro-optimisation for Route API. [#6948](https://github.com/Project-OSRM/osrm-backend/pull/6948)

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.18)
-project(OSRM C CXX)
+
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -10,12 +10,6 @@ Please create a directory and run cmake from there, passing the path to this sou
 This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
 endif()
 
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  message(STATUS "Building on a 64 bit system")
-else()
-  message(FATAL_ERROR "Building on a 32 bit system is not supported")
-endif()
-
 # detect if this is included as subproject and if so expose
 # some variables to its parent scope
 get_directory_property(BUILD_AS_SUBPROJECT PARENT_DIRECTORY)
@@ -28,37 +22,41 @@ if (NOT WIN32 AND NOT DEFINED ENV{OSRM_BUILD_DIR})
   set(ENV{OSRM_BUILD_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 endif()
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
-option(BUILD_PACKAGE "Build OSRM package" OFF)
-option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
-option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
-option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
 option(ENABLE_CONAN "Use conan for dependencies" OFF)
-option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
+option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
+option(BUILD_TOOLS "Build OSRM tools" OFF)
+option(BUILD_PACKAGE "Build OSRM package" OFF)
+option(BUILD_ROUTED "Build osrm-routed HTTP server" ON)
+option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
-option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
+option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
-option(ENABLE_LTO "Use Link Time Optimisation" ON)
-option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
 option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
+option(ENABLE_LTO "Use LTO if available" OFF)
+option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
+option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
+option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
 
 if (ENABLE_CLANG_TIDY)
-  find_program(CLANG_TIDY_COMMAND NAMES clang-tidy REQUIRED)
+  find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
-  message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
+  if(NOT CLANG_TIDY_COMMAND)
-  set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
+    message(FATAL_ERROR "ENABLE_CLANG_TIDY is ON but clang-tidy is not found!")
-endif()
-
-if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
-  if(LTO_SUPPORTED)
-      message(STATUS "IPO / LTO enabled")
-      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
   else()
-      message(FATAL_ERROR "IPO / LTO not supported: <${error}>")
+    message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
+    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
   endif()
 endif()
 
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+# be compatible with version handling before cmake 3.x
+if (POLICY CMP0057)
+  cmake_policy(SET CMP0057 NEW)
+endif()
+if (POLICY CMP0074)
+  cmake_policy(SET CMP0074 NEW)
+endif()
+project(OSRM C CXX)
+
 # add @loader_path/$ORIGIN to rpath to make binaries relocatable
 if (APPLE)
   set(CMAKE_BUILD_RPATH "@loader_path")
@@ -75,14 +73,14 @@ sbeParseJson(packagejson packagejsonraw)
 # This regex is not strict enough, but the correct one is too complicated for cmake matching.
 # https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
 if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)([-+][0-9a-zA-Z.-]+)?$")
-  set(OSRM_VERSION_MAJOR            ${CMAKE_MATCH_1})
+    set(OSRM_VERSION_MAJOR            ${CMAKE_MATCH_1})
-  set(OSRM_VERSION_MINOR            ${CMAKE_MATCH_2})
+    set(OSRM_VERSION_MINOR            ${CMAKE_MATCH_2})
-  set(OSRM_VERSION_PATCH            ${CMAKE_MATCH_3})
+    set(OSRM_VERSION_PATCH            ${CMAKE_MATCH_3})
-  set(OSRM_VERSION_PRERELEASE_BUILD ${CMAKE_MATCH_4})
+    set(OSRM_VERSION_PRERELEASE_BUILD ${CMAKE_MATCH_4})
 
-  set(OSRM_VERSION packagejson.version)
+    set(OSRM_VERSION packagejson.version)
 else()
-  message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible label, but found ${packagejson.version}")
+    message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible label, but found ${packagejson.version}")
 endif()
 
 if (MSVC)
@@ -114,6 +112,12 @@ include(CheckCXXCompilerFlag)
 include(FindPackageHandleStandardArgs)
 include(GNUInstallDirs)
 
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+  message(STATUS "Building on a 64 bit system")
+else()
+  message(FATAL_ERROR "Building on a 32 bit system is not supported")
+endif()
+
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
 include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)
@@ -134,6 +138,7 @@ file(GLOB UpdaterGlob src/updater/*.cpp)
 file(GLOB StorageGlob src/storage/*.cpp)
 file(GLOB ServerGlob src/server/*.cpp src/server/**/*.cpp)
 file(GLOB EngineGlob src/engine/*.cpp src/engine/**/*.cpp)
+file(GLOB ErrorcodesGlob src/osrm/errorcodes.cpp)
 
 add_library(UTIL OBJECT ${UtilGlob})
 add_library(EXTRACTOR OBJECT ${ExtractorGlob})
@@ -144,11 +149,14 @@ add_library(CONTRACTOR OBJECT ${ContractorGlob})
 add_library(UPDATER OBJECT ${UpdaterGlob})
 add_library(STORAGE OBJECT ${StorageGlob})
 add_library(ENGINE OBJECT ${EngineGlob})
-add_library(SERVER OBJECT ${ServerGlob})
+
+if (BUILD_ROUTED)
+  add_library(SERVER OBJECT ${ServerGlob})
+  add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
+endif()
 
 set_target_properties(UTIL PROPERTIES LINKER_LANGUAGE CXX)
 
-add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
 add_executable(osrm-extract src/tools/extract.cpp)
 add_executable(osrm-partition src/tools/partition.cpp)
 add_executable(osrm-customize src/tools/customize.cpp)
@@ -200,6 +208,17 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -ggdb")
 endif()
 
+if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
+  if(LTO_SUPPORTED)
+      message(STATUS "IPO / LTO enabled")
+      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  else()
+      message(WARNING "IPO / LTO not supported: <${error}>")
+  endif()
+endif()
+
 set(MAYBE_COVERAGE_LIBRARIES "")
 if (ENABLE_COVERAGE)
   if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
@@ -271,7 +290,6 @@ include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})
 
 add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
 set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
-
 target_no_warning(MICROTAR unused-variable)
 target_no_warning(MICROTAR format)
 
@@ -458,7 +476,9 @@ target_link_libraries(osrm-extract osrm_extract ${Boost_PROGRAM_OPTIONS_LIBRARY}
 target_link_libraries(osrm-partition osrm_partition ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_link_libraries(osrm-customize osrm_customize ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_link_libraries(osrm-contract osrm_contract ${Boost_PROGRAM_OPTIONS_LIBRARY})
-target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
+if (BUILD_ROUTED)
+  target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
+endif()
 
 set(EXTRACTOR_LIBRARIES
     ${BZIP2_LIBRARIES}
@@ -532,13 +552,18 @@ target_link_libraries(osrm_partition ${PARTITIONER_LIBRARIES})
 target_link_libraries(osrm_customize ${CUSTOMIZER_LIBRARIES} osrm_update osrm_store)
 target_link_libraries(osrm_store ${STORAGE_LIBRARIES})
 
+# BUILD_COMPONENTS
 add_executable(osrm-components src/tools/components.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 target_link_libraries(osrm-components ${TBB_LIBRARIES} ${BOOST_BASE_LIBRARIES} ${UTIL_LIBRARIES})
 install(TARGETS osrm-components DESTINATION bin)
 
-add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
+if(BUILD_TOOLS)
-target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES} ${TBB_LIBRARIES})
+  message(STATUS "Activating OSRM internal tools")
-install(TARGETS osrm-io-benchmark DESTINATION bin)
+  add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
+  target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES} ${TBB_LIBRARIES})
+
+  install(TARGETS osrm-io-benchmark DESTINATION bin)
+endif()
 
 if (ENABLE_ASSERTIONS)
   message(STATUS "Enabling assertions")
@@ -557,14 +582,47 @@ set_property(TARGET osrm-extract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-partition PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-contract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+if (BUILD_ROUTED)
+  set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+endif()
 
+file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
+file(GLOB LibraryGlob include/osrm/*.hpp)
+file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
+set(ApiHeader include/engine/api/base_result.hpp)
+set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/bearing.hpp include/engine/approach.hpp include/engine/phantom_node.hpp)
+set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/alias.hpp include/util/exception.hpp include/util/bearing.hpp)
+set(ExtractorHeader include/extractor/extractor.hpp include/storage/io_config.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
+set(PartitionerHeader include/partitioner/partitioner.hpp include/partitioner/partitioner_config.hpp)
+set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)
+set(StorageHeader include/storage/storage.hpp include/storage/io_config.hpp include/storage/storage_config.hpp)
+install(FILES ${EngineHeader} DESTINATION include/osrm/engine)
+install(FILES ${UtilHeader} DESTINATION include/osrm/util)
+install(FILES ${StorageHeader} DESTINATION include/osrm/storage)
+install(FILES ${ExtractorHeader} DESTINATION include/osrm/extractor)
+install(FILES ${PartitionerHeader} DESTINATION include/osrm/partitioner)
+install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
+install(FILES ${LibraryGlob} DESTINATION include/osrm)
+install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
+install(FILES ${ApiHeader} DESTINATION include/osrm/engine/api)
+install(FILES ${FlatbuffersGlob} DESTINATION include/flatbuffers)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)
 install(TARGETS osrm-customize DESTINATION bin)
 install(TARGETS osrm-contract DESTINATION bin)
 install(TARGETS osrm-datastore DESTINATION bin)
-install(TARGETS osrm-routed DESTINATION bin)
+if (BUILD_ROUTED)
+  install(TARGETS osrm-routed DESTINATION bin)
+endif()
+install(TARGETS osrm DESTINATION lib)
+install(TARGETS osrm_extract DESTINATION lib)
+install(TARGETS osrm_partition DESTINATION lib)
+install(TARGETS osrm_customize DESTINATION lib)
+install(TARGETS osrm_update DESTINATION lib)
+install(TARGETS osrm_contract DESTINATION lib)
+install(TARGETS osrm_store DESTINATION lib)
+install(TARGETS osrm_guidance DESTINATION lib)
+
 
 # Install profiles and support library to /usr/local/share/osrm/profiles by default
 set(DefaultProfilesDir profiles)
@@ -575,6 +633,8 @@ set(DefaultProfilesDir data)
 install(DIRECTORY ${DefaultProfilesDir} DESTINATION share/osrm)
 
 # Setup exporting variables for pkgconfig and subproject
+#
+
 if(BUILD_PACKAGE)
   include(CPackConfig)
   include(CPack)
@@ -651,6 +711,7 @@ if (ENABLE_NODE_BINDINGS)
   add_subdirectory(src/nodejs)
 endif()
 
+
 if (ENABLE_FUZZING)
   # Requires libosrm being built with sanitizers; make configurable and default to ubsan
   set(FUZZ_SANITIZER "undefined" CACHE STRING "Sanitizer to be used for Fuzz testing")
@@ -684,3 +745,4 @@ foreach(header ${headers_to_check})
 endforeach()
 add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
 set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
+

cmake/warnings.cmake

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

docker/Dockerfile-alpine

@@ -27,10 +27,11 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
     cd build && \
     BUILD_TYPE="Release" && \
     ENABLE_ASSERTIONS="Off" && \
+    BUILD_TOOLS="Off" && \
     case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DENABLE_LTO=OFF && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
     make -j${NPROC} install && \
     cd ../profiles && \
     cp -r * /opt && \

docker/Dockerfile-debian

@@ -21,7 +21,7 @@ COPY . /src
 WORKDIR /src
 
 RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized -Wno-stringop-overflow" && \
+    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized" && \
     echo "Building OSRM ${DOCKER_TAG}" && \
     git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
     echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
@@ -29,10 +29,11 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
     cd build && \
     BUILD_TYPE="Release" && \
     ENABLE_ASSERTIONS="Off" && \
+    BUILD_TOOLS="Off" && \
     case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DENABLE_LTO=On && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
     make -j${NPROC} install && \
     cd ../profiles && \
     cp -r * /opt && \

docs/libosrm.md

@@ -0,0 +1,33 @@
+## Introduction
+
+OSRM can be used as a library (libosrm) via C++ instead of using it through the HTTP interface and `osrm-routed`. This allows for fine-tuning OSRM and has much less overhead. Here is a quick introduction into how to use `libosrm` in the upcoming v5 release.
+
+Take a look at the example code that lives in the [example directory](https://github.com/Project-OSRM/osrm-backend/tree/master/example). Here is all you ever wanted to know about `libosrm`, that is a short description of what the types do and where to find documentation on it:
+
+## Important interface objects
+
+- [`EngineConfig`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/engine_config.hpp) - for initializing an OSRM instance we can configure certain properties and constraints. E.g. the storage config is the base path such as `france.osm.osrm` from which we derive and load `france.osm.osrm.*` auxiliary files. This also lets you set constraints such as the maximum number of locations allowed for specific services.
+
+- [`OSRM`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/osrm/osrm.hpp) - this is the main Routing Machine type with functions such as `Route` and `Table`. You initialize it with a `EngineConfig`. It does all the heavy lifting for you. Each function takes its own parameters, e.g. the `Route` function takes `RouteParameters`, and a out-reference to a JSON result that gets filled. The return value is a `Status`, indicating error or success.
+
+- [`Status`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/status.hpp) - this is a type wrapping `Error` or `Ok` for indicating error or success, respectively.
+
+- [`TableParameters`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/api/table_parameters.hpp) - this is an example of parameter types the Routing Machine functions expect. In this case `Table` expects its own parameters as `TableParameters`. You can see it wrapping two vectors, sources and destinations --- these are indices into your coordinates for the table service to construct a matrix from (empty sources or destinations means: use all of them). If you ask yourself where coordinates come from, you can see `TableParameters` inheriting from `BaseParameters`.
+
+- [`BaseParameter`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/api/base_parameters.hpp) - this most importantly holds coordinates (and a few other optional properties that you don't need for basic usage); the specific parameter types inherit from `BaseParameters` to get these member attributes. That means your `TableParameters` type has `coordinates`, `sources` and `destination` member attributes (and a few other that we ignore for now).
+
+- [`Coordinate`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/util/coordinate.hpp) - this is a wrapper around a (longitude, latitude) pair. We really don't care about (lon,lat) vs (lat, lon) but we don't want you to accidentally mix them up, so both latitude and longitude are strictly typed wrappers around integers (fixed notation such as `13423240`) and floating points (floating notation such as `13.42324`).
+
+- [Parameters for other services](https://github.com/Project-OSRM/osrm-backend/tree/master/include/engine/api) - here are all other `*Parameters` you need for other Routing Machine services.
+
+- [JSON](https://github.com/Project-OSRM/osrm-backend/blob/master/include/util/json_container.hpp) - this is a sum type resembling JSON. The Routing Machine service functions take a out-ref to a JSON result and fill it accordingly. It is currently implemented using [mapbox/variant](https://github.com/mapbox/variant) which is similar to [Boost.Variant](http://www.boost.org/doc/libs/1_55_0/doc/html/variant.html). There are two ways to work with this sum type: either provide a visitor that acts on each type on visitation or use the `get` function in case you're sure about the structure. The JSON structure is written down in the [HTTP API](#http-api).
+
+## Example
+
+See [the example folder](https://github.com/Project-OSRM/osrm-backend/tree/master/example) in the OSRM repository.
+
+## Workflow
+
+ - Create an `OSRM` instance initialized with a `EngineConfig`
+ - Call the service function on the `OSRM` object providing service specific `*Parameters`
+ - Check the return code and use the JSON result

example/CMakeLists.txt

@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.18)
+
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
+  message(FATAL_ERROR "In-source builds are not allowed.
+Please create a directory and run cmake from there, passing the path to this source directory as the last argument.
+This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
+endif()
+
+if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+project(osrm-example C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+  message(STATUS "Building on a 64 bit system")
+else()
+  message(STATUS "Building on a 32 bit system")
+endif()
+
+link_directories(${LibOSRM_LIBRARY_DIRS})
+add_executable(osrm-example example.cpp)
+
+find_package(LibOSRM REQUIRED)
+
+target_link_libraries(osrm-example ${LibOSRM_LIBRARIES} ${LibOSRM_DEPENDENT_LIBRARIES})
+include_directories(SYSTEM ${LibOSRM_INCLUDE_DIRS})
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LibOSRM_CXXFLAGS}")

example/cmake/FindLibOSRM.cmake

@@ -0,0 +1,63 @@
+# - Try to find LibOSRM
+# Once done this will define
+#  LibOSRM_FOUND - System has LibOSRM
+#  LibOSRM_LIBRARIES - The libraries and ldflags needed to use LibOSRM
+#  LibOSRM_DEPENDENT_LIBRARIES - The libraries and ldflags need to link LibOSRM dependencies
+#  LibOSRM_LIBRARY_DIRS - The libraries paths needed to find LibOSRM
+#  LibOSRM_CXXFLAGS - Compiler switches required for using LibOSRM
+
+find_package(PkgConfig)
+pkg_search_module(PC_LibOSRM QUIET libosrm)
+
+function(JOIN VALUES GLUE OUTPUT)
+  string (REPLACE ";" "${GLUE}" _TMP_STR "${VALUES}")
+  set (${OUTPUT} "${_TMP_STR}" PARENT_SCOPE)
+endfunction()
+
+list(REMOVE_ITEM PC_LibOSRM_CFLAGS " ")
+JOIN("${PC_LibOSRM_CFLAGS}" " " output)
+
+set(LibOSRM_CXXFLAGS ${output})
+set(LibOSRM_LIBRARY_DIRS ${PC_LibOSRM_LIBRARY_DIRS})
+
+find_path(LibOSRM_INCLUDE_DIR osrm/osrm.hpp
+  PATH_SUFFIXES osrm include/osrm include
+  HINTS ${PC_LibOSRM_INCLUDEDIR} ${PC_LibOSRM_INCLUDE_DIRS}
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt)
+
+find_library(TEST_LibOSRM_STATIC_LIBRARY Names osrm.lib libosrm.a
+  PATH_SUFFIXES osrm lib/osrm lib
+  HINTS ${PC_LibOSRM_LIBDIR} ${PC_LibOSRM_LIBRARY_DIRS}
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt)
+find_library(TEST_LibOSRM_DYNAMIC_LIBRARY Names libosrm.dylib libosrm.so
+  PATH_SUFFIXES osrm lib/osrm lib
+  HINTS ${PC_LibOSRM_LIBDIR} ${PC_LibOSRM_LIBRARY_DIRS}
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt)
+
+set(LibOSRM_DEPENDENT_LIBRARIES ${PC_LibOSRM_STATIC_LDFLAGS})
+set(LibOSRM_LIBRARIES ${PC_LibOSRM_LDFLAGS})
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set LIBOSRM_FOUND to TRUE
+# if all listed variables are TRUE
+find_package_handle_standard_args(LibOSRM DEFAULT_MSG
+                                LibOSRM_LIBRARY_DIRS
+                                LibOSRM_CXXFLAGS
+                                LibOSRM_LIBRARIES
+                                LibOSRM_DEPENDENT_LIBRARIES
+                                LibOSRM_INCLUDE_DIR)

example/cmake/FindTBB.cmake

@@ -0,0 +1 @@
+../../cmake/FindTBB.cmake

example/example.cpp

@@ -0,0 +1,90 @@
+#include "osrm/match_parameters.hpp"
+#include "osrm/nearest_parameters.hpp"
+#include "osrm/route_parameters.hpp"
+#include "osrm/table_parameters.hpp"
+#include "osrm/trip_parameters.hpp"
+
+#include "osrm/coordinate.hpp"
+#include "osrm/engine_config.hpp"
+#include "osrm/json_container.hpp"
+
+#include "osrm/osrm.hpp"
+#include "osrm/status.hpp"
+
+#include <exception>
+#include <iostream>
+#include <string>
+#include <utility>
+
+#include <cstdlib>
+
+int main(int argc, const char *argv[])
+{
+    if (argc < 2)
+    {
+        std::cerr << "Usage: " << argv[0] << " data.osrm\n";
+        return EXIT_FAILURE;
+    }
+
+    using namespace osrm;
+
+    // Configure based on a .osrm base path, and no datasets in shared mem from osrm-datastore
+    EngineConfig config;
+
+    config.storage_config = {argv[1]};
+    config.use_shared_memory = false;
+
+    // We support two routing speed up techniques:
+    // - Contraction Hierarchies (CH): requires extract+contract pre-processing
+    // - Multi-Level Dijkstra (MLD): requires extract+partition+customize pre-processing
+    //
+    // config.algorithm = EngineConfig::Algorithm::CH;
+    config.algorithm = EngineConfig::Algorithm::MLD;
+
+    // Routing machine with several services (such as Route, Table, Nearest, Trip, Match)
+    const OSRM osrm{config};
+
+    // The following shows how to use the Route service; configure this service
+    RouteParameters params;
+
+    // Route in monaco
+    params.coordinates.push_back({util::FloatLongitude{7.419758}, util::FloatLatitude{43.731142}});
+    params.coordinates.push_back({util::FloatLongitude{7.419505}, util::FloatLatitude{43.736825}});
+
+    // Response is in JSON format
+    engine::api::ResultT result = json::Object();
+
+    // Execute routing request, this does the heavy lifting
+    const auto status = osrm.Route(params, result);
+
+    auto &json_result = std::get<json::Object>(result);
+    if (status == Status::Ok)
+    {
+        auto &routes = std::get<json::Array>(json_result.values["routes"]);
+
+        // Let's just use the first route
+        auto &route = std::get<json::Object>(routes.values.at(0));
+        const auto distance = std::get<json::Number>(route.values["distance"]).value;
+        const auto duration = std::get<json::Number>(route.values["duration"]).value;
+
+        // Warn users if extract does not contain the default coordinates from above
+        if (distance == 0 || duration == 0)
+        {
+            std::cout << "Note: distance or duration is zero. ";
+            std::cout << "You are probably doing a query outside of the OSM extract.\n\n";
+        }
+
+        std::cout << "Distance: " << distance << " meter\n";
+        std::cout << "Duration: " << duration << " seconds\n";
+        return EXIT_SUCCESS;
+    }
+    else if (status == Status::Error)
+    {
+        const auto code = std::get<json::String>(json_result.values["code"]).value;
+        const auto message = std::get<json::String>(json_result.values["message"]).value;
+
+        std::cout << "Code: " << code << "\n";
+        std::cout << "Message: " << code << "\n";
+        return EXIT_FAILURE;
+    }
+}

include/engine/api/base_parameters.hpp

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

include/engine/api/json_factory.hpp

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

include/engine/api/nearest_api.hpp

@@ -45,7 +45,7 @@ class NearestAPI final : public BaseAPI
                       flatbuffers::FlatBufferBuilder &fb_result) const
     {
         auto data_timestamp = facade.GetTimestamp();
-        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
+        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
         if (!data_timestamp.empty())
         {
             data_version_string = fb_result.CreateString(data_timestamp);

include/engine/api/route_api.hpp

@@ -184,10 +184,10 @@ class RouteAPI : public BaseAPI
         return builder.CreateVectorOfStructs(coordinates);
     }
 
-    std::optional<util::json::Value>
+    boost::optional<util::json::Value>
-    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
+    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
     {
-        std::optional<util::json::Value> json_geometry;
+        boost::optional<util::json::Value> json_geometry;
         if (annotations)
         {
             auto begin = annotations->begin();
@@ -720,7 +720,8 @@ class RouteAPI : public BaseAPI
         std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
 
         auto route = guidance::assembleRoute(legs);
-        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));
+        boost::optional<util::json::Value> json_overview =
+            MakeGeometry(MakeOverview(leg_geometries));
 
         std::vector<util::json::Value> step_geometries;
         const auto total_step_count =
@@ -996,10 +997,10 @@ class RouteAPI : public BaseAPI
         return result;
     }
 
-    std::optional<std::vector<Coordinate>>
+    boost::optional<std::vector<Coordinate>>
     MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
     {
-        std::optional<std::vector<Coordinate>> overview;
+        boost::optional<std::vector<Coordinate>> overview;
         if (parameters.overview != RouteParameters::OverviewType::False)
         {
             const auto use_simplification =

include/engine/api/route_parameters.hpp

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

include/engine/api/trip_parameters.hpp

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

include/engine/base64.hpp

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

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

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

include/engine/datafacade/datafacade_base.hpp

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

include/engine/engine_config.hpp

@@ -79,7 +79,7 @@ struct EngineConfig final
     int max_locations_map_matching = -1;
     double max_radius_map_matching = -1.0;
     int max_results_nearest = -1;
-    double default_radius = -1.0;
+    boost::optional<double> default_radius = -1.0;
     int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
     bool use_shared_memory = true;
     std::filesystem::path memory_file;

include/engine/geospatial_query.hpp

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

include/engine/guidance/assemble_geometry.hpp

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

include/engine/guidance/assemble_steps.hpp

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

include/engine/guidance/route_leg.hpp

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

include/engine/internal_route_result.hpp

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

include/engine/plugins/match.hpp

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

include/engine/plugins/nearest.hpp

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

include/engine/plugins/plugin_base.hpp

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

include/engine/plugins/table.hpp

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

include/engine/plugins/trip.hpp

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

include/engine/plugins/viaroute.hpp

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

include/engine/polyline_compressor.hpp

@@ -12,7 +12,7 @@ namespace osrm::engine
 {
 namespace detail
 {
-void encode(int number_to_encode, std::string &output);
+std::string encode(std::vector<int> &numbers);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                      std::string::const_iterator last);
 } // namespace detail
@@ -30,24 +30,27 @@ std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter
         return {};
     }
 
-    std::string output;
+    std::vector<int> delta_numbers;
-    // just a guess that we will need ~4 bytes per coordinate to avoid reallocations
+    BOOST_ASSERT(size > 0);
-    output.reserve(size * 4);
+    delta_numbers.reserve((size - 1) * 2);
-
     int current_lat = 0;
     int current_lon = 0;
-    for (auto it = begin; it != end; ++it)
+    std::for_each(
-    {
+        begin,
-        const int lat_diff =
+        end,
-            std::round(static_cast<int>(it->lat) * coordinate_to_polyline) - current_lat;
+        [&delta_numbers, &current_lat, &current_lon, coordinate_to_polyline](
-        const int lon_diff =
+            const util::Coordinate loc)
-            std::round(static_cast<int>(it->lon) * coordinate_to_polyline) - current_lon;
+        {
-        detail::encode(lat_diff, output);
+            const int lat_diff =
-        detail::encode(lon_diff, output);
+                std::round(static_cast<int>(loc.lat) * coordinate_to_polyline) - current_lat;
-        current_lat += lat_diff;
+            const int lon_diff =
-        current_lon += lon_diff;
+                std::round(static_cast<int>(loc.lon) * coordinate_to_polyline) - current_lon;
-    }
+            delta_numbers.emplace_back(lat_diff);
-    return output;
+            delta_numbers.emplace_back(lon_diff);
+            current_lat += lat_diff;
+            current_lon += lon_diff;
+        });
+    return detail::encode(delta_numbers);
 }
 
 // Decodes geometry from polyline format

include/engine/routing_algorithms.hpp

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

include/engine/routing_algorithms/map_matching.hpp

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

include/engine/routing_algorithms/routing_base.hpp

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

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -487,13 +487,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
 
 using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
-
+using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
-struct UnpackedPath
-{
-    EdgeWeight weight;
-    UnpackedNodes nodes;
-    UnpackedEdges edges;
-};
 
 template <typename Algorithm, typename Heap, typename... Args>
 std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
@@ -557,7 +551,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
         facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
     if (!searchResult)
     {
-        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
+        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
     }
 
     auto [middle, weight] = *searchResult;
@@ -601,27 +595,25 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
             forward_heap.Insert(source, {0}, {source});
             reverse_heap.Insert(target, {0}, {target});
 
-            auto unpacked_subpath = search(engine_working_data,
+            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
-                                           facade,
+                                                                         facade,
-                                           forward_heap,
+                                                                         forward_heap,
-                                           reverse_heap,
+                                                                         reverse_heap,
-                                           force_step_nodes,
+                                                                         force_step_nodes,
-                                           INVALID_EDGE_WEIGHT,
+                                                                         INVALID_EDGE_WEIGHT,
-                                           sublevel,
+                                                                         sublevel,
-                                           parent_cell_id);
+                                                                         parent_cell_id);
-            BOOST_ASSERT(!unpacked_subpath.edges.empty());
+            BOOST_ASSERT(!subpath_edges.empty());
-            BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
+            BOOST_ASSERT(subpath_nodes.size() > 1);
-            BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
+            BOOST_ASSERT(subpath_nodes.front() == source);
-            BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
+            BOOST_ASSERT(subpath_nodes.back() == target);
-            unpacked_nodes.insert(unpacked_nodes.end(),
+            unpacked_nodes.insert(
-                                  std::next(unpacked_subpath.nodes.begin()),
+                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
-                                  unpacked_subpath.nodes.end());
+            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
-            unpacked_edges.insert(
-                unpacked_edges.end(), unpacked_subpath.edges.begin(), unpacked_subpath.edges.end());
         }
     }
 
-    return {weight, std::move(unpacked_nodes), std::move(unpacked_edges)};
+    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
 }
 
 template <typename Algorithm, typename... Args>
@@ -662,15 +654,13 @@ inline void search(SearchEngineData<Algorithm> &engine_working_data,
                    const EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
     // TODO: change search calling interface to use unpacked_edges result
-    auto unpacked_path = search(engine_working_data,
+    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
-                                facade,
+                                                           facade,
-                                forward_heap,
+                                                           forward_heap,
-                                reverse_heap,
+                                                           reverse_heap,
-                                force_step_nodes,
+                                                           force_step_nodes,
-                                weight_upper_bound,
+                                                           weight_upper_bound,
-                                endpoints);
+                                                           endpoints);
-    weight = unpacked_path.weight;
-    unpacked_nodes = std::move(unpacked_path.nodes);
 }
 
 // TODO: refactor CH-related stub to use unpacked_edges

include/engine/routing_algorithms/shortest_path.hpp

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

include/engine/routing_algorithms/shortest_path_impl.hpp

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

include/nodejs/node_osrm_support.hpp

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

include/server/api/base_parameters_grammar.hpp

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

include/server/api/parameters_parser.hpp

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

include/server/api/url_parser.hpp

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

include/util/binary_heap.hpp

@@ -1,40 +0,0 @@
-#pragma once
-#include <algorithm>
-#include <boost/assert.hpp>
-#include <vector>
-
-namespace osrm::util
-{
-
-// in its essence it is std::priority_queue, but with `clear` method
-template <typename T> class BinaryHeap
-{
-  public:
-    bool empty() const { return heap_.empty(); }
-
-    const T &top() const
-    {
-        BOOST_ASSERT(!heap_.empty());
-        return heap_.front();
-    }
-
-    void pop()
-    {
-        BOOST_ASSERT(!heap_.empty());
-        std::pop_heap(heap_.begin(), heap_.end());
-        heap_.pop_back();
-    }
-
-    template <typename... Args> void emplace(Args &&...args)
-    {
-        heap_.emplace_back(std::forward<Args>(args)...);
-        std::push_heap(heap_.begin(), heap_.end());
-    }
-
-    void clear() { heap_.clear(); }
-
-  private:
-    std::vector<T> heap_;
-};
-
-} // namespace osrm::util

include/util/static_rtree.hpp

@@ -2,9 +2,7 @@
 #define STATIC_RTREE_HPP
 
 #include "storage/tar_fwd.hpp"
-#include "osrm/coordinate.hpp"
 #include "util/bearing.hpp"
-#include "util/binary_heap.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/deallocating_vector.hpp"
 #include "util/exception.hpp"
@@ -17,6 +15,8 @@
 #include "util/vector_view.hpp"
 #include "util/web_mercator.hpp"
 
+#include "osrm/coordinate.hpp"
+
 #include "storage/shared_memory_ownership.hpp"
 
 #include <boost/assert.hpp>
@@ -554,12 +554,9 @@ class StaticRTree
         auto projected_coordinate = web_mercator::fromWGS84(input_coordinate);
         Coordinate fixed_projected_coordinate{projected_coordinate};
 
-        // we re-use queue for each query to avoid re-allocating memory
-        static thread_local util::BinaryHeap<QueryCandidate> traversal_queue;
-
-        traversal_queue.clear();
         // initialize queue with root element
-        traversal_queue.emplace(QueryCandidate{0, TreeIndex{}});
+        std::priority_queue<QueryCandidate> traversal_queue;
+        traversal_queue.push(QueryCandidate{0, TreeIndex{}});
 
         while (!traversal_queue.empty())
         {
@@ -713,11 +710,10 @@ class StaticRTree
             // distance must be non-negative
             BOOST_ASSERT(0. <= squared_distance);
             BOOST_ASSERT(i < std::numeric_limits<std::uint32_t>::max());
-
+            traversal_queue.push(QueryCandidate{squared_distance,
-            traversal_queue.emplace(QueryCandidate{squared_distance,
+                                                leaf_id,
-                                                   leaf_id,
+                                                static_cast<std::uint32_t>(i),
-                                                   static_cast<std::uint32_t>(i),
+                                                Coordinate{projected_nearest}});
-                                                   Coordinate{projected_nearest}});
         }
     }
 
@@ -746,7 +742,7 @@ class StaticRTree
                 child.minimum_bounding_rectangle.GetMinSquaredDist(
                     fixed_projected_input_coordinate);
 
-            traversal_queue.emplace(QueryCandidate{
+            traversal_queue.push(QueryCandidate{
                 squared_lower_bound_to_element,
                 TreeIndex(parent.level + 1, child_index - m_tree_level_starts[parent.level + 1])});
         }

scripts/ci/e2e_benchmark.py

@@ -86,9 +86,9 @@ def bootstrap_confidence_interval(data, num_samples=1000, confidence_level=0.95)
     mean = np.mean(means)
     return mean, lower_bound, upper_bound
 
-def calculate_confidence_interval(data, min_is_best=True):
+def calculate_confidence_interval(data):
     mean, lower, upper = bootstrap_confidence_interval(data)
-    min_value = np.min(data) if min_is_best else np.max(data)
+    min_value = np.min(data)
     return mean, (upper - lower) / 2, min_value
 
 
@@ -117,7 +117,7 @@ def main():
 
 
     total_time, total_ci, total_best = calculate_confidence_interval(np.sum(all_times, axis=1))
-    ops_per_sec, ops_per_sec_ci, ops_per_sec_best = calculate_confidence_interval(float(all_times.shape[1]) / np.sum(all_times / 1000, axis=1), min_is_best=False)
+    ops_per_sec, ops_per_sec_ci, ops_per_sec_best = calculate_confidence_interval(float(all_times.shape[1]) / np.sum(all_times / 1000, axis=1))
     min_time, min_ci, _ = calculate_confidence_interval(np.min(all_times, axis=1))
     mean_time, mean_ci, _ = calculate_confidence_interval(np.mean(all_times, axis=1))
     median_time, median_ci, _ = calculate_confidence_interval(np.median(all_times, axis=1))

scripts/ci/run_benchmarks.sh

@@ -64,7 +64,7 @@ function run_benchmarks_for_folder {
     echo "Running alias"
     $BENCHMARKS_FOLDER/alias-bench > "$RESULTS_FOLDER/alias.bench"
     echo "Running json-render-bench"
-    $BENCHMARKS_FOLDER/json-render-bench  "$FOLDER/test/data/portugal_to_korea.json" > "$RESULTS_FOLDER/json-render.bench"
+    $BENCHMARKS_FOLDER/json-render-bench  "$FOLDER/src/benchmarks/portugal_to_korea.json" > "$RESULTS_FOLDER/json-render.bench"
     echo "Running packedvector-bench"
     $BENCHMARKS_FOLDER/packedvector-bench > "$RESULTS_FOLDER/packedvector.bench"
     echo "Running rtree-bench"

scripts/ci/windows-build.bat

@@ -62,7 +62,7 @@ SET test_region_ch=ch\monaco
 SET test_region_corech=corech\monaco
 SET test_region_mld=mld\monaco
 SET test_osm=%test_region%.osm.pbf
-COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm%
+COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm% 
 %CONFIGURATION%\osrm-extract.exe -p %PROJECT_DIR%\profiles\car.lua %test_osm%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 

src/benchmarks/bench.cpp

@@ -134,7 +134,6 @@ struct ConfidenceInterval
     double mean;
     double confidence;
     double min;
-    double max;
 };
 
 // Helper function to calculate the bootstrap confidence interval
@@ -162,10 +161,8 @@ ConfidenceInterval confidenceInterval(const std::vector<double> &data,
     double upper_bound = means[(int)((1 + confidence_level) / 2 * num_samples)];
     double mean = std::accumulate(means.begin(), means.end(), 0.0) / means.size();
 
-    ConfidenceInterval ci = {mean,
+    ConfidenceInterval ci = {
-                             (upper_bound - lower_bound) / 2,
+        mean, (upper_bound - lower_bound) / 2, *std::min_element(data.begin(), data.end())};
-                             *std::min_element(data.begin(), data.end()),
-                             *std::max_element(data.begin(), data.end())};
     return ci;
 }
 
@@ -263,7 +260,7 @@ std::ostream &operator<<(std::ostream &os, Statistics &statistics)
     ConfidenceInterval ops_ci = statistics.ops_per_sec();
 
     os << "ops: " << ops_ci.mean << " ± " << ops_ci.confidence << " ops/s. "
-       << "best: " << ops_ci.max << "ops/s." << std::endl;
+       << "best: " << ops_ci.min << "ops/s." << std::endl;
     os << "total: " << total_ci.mean << " ± " << total_ci.confidence << "ms. "
        << "best: " << total_ci.min << "ms." << std::endl;
     os << "avg: " << mean_ci.mean << " ± " << mean_ci.confidence << "ms" << std::endl;
@@ -360,8 +357,8 @@ void runRouteBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati
 
                       if (benchmark.radius)
                       {
-                          params.radiuses = std::vector<std::optional<double>>(
+                          params.radiuses = std::vector<boost::optional<double>>(
-                              params.coordinates.size(), std::make_optional(*benchmark.radius));
+                              params.coordinates.size(), boost::make_optional(*benchmark.radius));
                       }
 
                       engine::api::ResultT result = json::Object();

src/benchmarks/route.cpp

@@ -66,8 +66,8 @@ try
 
         if (benchmark.radius)
         {
-            params.radiuses = std::vector<std::optional<double>>(
+            params.radiuses = std::vector<boost::optional<double>>(
-                params.coordinates.size(), std::make_optional(*benchmark.radius));
+                params.coordinates.size(), boost::make_optional(*benchmark.radius));
         }
 
         TIMER_START(routes);

src/engine/api/json_factory.cpp

@@ -11,7 +11,7 @@
 #include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
-#include <optional>
+#include <boost/optional.hpp>
 
 #include <algorithm>
 #include <iterator>
@@ -215,7 +215,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo
 
 util::json::Object makeRoute(const guidance::Route &route,
                              util::json::Array legs,
-                             std::optional<util::json::Value> geometry,
+                             boost::optional<util::json::Value> geometry,
                              const char *weight_name)
 {
     util::json::Object json_route;

src/engine/engine_config.cpp

@@ -12,13 +12,15 @@ bool EngineConfig::IsValid() const
     const auto unlimited_or_more_than = [](const auto v, const auto limit)
     { return v == -1 || v > limit; };
 
-    const bool limits_valid = unlimited_or_more_than(max_locations_distance_table, 2) &&
+    const bool limits_valid =
-                              unlimited_or_more_than(max_locations_map_matching, 2) &&
+        unlimited_or_more_than(max_locations_distance_table, 2) &&
-                              unlimited_or_more_than(max_radius_map_matching, 0) &&
+        unlimited_or_more_than(max_locations_map_matching, 2) &&
-                              unlimited_or_more_than(max_locations_trip, 2) &&
+        unlimited_or_more_than(max_radius_map_matching, 0) &&
-                              unlimited_or_more_than(max_locations_viaroute, 2) &&
+        unlimited_or_more_than(max_locations_trip, 2) &&
-                              unlimited_or_more_than(max_results_nearest, 0) &&
+        unlimited_or_more_than(max_locations_viaroute, 2) &&
-                              unlimited_or_more_than(default_radius, 0) && max_alternatives >= 0;
+        unlimited_or_more_than(max_results_nearest, 0) &&
+        (!default_radius.has_value() || unlimited_or_more_than(*default_radius, 0)) &&
+        max_alternatives >= 0;
 
     return ((use_shared_memory && all_path_are_empty) || (use_mmap && storage_config.IsValid()) ||
             storage_config.IsValid()) &&

src/engine/plugins/match.cpp

@@ -194,7 +194,7 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
             tidied.parameters.radiuses.begin(),
             tidied.parameters.radiuses.end(),
             search_radiuses.begin(),
-            [default_radius = this->default_radius](const std::optional<double> &maybe_radius)
+            [default_radius = this->default_radius](const boost::optional<double> &maybe_radius)
             {
                 if (maybe_radius)
                 {

src/engine/plugins/nearest.cpp

@@ -10,7 +10,7 @@
 namespace osrm::engine::plugins
 {
 
-NearestPlugin::NearestPlugin(const int max_results_, const std::optional<double> default_radius_)
+NearestPlugin::NearestPlugin(const int max_results_, const boost::optional<double> default_radius_)
     : BasePlugin(default_radius_), max_results{max_results_}
 {
 }

src/engine/plugins/table.cpp

@@ -15,7 +15,7 @@ namespace osrm::engine::plugins
 {
 
 TablePlugin::TablePlugin(const int max_locations_distance_table,
-                         const std::optional<double> default_radius)
+                         const boost::optional<double> default_radius)
     : BasePlugin(default_radius), max_locations_distance_table(max_locations_distance_table)
 {
 }

src/engine/plugins/viaroute.cpp

@@ -17,7 +17,7 @@ namespace osrm::engine::plugins
 
 ViaRoutePlugin::ViaRoutePlugin(int max_locations_viaroute,
                                int max_alternatives,
-                               std::optional<double> default_radius)
+                               boost::optional<double> default_radius)
     : BasePlugin(default_radius), max_locations_viaroute(max_locations_viaroute),
       max_alternatives(max_alternatives)
 {

src/engine/polyline_compressor.cpp

@@ -10,19 +10,9 @@
 namespace osrm::engine::detail // anonymous to keep TU local
 {
 
-void encode(int number_to_encode, std::string &output)
+std::string encode(int number_to_encode)
 {
-    if (number_to_encode < 0)
+    std::string output;
-    {
-        const unsigned binary = std::llabs(number_to_encode);
-        const unsigned twos = (~binary) + 1u;
-        const unsigned shl = twos << 1u;
-        number_to_encode = static_cast<int>(~shl);
-    }
-    else
-    {
-        number_to_encode <<= 1u;
-    }
     while (number_to_encode >= 0x20)
     {
         const int next_value = (0x20 | (number_to_encode & 0x1f)) + 63;
@@ -32,6 +22,31 @@ void encode(int number_to_encode, std::string &output)
 
     number_to_encode += 63;
     output += static_cast<char>(number_to_encode);
+    return output;
+}
+
+std::string encode(std::vector<int> &numbers)
+{
+    std::string output;
+    for (auto &number : numbers)
+    {
+        if (number < 0)
+        {
+            const unsigned binary = std::llabs(number);
+            const unsigned twos = (~binary) + 1u;
+            const unsigned shl = twos << 1u;
+            number = static_cast<int>(~shl);
+        }
+        else
+        {
+            number <<= 1u;
+        }
+    }
+    for (const int number : numbers)
+    {
+        output += encode(number);
+    }
+    return output;
 }
 
 // https://developers.google.com/maps/documentation/utilities/polylinealgorithm

src/engine/routing_algorithms/alternative_path_mld.cpp

@@ -621,24 +621,27 @@ void unpackPackedPaths(InputIt first,
                 BOOST_ASSERT(!facade.ExcludeNode(source));
                 BOOST_ASSERT(!facade.ExcludeNode(target));
 
-                auto unpacked_subpath = search(search_engine_data,
+                // TODO: when structured bindings will be allowed change to
-                                               facade,
+                // auto [subpath_weight, subpath_source, subpath_target, subpath] = ...
-                                               forward_heap,
+                EdgeWeight subpath_weight;
-                                               reverse_heap,
+                std::vector<NodeID> subpath_nodes;
-                                               {},
+                std::vector<EdgeID> subpath_edges;
-                                               INVALID_EDGE_WEIGHT,
+                std::tie(subpath_weight, subpath_nodes, subpath_edges) = search(search_engine_data,
-                                               sublevel,
+                                                                                facade,
-                                               parent_cell_id);
+                                                                                forward_heap,
-                BOOST_ASSERT(!unpacked_subpath.edges.empty());
+                                                                                reverse_heap,
-                BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
+                                                                                {},
-                BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
+                                                                                INVALID_EDGE_WEIGHT,
-                BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
+                                                                                sublevel,
-                unpacked_nodes.insert(unpacked_nodes.end(),
+                                                                                parent_cell_id);
-                                      std::next(unpacked_subpath.nodes.begin()),
+                BOOST_ASSERT(!subpath_edges.empty());
-                                      unpacked_subpath.nodes.end());
+                BOOST_ASSERT(subpath_nodes.size() > 1);
-                unpacked_edges.insert(unpacked_edges.end(),
+                BOOST_ASSERT(subpath_nodes.front() == source);
-                                      unpacked_subpath.edges.begin(),
+                BOOST_ASSERT(subpath_nodes.back() == target);
-                                      unpacked_subpath.edges.end());
+                unpacked_nodes.insert(
+                    unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
+                unpacked_edges.insert(
+                    unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
             }
         }
 

src/engine/routing_algorithms/direct_shortest_path.cpp

@@ -70,19 +70,20 @@ InternalRouteResult directShortestPathSearch(SearchEngineData<mld::Algorithm> &e
     auto &reverse_heap = *engine_working_data.reverse_heap_1;
     insertNodesInHeaps(forward_heap, reverse_heap, endpoint_candidates);
 
-    auto unpacked_path = mld::search(engine_working_data,
+    // TODO: when structured bindings will be allowed change to
-                                     facade,
+    // auto [weight, source_node, target_node, unpacked_edges] = ...
-                                     forward_heap,
+    EdgeWeight weight = INVALID_EDGE_WEIGHT;
-                                     reverse_heap,
+    std::vector<NodeID> unpacked_nodes;
-                                     {},
+    std::vector<EdgeID> unpacked_edges;
-                                     INVALID_EDGE_WEIGHT,
+    std::tie(weight, unpacked_nodes, unpacked_edges) = mld::search(engine_working_data,
-                                     endpoint_candidates);
+                                                                   facade,
+                                                                   forward_heap,
+                                                                   reverse_heap,
+                                                                   {},
+                                                                   INVALID_EDGE_WEIGHT,
+                                                                   endpoint_candidates);
 
-    return extractRoute(facade,
+    return extractRoute(facade, weight, endpoint_candidates, unpacked_nodes, unpacked_edges);
-                        unpacked_path.weight,
-                        endpoint_candidates,
-                        unpacked_path.nodes,
-                        unpacked_path.edges);
 }
 
 } // namespace osrm::engine::routing_algorithms

src/engine/routing_algorithms/map_matching.cpp

@@ -70,7 +70,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                             const CandidateLists &candidates_list,
                             const std::vector<util::Coordinate> &trace_coordinates,
                             const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<std::optional<double>> &trace_gps_precision,
+                            const std::vector<boost::optional<double>> &trace_gps_precision,
                             const bool allow_splitting)
 {
     map_matching::MatchingConfidence confidence;
@@ -401,7 +401,6 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
         auto trace_distance = 0.0;
         matching.nodes.reserve(reconstructed_indices.size());
         matching.indices.reserve(reconstructed_indices.size());
-        matching.alternatives_count.reserve(reconstructed_indices.size());
         for (const auto &idx : reconstructed_indices)
         {
             const auto timestamp_index = idx.first;
@@ -429,7 +428,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
 
         matching.confidence = confidence(trace_distance, matching_distance);
 
-        sub_matchings.emplace_back(std::move(matching));
+        sub_matchings.push_back(matching);
         sub_matching_begin = sub_matching_end;
     }
 
@@ -437,22 +436,24 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
 }
 
 // CH
-template SubMatchingList mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
+template SubMatchingList
-                                     const DataFacade<ch::Algorithm> &facade,
+mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
-                                     const CandidateLists &candidates_list,
+            const DataFacade<ch::Algorithm> &facade,
-                                     const std::vector<util::Coordinate> &trace_coordinates,
+            const CandidateLists &candidates_list,
-                                     const std::vector<unsigned> &trace_timestamps,
+            const std::vector<util::Coordinate> &trace_coordinates,
-                                     const std::vector<std::optional<double>> &trace_gps_precision,
+            const std::vector<unsigned> &trace_timestamps,
-                                     const bool allow_splitting);
+            const std::vector<boost::optional<double>> &trace_gps_precision,
+            const bool allow_splitting);
 
 // MLD
-template SubMatchingList mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
+template SubMatchingList
-                                     const DataFacade<mld::Algorithm> &facade,
+mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
-                                     const CandidateLists &candidates_list,
+            const DataFacade<mld::Algorithm> &facade,
-                                     const std::vector<util::Coordinate> &trace_coordinates,
+            const CandidateLists &candidates_list,
-                                     const std::vector<unsigned> &trace_timestamps,
+            const std::vector<util::Coordinate> &trace_coordinates,
-                                     const std::vector<std::optional<double>> &trace_gps_precision,
+            const std::vector<unsigned> &trace_timestamps,
-                                     const bool allow_splitting);
+            const std::vector<boost::optional<double>> &trace_gps_precision,
+            const bool allow_splitting);
 
 } // namespace osrm::engine::routing_algorithms
 

src/engine/routing_algorithms/shortest_path.cpp

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

src/extractor/extractor_callbacks.cpp

@@ -23,6 +23,8 @@
 #include <vector>
 
 #ifdef _MSC_VER
+#if (_MSC_VER >= 1928)
+#ifdef _DEBUG
 namespace osrm
 {
 namespace extractor
@@ -35,6 +37,8 @@ const ByEdgeOrByMeterValue::ValueByMeter ByEdgeOrByMeterValue::by_meter;
 } // namespace extractor
 } // namespace osrm
 #endif
+#endif
+#endif
 
 namespace osrm::extractor
 {

src/extractor/scripting_environment_lua.cpp

@@ -1254,7 +1254,7 @@ void Sol2ScriptingEnvironment::ProcessSegment(ExtractionSegment &segment)
 
     if (context.has_segment_function)
     {
-        sol::protected_function_result luares;
+        std::optional<sol::protected_function_result> luares;
         switch (context.api_version)
         {
         case 4:
@@ -1274,8 +1274,8 @@ void Sol2ScriptingEnvironment::ProcessSegment(ExtractionSegment &segment)
             break;
         }
 
-        if (!luares.valid())
+        if (luares && !luares->valid())
-            handle_lua_error(luares);
+            handle_lua_error(*luares);
     }
 }
 
@@ -1285,7 +1285,7 @@ void LuaScriptingContext::ProcessNode(const osmium::Node &node,
 {
     BOOST_ASSERT(state.lua_state() != nullptr);
 
-    sol::protected_function_result luares;
+    std::optional<sol::protected_function_result> luares;
 
     // TODO check for api version, make sure luares is always set
     switch (api_version)
@@ -1302,10 +1302,12 @@ void LuaScriptingContext::ProcessNode(const osmium::Node &node,
     case 0:
         luares = node_function(std::cref(node), std::ref(result));
         break;
+    default:
+        BOOST_ASSERT(false && "Invalid API version");
     }
 
-    if (!luares.valid())
+    if (luares && !luares->valid())
-        handle_lua_error(luares);
+        handle_lua_error(*luares);
 }
 
 void LuaScriptingContext::ProcessWay(const osmium::Way &way,
@@ -1314,7 +1316,7 @@ void LuaScriptingContext::ProcessWay(const osmium::Way &way,
 {
     BOOST_ASSERT(state.lua_state() != nullptr);
 
-    sol::protected_function_result luares;
+    std::optional<sol::protected_function_result> luares;
 
     // TODO check for api version, make sure luares is always set
     switch (api_version)
@@ -1331,10 +1333,12 @@ void LuaScriptingContext::ProcessWay(const osmium::Way &way,
     case 0:
         luares = way_function(std::cref(way), std::ref(result));
         break;
+    default:
+        BOOST_ASSERT(false && "Invalid API version");
     }
 
-    if (!luares.valid())
+    if (luares && !luares->valid())
-        handle_lua_error(luares);
+        handle_lua_error(*luares);
 }
 
 } // namespace osrm::extractor

src/server/api/parameters_parser.cpp

@@ -28,8 +28,8 @@ template <typename ParameterT,
           typename GrammarT,
           typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0,
           typename std::enable_if<detail::is_grammar_t<GrammarT>::value, int>::type = 0>
-std::optional<ParameterT> parseParameters(std::string::iterator &iter,
+boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
-                                          const std::string::iterator end)
+                                            const std::string::iterator end)
 {
     using It = std::decay<decltype(iter)>::type;
 
@@ -56,52 +56,52 @@ std::optional<ParameterT> parseParameters(std::string::iterator &iter,
         // as normal parser error
     }
 
-    return std::nullopt;
+    return boost::none;
 }
 } // namespace detail
 
 template <>
-std::optional<engine::api::RouteParameters> parseParameters(std::string::iterator &iter,
+boost::optional<engine::api::RouteParameters> parseParameters(std::string::iterator &iter,
-                                                            const std::string::iterator end)
+                                                              const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::RouteParameters, RouteParametersGrammar<>>(iter,
                                                                                            end);
 }
 
 template <>
-std::optional<engine::api::TableParameters> parseParameters(std::string::iterator &iter,
+boost::optional<engine::api::TableParameters> parseParameters(std::string::iterator &iter,
-                                                            const std::string::iterator end)
+                                                              const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::TableParameters, TableParametersGrammar<>>(iter,
                                                                                            end);
 }
 
 template <>
-std::optional<engine::api::NearestParameters> parseParameters(std::string::iterator &iter,
+boost::optional<engine::api::NearestParameters> parseParameters(std::string::iterator &iter,
-                                                              const std::string::iterator end)
+                                                                const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::NearestParameters, NearestParametersGrammar<>>(iter,
                                                                                                end);
 }
 
 template <>
-std::optional<engine::api::TripParameters> parseParameters(std::string::iterator &iter,
+boost::optional<engine::api::TripParameters> parseParameters(std::string::iterator &iter,
-                                                           const std::string::iterator end)
+                                                             const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::TripParameters, TripParametersGrammar<>>(iter, end);
 }
 
 template <>
-std::optional<engine::api::MatchParameters> parseParameters(std::string::iterator &iter,
+boost::optional<engine::api::MatchParameters> parseParameters(std::string::iterator &iter,
-                                                            const std::string::iterator end)
+                                                              const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::MatchParameters, MatchParametersGrammar<>>(iter,
                                                                                            end);
 }
 
 template <>
-std::optional<engine::api::TileParameters> parseParameters(std::string::iterator &iter,
+boost::optional<engine::api::TileParameters> parseParameters(std::string::iterator &iter,
-                                                           const std::string::iterator end)
+                                                             const std::string::iterator end)
 {
     return detail::parseParameters<engine::api::TileParameters, TileParametersGrammar<>>(iter, end);
 }

src/server/api/url_parser.cpp

@@ -65,7 +65,7 @@ struct URLParser final : qi::grammar<Iterator, Into>
 namespace osrm::server::api
 {
 
-std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end)
+boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end)
 {
     using It = std::decay<decltype(iter)>::type;
 
@@ -77,7 +77,7 @@ std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string
         const auto ok = boost::spirit::qi::parse(iter, end, parser(boost::phoenix::val(iter)), out);
 
         if (ok && iter == end)
-            return std::make_optional(out);
+            return boost::make_optional(out);
     }
     catch (const qi::expectation_failure<It> &failure)
     {
@@ -86,7 +86,7 @@ std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string
         iter = failure.first;
     }
 
-    return std::nullopt;
+    return boost::none;
 }
 
 } // namespace osrm::server::api

src/tools/routed.cpp

@@ -186,7 +186,7 @@ inline unsigned generateServerProgramOptions(const int argc,
          value<double>(&config.max_radius_map_matching)->default_value(-1.0),
          "Max. radius size supported in map matching query. Default: unlimited.") //
         ("default-radius",
-         value<double>(&config.default_radius)->default_value(-1.0),
+         value<boost::optional<double>>(&config.default_radius)->default_value(-1.0),
          "Default radius size for queries. Default: unlimited.");
 
     // hidden options, will be allowed on command line, but will not be shown to the user

unit_tests/CMakeLists.txt

@@ -114,10 +114,12 @@ add_executable(library-partition-tests
     EXCLUDE_FROM_ALL
     ${LibraryPartitionTestsSources})
 
-add_executable(server-tests
+if (BUILD_ROUTED)
+  add_executable(server-tests
 	EXCLUDE_FROM_ALL
 	${ServerTestsSources}
 	$<TARGET_OBJECTS:UTIL> $<TARGET_OBJECTS:SERVER>)
+endif()
 
 add_executable(util-tests
 	EXCLUDE_FROM_ALL
@@ -170,7 +172,9 @@ target_link_libraries(library-extract-tests osrm_extract osrm_guidance ${Boost_U
 target_link_libraries(library-contract-tests osrm_contract ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 target_link_libraries(library-customize-tests osrm_customize ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 target_link_libraries(library-partition-tests osrm_partition ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
-target_link_libraries(server-tests osrm ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+if (BUILD_ROUTED)
+  target_link_libraries(server-tests osrm ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+endif()
 target_link_libraries(util-tests ${UTIL_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 target_link_libraries(contractor-tests osrm_contract ${CONTRACTOR_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 target_link_libraries(storage-tests osrm_store ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})

unit_tests/engine/base64.cpp

@@ -74,98 +74,4 @@ BOOST_AUTO_TEST_CASE(hint_encoding_decoding_roundtrip_bytewise)
                            reinterpret_cast<const unsigned char *>(&decoded)));
 }
 
-BOOST_AUTO_TEST_CASE(long_string_encoding)
-{
-    using namespace osrm::engine;
-    std::string long_string(1000, 'A'); // String of 1000 'A's
-    std::string encoded = encodeBase64(long_string);
-    BOOST_CHECK_EQUAL(decodeBase64(encoded), long_string);
-}
-
-BOOST_AUTO_TEST_CASE(invalid_base64_decoding)
-{
-    using namespace osrm::engine;
-    BOOST_CHECK_THROW(decodeBase64("Invalid!"), std::exception);
-}
-
-BOOST_AUTO_TEST_CASE(hint_serialization_size)
-{
-    using namespace osrm::engine;
-    using namespace osrm::util;
-
-    const Coordinate coordinate;
-    const PhantomNode phantom;
-    const osrm::test::MockDataFacade<osrm::engine::routing_algorithms::ch::Algorithm> facade{};
-
-    const SegmentHint hint{phantom, facade.GetCheckSum()};
-    const auto base64 = hint.ToBase64();
-
-    BOOST_CHECK_EQUAL(base64.size(), 112);
-}
-
-BOOST_AUTO_TEST_CASE(extended_roundtrip_tests)
-{
-    using namespace osrm::engine;
-
-    std::vector<std::string> test_strings = {
-        "Hello, World!",                    // Simple ASCII string
-        "1234567890",                       // Numeric string
-        "!@#$%^&*()_+",                     // Special characters
-        std::string(1000, 'A'),             // Long repeating string
-        "¡Hola, mundo!",                    // Non-ASCII characters
-        "こんにちは、世界！",               // Unicode characters
-        std::string("\x00\x01\x02\x03", 4), // Binary data
-        "a",                                // Single character
-        "ab",                               // Two characters
-        "abc",                              // Three characters (no padding in Base64)
-        std::string(190, 'x')               // String that doesn't align with Base64 padding
-    };
-
-    for (const auto &test_str : test_strings)
-    {
-        std::string encoded = encodeBase64(test_str);
-        std::string decoded = decodeBase64(encoded);
-        BOOST_CHECK_EQUAL(decoded, test_str);
-
-        // Additional checks
-        BOOST_CHECK(encoded.find_first_not_of(
-                        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=") ==
-                    std::string::npos);
-        if (test_str.length() % 3 != 0)
-        {
-            BOOST_CHECK(encoded.back() == '=');
-        }
-    }
-}
-
-BOOST_AUTO_TEST_CASE(roundtrip_with_url_safe_chars)
-{
-    using namespace osrm::engine;
-
-    std::string original = "Hello+World/Nothing?Is:Impossible";
-    std::string encoded = encodeBase64(original);
-
-    // Replace '+' with '-' and '/' with '_'
-    std::replace(encoded.begin(), encoded.end(), '+', '-');
-    std::replace(encoded.begin(), encoded.end(), '/', '_');
-
-    std::string decoded = decodeBase64(encoded);
-    BOOST_CHECK_EQUAL(decoded, original);
-}
-
-BOOST_AUTO_TEST_CASE(roundtrip_stress_test)
-{
-    using namespace osrm::engine;
-
-    std::string test_str;
-    for (int i = 0; i < 1000; ++i)
-    {
-        test_str += static_cast<char>(i % 256);
-    }
-
-    std::string encoded = encodeBase64(test_str);
-    std::string decoded = decodeBase64(encoded);
-    BOOST_CHECK_EQUAL(decoded, test_str);
-}
-
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/engine/collapse_internal_route_result.cpp

@@ -19,8 +19,8 @@ BOOST_AUTO_TEST_CASE(unchanged_collapse_route_result)
     PhantomNode target;
     source.forward_segment_id = {1, true};
     target.forward_segment_id = {6, true};
-    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, std::nullopt};
+    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, boost::none};
-    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, std::nullopt};
+    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, boost::none};
     InternalRouteResult one_leg_result;
     one_leg_result.unpacked_path_segments = {{pathy, kathy}};
     one_leg_result.leg_endpoints = {PhantomEndpoints{source, target}};
@@ -39,9 +39,9 @@ BOOST_AUTO_TEST_CASE(two_legs_to_one_leg)
 {
     // from_edge_based_node, turn_via_node, weight_until_turn, weight_of_turn,
     // duration_until_turn, duration_of_turn, datasource_id, turn_edge
-    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, std::nullopt};
+    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, boost::none};
-    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, std::nullopt};
+    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, boost::none};
-    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, std::nullopt};
+    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, boost::none};
     PhantomNode node_1;
     PhantomNode node_2;
     PhantomNode node_3;
@@ -74,11 +74,11 @@ BOOST_AUTO_TEST_CASE(two_legs_to_one_leg)
 
 BOOST_AUTO_TEST_CASE(three_legs_to_two_legs)
 {
-    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, std::nullopt};
+    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, boost::none};
-    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, std::nullopt};
+    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, boost::none};
-    PathData qathy{0, 5, {1}, {2}, {3}, {4}, 1, std::nullopt};
+    PathData qathy{0, 5, {1}, {2}, {3}, {4}, 1, boost::none};
-    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, std::nullopt};
+    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, boost::none};
-    PathData mathy{0, 4, {8}, {9}, {13}, {4}, 2, std::nullopt};
+    PathData mathy{0, 4, {8}, {9}, {13}, {4}, 2, boost::none};
     PhantomNode node_1;
     PhantomNode node_2;
     PhantomNode node_3;
@@ -131,9 +131,9 @@ BOOST_AUTO_TEST_CASE(three_legs_to_two_legs)
 
 BOOST_AUTO_TEST_CASE(two_legs_to_two_legs)
 {
-    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, std::nullopt};
+    PathData pathy{0, 2, {2}, {3}, {4}, {5}, 2, boost::none};
-    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, std::nullopt};
+    PathData kathy{0, 1, {1}, {2}, {3}, {4}, 1, boost::none};
-    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, std::nullopt};
+    PathData cathy{0, 3, {1}, {2}, {3}, {4}, 1, boost::none};
     PhantomNode node_1;
     PhantomNode node_2;
     PhantomNode node_3;

unit_tests/engine/offline_facade.cpp

@@ -219,7 +219,7 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate /*input_coordinate*/,
                                const double /*max_distance*/,
-                               const std::optional<engine::Bearing> /*bearing*/,
+                               const boost::optional<engine::Bearing> /*bearing*/,
                                const engine::Approach /*approach*/,
                                const bool /*use_all_edges*/) const override
     {
@@ -229,8 +229,8 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate /*input_coordinate*/,
                         const size_t /*max_results*/,
-                        const std::optional<double> /*max_distance*/,
+                        const boost::optional<double> /*max_distance*/,
-                        const std::optional<engine::Bearing> /*bearing*/,
+                        const boost::optional<engine::Bearing> /*bearing*/,
                         const engine::Approach /*approach*/) const override
     {
         return {};
@@ -238,8 +238,8 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
 
     engine::PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
         const util::Coordinate /*input_coordinate*/,
-        const std::optional<double> /*max_distance*/,
+        const boost::optional<double> /*max_distance*/,
-        const std::optional<engine::Bearing> /*bearing*/,
+        const boost::optional<engine::Bearing> /*bearing*/,
         const engine::Approach /*approach*/,
         const bool /*use_all_edges*/) const override
     {

unit_tests/engine/polyline_compressor.cpp

@@ -45,96 +45,4 @@ BOOST_AUTO_TEST_CASE(polyline6_test_case)
         decodePolyline<1000000>(encodePolyline<1000000>(coords.begin(), coords.end())).begin()));
 }
 
-BOOST_AUTO_TEST_CASE(empty_polyline_test)
-{
-    using namespace osrm::engine;
-    using namespace osrm::util;
-
-    std::vector<Coordinate> empty_coords;
-    BOOST_CHECK_EQUAL(encodePolyline(empty_coords.begin(), empty_coords.end()), "");
-    BOOST_CHECK(decodePolyline("").empty());
-}
-BOOST_AUTO_TEST_CASE(polyline_single_point_test)
-{
-    using namespace osrm::engine;
-    using namespace osrm::util;
-
-    const std::vector<Coordinate> coords({{FixedLongitude{-122414000}, FixedLatitude{37776000}}});
-
-    const std::string encoded = encodePolyline(coords.begin(), coords.end());
-    BOOST_CHECK_EQUAL(encoded, "_cqeFn~cjV");
-
-    const auto decoded = decodePolyline(encoded);
-    BOOST_CHECK_EQUAL(decoded.size(), 1);
-    BOOST_CHECK_EQUAL(decoded[0].lon, FixedLongitude{-122414000});
-    BOOST_CHECK_EQUAL(decoded[0].lat, FixedLatitude{37776000});
-}
-
-BOOST_AUTO_TEST_CASE(polyline_multiple_points_test)
-{
-    using namespace osrm::engine;
-    using namespace osrm::util;
-
-    const std::vector<Coordinate> coords({{FixedLongitude{-122414000}, FixedLatitude{37776000}},
-                                          {FixedLongitude{-122420000}, FixedLatitude{37779000}},
-                                          {FixedLongitude{-122421000}, FixedLatitude{37780000}}});
-
-    const std::string encoded = encodePolyline(coords.begin(), coords.end());
-    BOOST_CHECK_EQUAL(encoded, "_cqeFn~cjVwQnd@gEfE");
-
-    const auto decoded = decodePolyline(encoded);
-    BOOST_CHECK_EQUAL(decoded.size(), 3);
-    for (size_t i = 0; i < coords.size(); ++i)
-    {
-        BOOST_CHECK_EQUAL(decoded[i].lon, coords[i].lon);
-        BOOST_CHECK_EQUAL(decoded[i].lat, coords[i].lat);
-    }
-}
-
-BOOST_AUTO_TEST_CASE(polyline_large_coordinate_difference_test)
-{
-    using namespace osrm::engine;
-    using namespace osrm::util;
-
-    const std::vector<Coordinate> coords({{FixedLongitude{-179000000}, FixedLatitude{-89000000}},
-                                          {FixedLongitude{179000000}, FixedLatitude{89000000}}});
-
-    const std::string encoded = encodePolyline(coords.begin(), coords.end());
-    BOOST_CHECK_EQUAL(encoded, "~xe~O~|oca@_sl}`@_{`hcA");
-
-    const auto decoded = decodePolyline(encoded);
-    BOOST_CHECK_EQUAL(decoded.size(), 2);
-    for (size_t i = 0; i < coords.size(); ++i)
-    {
-        BOOST_CHECK_EQUAL(decoded[i].lon, coords[i].lon);
-        BOOST_CHECK_EQUAL(decoded[i].lat, coords[i].lat);
-    }
-}
-
-BOOST_AUTO_TEST_CASE(roundtrip)
-{
-    using namespace osrm::engine;
-    using namespace osrm::util;
-
-    {
-        const auto encoded = "_chxEn`zvN\\\\]]";
-        const auto decoded = decodePolyline(encoded);
-        const auto reencoded = encodePolyline(decoded.begin(), decoded.end());
-        BOOST_CHECK_EQUAL(encoded, reencoded);
-    }
-    {
-        const auto encoded =
-            "gcneIpgxzRcDnBoBlEHzKjBbHlG`@`IkDxIiKhKoMaLwTwHeIqHuAyGXeB~Ew@fFjAtIzExF";
-        const auto decoded = decodePolyline(encoded);
-        const auto reencoded = encodePolyline(decoded.begin(), decoded.end());
-        BOOST_CHECK_EQUAL(encoded, reencoded);
-    }
-    {
-        const auto encoded = "_p~iF~ps|U_ulLnnqC_mqNvxq`@";
-        const auto decoded = decodePolyline(encoded);
-        const auto reencoded = encodePolyline(decoded.begin(), decoded.end());
-        BOOST_CHECK_EQUAL(encoded, reencoded);
-    }
-}
-
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/library/table.cpp

@@ -271,8 +271,8 @@ void test_table_no_segment_for_some_coordinates(bool use_json_only_api)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
     // resembles query option: `&radiuses=0;`
-    params.radiuses.push_back(std::make_optional(0.));
+    params.radiuses.push_back(boost::make_optional(0.));
-    params.radiuses.push_back(std::nullopt);
+    params.radiuses.push_back(boost::none);
 
     json::Object json_result;
     const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);

unit_tests/mocks/mock_datafacade.hpp

@@ -107,7 +107,7 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate /*input_coordinate*/,
                                const double /*max_distance*/,
-                               const std::optional<engine::Bearing> /*bearing*/,
+                               const boost::optional<engine::Bearing> /*bearing*/,
                                const engine::Approach /*approach*/,
                                const bool /*use_all_edges*/) const override
     {
@@ -117,8 +117,8 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate /*input_coordinate*/,
                         const size_t /*max_results*/,
-                        const std::optional<double> /*max_distance*/,
+                        const boost::optional<double> /*max_distance*/,
-                        const std::optional<engine::Bearing> /*bearing*/,
+                        const boost::optional<engine::Bearing> /*bearing*/,
                         const engine::Approach /*approach*/) const override
     {
         return {};
@@ -126,8 +126,8 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
 
     engine::PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
         const util::Coordinate /*input_coordinate*/,
-        const std::optional<double> /*max_distance*/,
+        const boost::optional<double> /*max_distance*/,
-        const std::optional<engine::Bearing> /*bearing*/,
+        const boost::optional<engine::Bearing> /*bearing*/,
         const engine::Approach /*approach*/,
         const bool /*use_all_edges*/) const override
     {

unit_tests/server/parameters_parser.cpp

@@ -32,11 +32,6 @@
                                           (R2)[i]->segment_hints.end());                           \
         }                                                                                          \
     }
-// TODO: we should be able to somehow make Boost.Test to print std::optional types
-BOOST_TEST_DONT_PRINT_LOG_VALUE(std::optional<double>)
-BOOST_TEST_DONT_PRINT_LOG_VALUE(std::optional<osrm::engine::Approach>)
-BOOST_TEST_DONT_PRINT_LOG_VALUE(std::optional<osrm::engine::Bearing>)
-BOOST_TEST_DONT_PRINT_LOG_VALUE(std::optional<bool>)
 
 BOOST_AUTO_TEST_SUITE(api_parameters_parser)
 
@@ -221,7 +216,7 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     phantom_1.input_location = coords_1[0];
     engine::PhantomNode phantom_2;
     phantom_2.input_location = coords_1[1];
-    std::vector<std::optional<engine::Hint>> hints_4 = {
+    std::vector<boost::optional<engine::Hint>> hints_4 = {
         engine::Hint{{engine::SegmentHint{phantom_1, 0x1337}}},
         engine::Hint{{engine::SegmentHint{phantom_2, 0x1337}}}};
     RouteParameters reference_4{false,
@@ -229,11 +224,11 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                 false,
                                 RouteParameters::GeometriesType::Polyline,
                                 RouteParameters::OverviewType::Simplified,
-                                std::optional<bool>{},
+                                boost::optional<bool>{},
                                 coords_1,
                                 hints_4,
-                                std::vector<std::optional<double>>{},
+                                std::vector<boost::optional<double>>{},
-                                std::vector<std::optional<engine::Bearing>>{}};
+                                std::vector<boost::optional<engine::Bearing>>{}};
     auto result_4 = parseParameters<RouteParameters>(
         "1,2;3,4?steps=false&hints=" + hints_4[0]->ToBase64() + ";" + hints_4[1]->ToBase64());
     BOOST_CHECK(result_4);
@@ -249,8 +244,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     CHECK_EQUAL_RANGE(reference_4.coordinates, result_4->coordinates);
     CHECK_EQUAL_RANGE_OF_HINTS(reference_4.hints, result_4->hints);
 
-    std::vector<std::optional<engine::Bearing>> bearings_4 = {
+    std::vector<boost::optional<engine::Bearing>> bearings_4 = {
-        std::nullopt,
+        boost::none,
         engine::Bearing{200, 10},
         engine::Bearing{100, 5},
     };
@@ -259,10 +254,10 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                 false,
                                 RouteParameters::GeometriesType::Polyline,
                                 RouteParameters::OverviewType::Simplified,
-                                std::optional<bool>{},
+                                boost::optional<bool>{},
                                 coords_1,
-                                std::vector<std::optional<engine::Hint>>{},
+                                std::vector<boost::optional<engine::Hint>>{},
-                                std::vector<std::optional<double>>{},
+                                std::vector<boost::optional<double>>{},
                                 bearings_4};
     auto result_5 = parseParameters<RouteParameters>("1,2;3,4?steps=false&bearings=;200,10;100,5");
     BOOST_CHECK(result_5);
@@ -301,8 +296,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     auto result_7 = parseParameters<RouteParameters>("1,2;3,4?radiuses=;unlimited");
     RouteParameters reference_7{};
     reference_7.coordinates = coords_1;
-    reference_7.radiuses = {std::nullopt,
+    reference_7.radiuses = {boost::none,
-                            std::make_optional(std::numeric_limits<double>::infinity())};
+                            boost::make_optional(std::numeric_limits<double>::infinity())};
     BOOST_CHECK(result_7);
     BOOST_CHECK_EQUAL(reference_7.steps, result_7->steps);
     BOOST_CHECK_EQUAL(reference_7.alternatives, result_7->alternatives);
@@ -319,14 +314,14 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     auto result_8 = parseParameters<RouteParameters>("1,2;3,4?radiuses=;");
     RouteParameters reference_8{};
     reference_8.coordinates = coords_1;
-    reference_8.radiuses = {std::nullopt, std::nullopt};
+    reference_8.radiuses = {boost::none, boost::none};
     BOOST_CHECK(result_8);
     CHECK_EQUAL_RANGE(reference_8.radiuses, result_8->radiuses);
 
     auto result_9 = parseParameters<RouteParameters>("1,2?radiuses=");
     RouteParameters reference_9{};
     reference_9.coordinates = coords_1;
-    reference_9.radiuses = {std::nullopt};
+    reference_9.radiuses = {boost::none};
     BOOST_CHECK(result_9);
     CHECK_EQUAL_RANGE(reference_9.radiuses, result_9->radiuses);
 
@@ -340,7 +335,7 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     phantom_3.input_location = coords_3[0];
     engine::PhantomNode phantom_4;
     phantom_4.input_location = coords_3[2];
-    std::vector<std::optional<engine::Hint>> hints_10 = {
+    std::vector<boost::optional<engine::Hint>> hints_10 = {
         engine::Hint{{engine::SegmentHint{phantom_3, 0x1337}}},
         {},
         engine::Hint{{engine::SegmentHint{phantom_4, 0x1337}}},
@@ -351,11 +346,11 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                  false,
                                  RouteParameters::GeometriesType::Polyline,
                                  RouteParameters::OverviewType::Simplified,
-                                 std::optional<bool>{},
+                                 boost::optional<bool>{},
                                  coords_3,
                                  hints_10,
-                                 std::vector<std::optional<double>>{},
+                                 std::vector<boost::optional<double>>{},
-                                 std::vector<std::optional<engine::Bearing>>{}};
+                                 std::vector<boost::optional<engine::Bearing>>{}};
     auto result_10 = parseParameters<RouteParameters>(
         "1,2;3,4;5,6;7,8?steps=false&hints=" + hints_10[0]->ToBase64() + ";;" +
         hints_10[2]->ToBase64() + ";");
@@ -452,8 +447,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     BOOST_CHECK_EQUAL(result_2->annotations_type == RouteParameters::AnnotationsType::All, true);
     BOOST_CHECK_EQUAL(result_17->annotations, true);
 
-    std::vector<std::optional<engine::Approach>> approaches_18 = {
+    std::vector<boost::optional<engine::Approach>> approaches_18 = {
-        std::nullopt,
+        boost::none,
         engine::Approach::CURB,
         engine::Approach::UNRESTRICTED,
         engine::Approach::OPPOSITE,
@@ -463,11 +458,11 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                  false,
                                  RouteParameters::GeometriesType::Polyline,
                                  RouteParameters::OverviewType::Simplified,
-                                 std::optional<bool>{},
+                                 boost::optional<bool>{},
                                  coords_3,
-                                 std::vector<std::optional<engine::Hint>>{},
+                                 std::vector<boost::optional<engine::Hint>>{},
-                                 std::vector<std::optional<double>>{},
+                                 std::vector<boost::optional<double>>{},
-                                 std::vector<std::optional<engine::Bearing>>{},
+                                 std::vector<boost::optional<engine::Bearing>>{},
                                  approaches_18};
 
     auto result_18 = parseParameters<RouteParameters>(
@@ -783,7 +778,6 @@ BOOST_AUTO_TEST_CASE(valid_trip_urls)
     reference_1.coordinates = coords_1;
     auto result_1 = parseParameters<TripParameters>("1,2;3,4");
     BOOST_CHECK(result_1);
-
     CHECK_EQUAL_RANGE(reference_1.radiuses, result_1->radiuses);
     CHECK_EQUAL_RANGE(reference_1.coordinates, result_1->coordinates);
 

unit_tests/util/binary_heap.cpp

@@ -1,132 +0,0 @@
-#include "util/binary_heap.hpp"
-
-#include <boost/test/unit_test.hpp>
-#include <string>
-
-BOOST_AUTO_TEST_SUITE(binary_heap_test)
-
-BOOST_AUTO_TEST_CASE(empty_heap)
-{
-    osrm::util::BinaryHeap<int> heap;
-    BOOST_CHECK(heap.empty());
-}
-
-BOOST_AUTO_TEST_CASE(push_and_top)
-{
-    osrm::util::BinaryHeap<int> heap;
-    heap.emplace(5);
-    BOOST_CHECK_EQUAL(heap.top(), 5);
-    BOOST_CHECK(!heap.empty());
-}
-
-BOOST_AUTO_TEST_CASE(push_multiple_and_order)
-{
-    osrm::util::BinaryHeap<int> heap;
-    heap.emplace(5);
-    heap.emplace(10);
-    heap.emplace(3);
-    heap.emplace(8);
-    BOOST_CHECK_EQUAL(heap.top(), 10);
-}
-
-BOOST_AUTO_TEST_CASE(pop_and_order)
-{
-    osrm::util::BinaryHeap<int> heap;
-    heap.emplace(5);
-    heap.emplace(10);
-    heap.emplace(3);
-    heap.emplace(8);
-
-    BOOST_CHECK_EQUAL(heap.top(), 10);
-    heap.pop();
-    BOOST_CHECK_EQUAL(heap.top(), 8);
-    heap.pop();
-    BOOST_CHECK_EQUAL(heap.top(), 5);
-    heap.pop();
-    BOOST_CHECK_EQUAL(heap.top(), 3);
-    heap.pop();
-    BOOST_CHECK(heap.empty());
-}
-
-BOOST_AUTO_TEST_CASE(clear_heap)
-{
-    osrm::util::BinaryHeap<int> heap;
-    heap.emplace(5);
-    heap.emplace(10);
-    heap.clear();
-    BOOST_CHECK(heap.empty());
-}
-
-BOOST_AUTO_TEST_CASE(emplace_with_custom_type)
-{
-    struct CustomType
-    {
-        int value;
-        CustomType(int v) : value(v) {}
-        bool operator<(const CustomType &other) const { return value < other.value; }
-    };
-
-    osrm::util::BinaryHeap<CustomType> heap;
-    heap.emplace(5);
-    heap.emplace(10);
-    heap.emplace(3);
-    BOOST_CHECK_EQUAL(heap.top().value, 10);
-}
-
-BOOST_AUTO_TEST_CASE(large_number_of_elements)
-{
-    osrm::util::BinaryHeap<int> heap;
-    for (int i = 0; i < 1000; ++i)
-    {
-        heap.emplace(i);
-    }
-    BOOST_CHECK_EQUAL(heap.top(), 999);
-
-    for (int i = 999; i >= 0; --i)
-    {
-        BOOST_CHECK_EQUAL(heap.top(), i);
-        heap.pop();
-    }
-    BOOST_CHECK(heap.empty());
-}
-
-BOOST_AUTO_TEST_CASE(duplicate_values)
-{
-    osrm::util::BinaryHeap<int> heap;
-    heap.emplace(5);
-    heap.emplace(5);
-    heap.emplace(5);
-
-    BOOST_CHECK_EQUAL(heap.top(), 5);
-    heap.pop();
-    BOOST_CHECK_EQUAL(heap.top(), 5);
-    heap.pop();
-    BOOST_CHECK_EQUAL(heap.top(), 5);
-    heap.pop();
-    BOOST_CHECK(heap.empty());
-}
-
-BOOST_AUTO_TEST_CASE(string_type)
-{
-    osrm::util::BinaryHeap<std::string> heap;
-    heap.emplace("apple");
-    heap.emplace("banana");
-    heap.emplace("cherry");
-
-    BOOST_CHECK_EQUAL(heap.top(), "cherry");
-    heap.pop();
-    BOOST_CHECK_EQUAL(heap.top(), "banana");
-    heap.pop();
-    BOOST_CHECK_EQUAL(heap.top(), "apple");
-}
-
-BOOST_AUTO_TEST_CASE(emplace_after_clear)
-{
-    osrm::util::BinaryHeap<int> heap;
-    heap.emplace(5);
-    heap.clear();
-    heap.emplace(10);
-    BOOST_CHECK_EQUAL(heap.top(), 10);
-}
-
-BOOST_AUTO_TEST_SUITE_END()

unit_tests/util/static_rtree.cpp

@@ -332,13 +332,13 @@ BOOST_AUTO_TEST_CASE(radius_regression_test)
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 0.01, std::nullopt, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 0.01, boost::none, true);
         BOOST_CHECK_EQUAL(results.size(), 0);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 1, 0.01, std::nullopt, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 1, 0.01, boost::none, true);
         BOOST_CHECK_EQUAL(results.size(), 0);
     }
 }
@@ -364,25 +364,25 @@ BOOST_AUTO_TEST_CASE(permissive_edge_snapping)
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 1000, std::nullopt, false);
+            input, osrm::engine::Approach::UNRESTRICTED, 1000, boost::none, false);
         BOOST_CHECK_EQUAL(results.size(), 1);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 1000, std::nullopt, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 1000, boost::none, true);
         BOOST_CHECK_EQUAL(results.size(), 2);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 10, 1000, std::nullopt, false);
+            input, osrm::engine::Approach::UNRESTRICTED, 10, 1000, boost::none, false);
         BOOST_CHECK_EQUAL(results.size(), 1);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 10, 1000, std::nullopt, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 10, 1000, boost::none, true);
         BOOST_CHECK_EQUAL(results.size(), 2);
     }
 }
@@ -408,7 +408,7 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 5, std::nullopt, std::nullopt, false);
+            input, osrm::engine::Approach::UNRESTRICTED, 5, boost::none, boost::none, false);
         BOOST_CHECK_EQUAL(results.size(), 2);
         BOOST_CHECK_EQUAL(results.back().phantom_node.forward_segment_id.id, 0);
         BOOST_CHECK_EQUAL(results.back().phantom_node.reverse_segment_id.id, 1);
@@ -418,7 +418,7 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
         auto results = query.NearestPhantomNodes(input,
                                                  osrm::engine::Approach::UNRESTRICTED,
                                                  5,
-                                                 std::nullopt,
+                                                 boost::none,
                                                  engine::Bearing{270, 10},
                                                  false);
         BOOST_CHECK_EQUAL(results.size(), 0);
@@ -428,7 +428,7 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
         auto results = query.NearestPhantomNodes(input,
                                                  osrm::engine::Approach::UNRESTRICTED,
                                                  5,
-                                                 std::nullopt,
+                                                 boost::none,
                                                  engine::Bearing{45, 10},
                                                  false);
         BOOST_CHECK_EQUAL(results.size(), 2);
@@ -444,13 +444,13 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 11000, std::nullopt, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 11000, boost::none, true);
         BOOST_CHECK_EQUAL(results.size(), 2);
     }
 
     {
         auto results = query.NearestPhantomNodes(
-            input, osrm::engine::Approach::UNRESTRICTED, 10, 11000, std::nullopt, true);
+            input, osrm::engine::Approach::UNRESTRICTED, 10, 11000, boost::none, true);
         BOOST_CHECK_EQUAL(results.size(), 2);
     }