wip

.github/workflows/osrm-backend.yml

@@ -31,8 +31,6 @@ jobs:
       BUILD_TYPE: Release
     steps:
     - uses: actions/checkout@v4
-    - run: pip install "conan<2.0.0"
-    - run: conan --version
     - run: cmake --version
     - uses: actions/setup-node@v4
       with:
@@ -51,6 +49,12 @@ jobs:
       run: |
         mkdir build
         cd build
+
+        python3 -m venv .venv
+        source .venv/Scripts/Activate
+        python3 -m pip install conan==2.7.1
+        conan profile detect --force
+
         cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_CONAN=ON -DENABLE_NODE_BINDINGS=ON ..
         cmake --build . --config Release
         
@@ -393,10 +397,10 @@ jobs:
     - name: Enable Conan cache
       uses: actions/cache@v4
       with:
-        path: ~/.conan
+        path: ~/.conan2
-        key: v9-conan-${{ matrix.name }}-${{ github.sha }}
+        key: v10-conan-${{ matrix.name }}-${{ github.sha }}
         restore-keys: |
-          v9-conan-${{ matrix.name }}-
+          v10-conan-${{ matrix.name }}-
     - name: Enable test cache
       uses: actions/cache@v4
       with:
@@ -446,19 +450,17 @@ jobs:
       if: steps.cache-boost.outputs.cache-hit != 'true' && runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
       run: |
         BOOST_VERSION="1.85.0"
-        BOOST_VERSION_FLAVOR="${BOOST_VERSION}-b2-nodocs"
+        BOOST_VERSION_UNDERSCORE="${BOOST_VERSION//./_}"
-        wget -q https://github.com/boostorg/boost/releases/download/boost-${BOOST_VERSION}/boost-${BOOST_VERSION_FLAVOR}.tar.gz
+        wget -q https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION}/source/boost_${BOOST_VERSION_UNDERSCORE}.tar.gz
-        tar xzf boost-${BOOST_VERSION_FLAVOR}.tar.gz
+        tar xzf boost_${BOOST_VERSION_UNDERSCORE}.tar.gz
-        cd boost-${BOOST_VERSION}
+        cd boost_${BOOST_VERSION_UNDERSCORE}
         sudo ./bootstrap.sh
         sudo ./b2 install
         cd ..
-        sudo rm -rf boost-${BOOST_VERSION}*
+        sudo rm -rf boost_${BOOST_VERSION_UNDERSCORE}*
     
     - name: Install dev dependencies
       run: |
-        python3 -m pip install "conan<2.0.0" || python3 -m pip install "conan<2.0.0" --break-system-packages
-
         # workaround for issue that GitHub Actions seems to not adding it to PATH after https://github.com/actions/runner-images/pull/6499
         # and that's why CI cannot find conan executable installed above
         if [[ "${RUNNER_OS}" == "macOS" ]]; then
@@ -495,20 +497,6 @@ jobs:
         tar zxvf onetbb.tgz
         sudo cp -a oneapi-tbb-${TBB_VERSION}/lib/. /usr/local/lib/
         sudo cp -a oneapi-tbb-${TBB_VERSION}/include/. /usr/local/include/
-    - name: Add Clang 18 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Clang 18
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.CCOMPILER == 'clang-18' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_linux_amd64 -O /usr/bin/yq && sudo chmod +x /usr/bin/yq
-
-        conan config init
-        yq eval '.compiler.clang.version += ["18"]' -i "$HOME/.conan/settings.yml"
-    - name: Add Apple-clang 16 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Apple-clang 16
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.runs-on == 'macos-14' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_darwin_arm64 -O /usr/local/bin/yq && sudo chmod +x /usr/local/bin/yq
-
-        conan config init
-        yq eval '.compiler.apple-clang.version += ["16.0"]' -i "$HOME/.conan/settings.yml"
     - name: Prepare build
       run: |
         mkdir ${OSRM_BUILD_DIR}
@@ -530,7 +518,14 @@ jobs:
       run: |
         echo "Using ${JOBS} jobs"
         pushd ${OSRM_BUILD_DIR}
-        
+
+        if [[ "${ENABLE_CONAN}" == "ON" ]]; then
+          python3 -m venv .venv
+          source .venv/bin/activate
+          python3 -m pip install conan==2.7.1
+          conan profile detect --force
+        fi
+
         ccache --zero-stats
         cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
                  -DENABLE_CONAN=${ENABLE_CONAN:-OFF} \
@@ -544,6 +539,7 @@ jobs:
                  -DENABLE_CCACHE=ON \
                  -DENABLE_LTO=${ENABLE_LTO:-ON} \
                  -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
+
         make --jobs=${JOBS}
 
         if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
@@ -558,7 +554,7 @@ jobs:
         fi
         popd
     - name: Build example
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' && matrix.ENABLE_CONAN != 'ON' }}
       run: |
         mkdir example/build && pushd example/build
         cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
@@ -570,8 +566,10 @@ jobs:
         make -C test/data benchmark
 
         # macOS SIP strips the linker path. Reset this inside the running shell
-        export LD_LIBRARY_PATH=${{ env.LD_LIBRARY_PATH }}
+        if [[ "${ENABLE_CONAN}" == "OFF" ]]; then
-        ./example/build/osrm-example test/data/mld/monaco.osrm
+          export LD_LIBRARY_PATH=${{ env.LD_LIBRARY_PATH }}
+          ./example/build/osrm-example test/data/mld/monaco.osrm
+        fi
 
         # All tests assume to be run from the build directory
         pushd ${OSRM_BUILD_DIR}
@@ -681,7 +679,7 @@ jobs:
           python3 -m venv .venv
           source .venv/bin/activate
           echo PATH=$PATH >> $GITHUB_ENV
-          pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
+          pip install "conan==2.7.1" "requests==2.31.0" "numpy==1.26.4" 
       - name: Prepare data
         run: |
           if [ "$RUN_BIG_BENCHMARK" = "true" ]; then

CHANGELOG.md

@@ -25,7 +25,7 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
-      - CHANGED: Use std::string_view for key type in json::Object. [#7062](https://github.com/Project-OSRM/osrm-backend/pull/7062)
+      - CHANGED: Migrate to Conan 2.x. [#7042](https://github.com/Project-OSRM/osrm-backend/pull/7042)
       - CHANGED: Use thread_local instead of boost::thread_specific_ptr. [#6991](https://github.com/Project-OSRM/osrm-backend/pull/6991)
       - CHANGED: Bump flatbuffers to v24.3.25 version. [#6988](https://github.com/Project-OSRM/osrm-backend/pull/6988)
       - CHANGED: Add .reserve(...) to assembleGeometry function. [#6983](https://github.com/Project-OSRM/osrm-backend/pull/6983)

CMakeLists.txt

@@ -37,6 +37,29 @@ option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
 option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
 
 
+if (ENABLE_CONAN)
+  message(STATUS "Installing Conan packages. It may take a while...")
+  find_program(CONAN_EXECUTABLE NAMES conan)
+
+  if (NOT CONAN_EXECUTABLE)
+    message(FATAL_ERROR "Conan not found! Please install Conan 2.x and try again.")
+  else()
+    set(CMAKE_TOOLCHAIN_FILE "./conan_toolchain.cmake")
+
+    execute_process(
+      COMMAND ${CONAN_EXECUTABLE} install .. --output-folder=. --build=missing --settings compiler.cppstd=20 --settings build_type=${CMAKE_BUILD_TYPE}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+      OUTPUT_VARIABLE conan_stdout
+      ERROR_VARIABLE conan_stderr
+      RESULT_VARIABLE conan_install_result
+    )
+
+    if (NOT conan_install_result EQUAL 0)
+      message(FATAL_ERROR "Conan install failed: ${conan_install_result}. Stderr: ${conan_stderr}. Stdout: ${conan_stdout}")
+    endif()
+  endif()
+endif()
+
 if (ENABLE_CLANG_TIDY)
   find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
   if(NOT CLANG_TIDY_COMMAND)
@@ -56,9 +79,6 @@ endif()
 if (POLICY CMP0074)
   cmake_policy(SET CMP0074 NEW)
 endif()
-if (POLICY CMP0167)
-  cmake_policy(SET CMP0167 NEW)
-endif()
 project(OSRM C CXX)
 
 
@@ -324,116 +344,75 @@ if (MSVC)
   add_definitions(-DBOOST_ALL_NO_LIB)
 endif()
 
-if(ENABLE_CONAN)
-  message(STATUS "Installing dependencies via Conan")
-
-  # Conan will generate Find*.cmake files to build directory, so we use them with the highest priority
-  list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_BINARY_DIR})
-  list(INSERT CMAKE_PREFIX_PATH 0 ${CMAKE_BINARY_DIR})
-
-  include(${CMAKE_CURRENT_LIST_DIR}/cmake/conan.cmake)
-
-  conan_check(REQUIRED)
-
-  set(CONAN_BOOST_VERSION "1.85.0@#14265ec82b25d91305bbb3b30d3357f8")
-  set(CONAN_BZIP2_VERSION "1.0.8@#d1b2d5816f25865acf978501dff1f897")
-  set(CONAN_EXPAT_VERSION "2.6.2@#2d385d0d50eb5561006a7ff9e356656b")
-  set(CONAN_LUA_VERSION "5.4.6@#658d6089093cf01992c2737ab2e96763")
-  set(CONAN_TBB_VERSION "2021.12.0@#e56e5b44be8d690530585dd3634c0106")
-
-  set(CONAN_SYSTEM_INCLUDES ON)
-
-
-  set(CONAN_ARGS
-    REQUIRES
-    "boost/${CONAN_BOOST_VERSION}"
-    "bzip2/${CONAN_BZIP2_VERSION}"
-    "expat/${CONAN_EXPAT_VERSION}"
-    "lua/${CONAN_LUA_VERSION}"
-    "onetbb/${CONAN_TBB_VERSION}"
-    BASIC_SETUP
-    GENERATORS cmake_find_package json  # json generator generates a conanbuildinfo.json in the build folder so (non-CMake) projects can easily parse OSRM's dependencies
-    KEEP_RPATHS
-    NO_OUTPUT_DIRS
-    OPTIONS boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
-    BUILD missing
-  )
-
-  # Enable revisions in the conan config
-  execute_process(COMMAND ${CONAN_CMD} config set general.revisions_enabled=1 RESULT_VARIABLE RET_CODE)
-  if(NOT "${RET_CODE}" STREQUAL "0")
-    message(FATAL_ERROR "Error setting revisions for Conan: '${RET_CODE}'")
-  endif()
-
-  # explicitly say Conan to use x86 dependencies if build for x86 platforms (https://github.com/conan-io/cmake-conan/issues/141)
-  if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-    conan_cmake_run("${CONAN_ARGS};ARCH;x86")
-  # cross-compilation for Apple Silicon
-  elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64" AND CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64")
-    conan_cmake_run("${CONAN_ARGS};ARCH;armv8")
-  else()
-    conan_cmake_run("${CONAN_ARGS}")
-  endif()
-
-  add_dependency_includes(${CONAN_INCLUDE_DIRS_BOOST})
-  add_dependency_includes(${CONAN_INCLUDE_DIRS_BZIP2})
-  add_dependency_includes(${CONAN_INCLUDE_DIRS_EXPAT})
-  add_dependency_includes(${CONAN_INCLUDE_DIRS_LUA})
-  add_dependency_includes(${CONAN_INCLUDE_DIRS_TBB})
 
+if (ENABLE_CONAN)
   set(Boost_USE_STATIC_LIBS ON)
   find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
-  set(Boost_DATE_TIME_LIBRARY "${Boost_date_time_LIB_TARGETS}")
-  set(Boost_PROGRAM_OPTIONS_LIBRARY "${Boost_program_options_LIB_TARGETS}")
-  set(Boost_IOSTREAMS_LIBRARY "${Boost_iostreams_LIB_TARGETS}")
-  set(Boost_THREAD_LIBRARY "${Boost_thread_LIB_TARGETS}")
-  set(Boost_ZLIB_LIBRARY "${Boost_zlib_LIB_TARGETS}")
-  set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY "${Boost_unit_test_framework_LIB_TARGETS}")
-
-
-  find_package(BZip2 REQUIRED)
-  find_package(EXPAT REQUIRED)
-  find_package(lua REQUIRED)
-  set(LUA_LIBRARIES ${lua_LIBRARIES})
-
   find_package(TBB REQUIRED)
+  find_package(EXPAT REQUIRED)
+  find_package(BZip2 REQUIRED)
+  find_package(Lua 5.2 REQUIRED)
 
-
-  # note: we avoid calling find_package(Osmium ...) here to ensure that the
-  # expat and bzip2 are used from conan rather than the system
-  include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include)
-else()
-  find_package(Boost 1.70 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
   add_dependency_includes(${Boost_INCLUDE_DIRS})
 
-  find_package(TBB REQUIRED)
+  set(BOOST_BASE_LIBRARIES ${Boost_LIBRARIES})
+  set(BOOST_ENGINE_LIBRARIES ${Boost_LIBRARIES})
+
   add_dependency_includes(${TBB_INCLUDE_DIR})
-  set(TBB_LIBRARIES TBB::tbb)
+  set(TBB_LIBRARIES ${TBB_LIBRARIES})
 
-  find_package(EXPAT REQUIRED)
+  add_dependency_includes(${expat_INCLUDE_DIRS})
-  add_dependency_includes(${EXPAT_INCLUDE_DIRS})
+  set(EXPAT_LIBRARIES ${expat_LIBRARIES})
+  set(EXPAT_INCLUDE_DIRS ${expat_INCLUDE_DIRS})
 
-  find_package(BZip2 REQUIRED)
   add_dependency_includes(${BZIP2_INCLUDE_DIR})
 
-  find_package(Lua 5.2 REQUIRED)
+  set(LUA_LIBRARIES lua::lua)
   if (LUA_FOUND)
     message(STATUS "Using Lua ${LUA_VERSION_STRING}")
   endif()
 
+  add_dependency_includes(${lua_INCLUDE_DIRS})
+
+  # note: we avoid calling find_package(Osmium ...) here to ensure that the
+  # expat and bzip2 are used from conan rather than the system
+  include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include)
+
+else()
+  find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
+  find_package(TBB REQUIRED)
+  find_package(EXPAT REQUIRED)
+  find_package(BZip2 REQUIRED)
+  find_package(Lua 5.2 REQUIRED)
+
+  add_dependency_includes(${Boost_INCLUDE_DIRS})
+  add_dependency_includes(${TBB_INCLUDE_DIR})
+  add_dependency_includes(${EXPAT_INCLUDE_DIRS})
+  add_dependency_includes(${BZIP2_INCLUDE_DIR})
   add_dependency_includes(${LUA_INCLUDE_DIR})
 
+  set(TBB_LIBRARIES TBB::tbb)
+
+  set(BOOST_BASE_LIBRARIES
+    ${Boost_DATE_TIME_LIBRARY}
+    ${Boost_IOSTREAMS_LIBRARY}
+    ${Boost_THREAD_LIBRARY})
+
+  set(BOOST_ENGINE_LIBRARIES
+    ${Boost_ZLIB_LIBRARY}
+    ${Boost_REGEX_LIBRARY}
+    ${BOOST_BASE_LIBRARIES})
+
   # add a target to generate API documentation with Doxygen
   find_package(Doxygen)
   if(DOXYGEN_FOUND)
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
-  add_custom_target(doc
+    add_custom_target(doc
-  ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+      ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
-  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-  COMMENT "Generating API documentation with Doxygen" VERBATIM
+      COMMENT "Generating API documentation with Doxygen" VERBATIM
-  )
+    )
   endif()
-
   # note libosmium depends on expat and bzip2
   list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/cmake")
   if(NOT OSMIUM_INCLUDE_DIR)
@@ -443,6 +422,8 @@ else()
   include_directories(SYSTEM ${OSMIUM_INCLUDE_DIR})
 endif()
 
+
+
 # prefix compilation with ccache by default if available and on clang or gcc
 if(ENABLE_CCACHE AND (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU"))
   find_program(CCACHE_FOUND ccache)
@@ -457,6 +438,7 @@ endif()
 # to ensure that osrm binaries play well with other binaries like nodejs
 find_package(ZLIB REQUIRED)
 add_dependency_includes(${ZLIB_INCLUDE_DIRS})
+set(ZLIB_LIBRARY ${ZLIB_LIBRARIES})
 
 add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
 add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
@@ -467,15 +449,6 @@ add_dependency_defines(-DBOOST_PHOENIX_STL_TUPLE_H_)
 add_definitions(${OSRM_DEFINES})
 include_directories(SYSTEM ${DEPENDENCIES_INCLUDE_DIRS})
 
-set(BOOST_BASE_LIBRARIES
-   ${Boost_DATE_TIME_LIBRARY}
-   ${Boost_IOSTREAMS_LIBRARY}
-   ${Boost_THREAD_LIBRARY})
-
-set(BOOST_ENGINE_LIBRARIES
-  ${Boost_ZLIB_LIBRARY}
-  ${Boost_REGEX_LIBRARY}
-  ${BOOST_BASE_LIBRARIES})
 
 # Binaries
 target_link_libraries(osrm-datastore osrm_store ${Boost_PROGRAM_OPTIONS_LIBRARY})
@@ -508,10 +481,10 @@ set(PARTITIONER_LIBRARIES
     ${CMAKE_THREAD_LIBS_INIT}
     ${TBB_LIBRARIES}
     ${MAYBE_RT_LIBRARY}
-    ${MAYBE_COVERAGE_LIBRARIES}
+    ${MAYBE_COVERAGE_LIBRARIES})
-    ${ZLIB_LIBRARY})
 set(CUSTOMIZER_LIBRARIES
     ${BOOST_ENGINE_LIBRARIES}
+    ${ZLIB_LIBRARY}
     ${CMAKE_THREAD_LIBS_INIT}
     ${TBB_LIBRARIES}
     ${MAYBE_RT_LIBRARY}
@@ -679,16 +652,17 @@ list(APPEND DEPENDENCIES_INCLUDE_DIRS "${PKGCONFIG_INCLUDE_DIR}")
 list(APPEND DEPENDENCIES_INCLUDE_DIRS "${PKGCONFIG_INCLUDE_DIR}/osrm")
 JOIN("-I${DEPENDENCIES_INCLUDE_DIRS}" " -I" PKGCONFIG_OSRM_INCLUDE_FLAGS)
 
-# Boost uses imported targets, we need to use a generator expression to extract
+
-# the link libraries to be written to the pkg-config file.
+if (NOT ENABLE_CONAN)
-# Conan & TBB define dependencies as CMake targets too, that's why we do the same for them.
+  foreach(engine_lib ${ENGINE_LIBRARIES})
-foreach(engine_lib ${ENGINE_LIBRARIES})
+    if("${engine_lib}" MATCHES "^boost.*" OR "${engine_lib}" MATCHES "^TBB.*")
-  if("${engine_lib}" MATCHES "^Boost.*" OR "${engine_lib}" MATCHES "^CONAN_LIB.*" OR "${engine_lib}" MATCHES "^TBB.*")
+      list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "$<TARGET_LINKER_FILE:${engine_lib}>")
-    list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "$<TARGET_LINKER_FILE:${engine_lib}>")
+    else()
-  else()
+      list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "${engine_lib}")
-    list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "${engine_lib}")
+    endif()
-  endif()
+  endforeach(engine_lib)
-endforeach(engine_lib)
+endif()
+
 JOIN("${PKGCONFIG_DEPENDENT_LIBRARIES}" " " PKGCONFIG_OSRM_DEPENDENT_LIBRARIES)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in pkgconfig.configured @ONLY)

conanfile.py

@@ -0,0 +1,31 @@
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain, CMakeDeps
+
+class OsrmConan(ConanFile):
+    settings = "os", "compiler", "build_type", "arch"
+    generators = "CMakeDeps"
+
+    def requirements(self):
+        self.requires("boost/1.85.0")
+        self.requires("bzip2/1.0.8")
+        self.requires("expat/2.6.2")
+        self.requires("lua/5.4.6")
+        self.requires("onetbb/2021.12.0")
+        if self.settings.os == "Windows":
+            self.requires("zlib/1.3.1")
+    
+    def configure(self):
+        self.options["boost"].without_python = True
+        self.options["boost"].without_coroutine = True
+        self.options["boost"].without_stacktrace = True
+        self.options["boost"].without_cobalt = True
+        
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["CMAKE_CXX_STANDARD"] = "20"
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()

docker/Dockerfile-alpine

@@ -1,34 +1,20 @@
-FROM alpine:3.21.2 AS alpine-mimalloc
+FROM alpine:3.20.0 as alpine-mimalloc
 
-RUN apk update && \
+RUN apk add --no-cache mimalloc
-    apk upgrade && \
-    apk add --no-cache \
-        boost-iostreams \
-        boost-program_options \
-        boost-thread \
-        mimalloc
 
 ENV LD_PRELOAD=/usr/lib/libmimalloc.so.2
 ENV MIMALLOC_LARGE_OS_PAGES=1
 
 
-FROM alpine-mimalloc AS builder
+FROM alpine-mimalloc as builder
 ARG DOCKER_TAG
 ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
 
-RUN mkdir -p /src /opt && \
+RUN apk add --no-cache \
-    apk add --no-cache \
+    cmake make git clang libbz2 libxml2 \
-    boost-dev \
+    boost-dev boost-program_options boost-filesystem boost-iostreams boost-thread \
-    boost-filesystem \
+    lua5.4-dev onetbb-dev expat-dev
-    clang \
-    cmake \
-    expat-dev \
-    git \
-    libbz2 \
-    libxml2 \
-    lua5.4-dev \
-    make \
-    onetbb-dev
 
 COPY . /src
 WORKDIR /src
@@ -53,18 +39,16 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
     rm -rf /src
 
 
-# Multistage build to reduce image size - https://docs.docker.com/build/building/multi-stage/#use-multi-stage-builds
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM alpine-mimalloc AS runstage
+FROM alpine-mimalloc as runstage
 
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
 
 RUN apk add --no-cache \
-    boost-date_time \
+    boost-program_options boost-date_time boost-iostreams boost-thread \
-    expat \
+    expat lua5.4 onetbb && \
-    lua5.4 \
-    onetbb && \
     ldconfig /usr/local/lib
 
 RUN /usr/local/bin/osrm-extract --help && \
@@ -76,4 +60,3 @@ RUN /usr/local/bin/osrm-extract --help && \
 WORKDIR /opt
 
 EXPOSE 5000
-

docker/Dockerfile-debian

@@ -1,24 +1,21 @@
-FROM debian:bookworm-slim AS builder
+FROM debian:bookworm-slim as builder
 ARG DOCKER_TAG
 ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
 
-RUN mkdir -p /src /opt && \
+RUN apt-get update && \
-    apt-get update && \
+    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
-    apt-get -y --no-install-recommends --no-install-suggests install \
+    libzip-dev libboost1.81-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
-        ca-certificates \
+
-        cmake \
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-        g++ \
+    ldconfig /usr/local/lib && \
-        gcc \
+    git clone --branch v2021.12.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
-        git \
+    cd oneTBB && \
-        libboost1.81-all-dev \
+    mkdir build && \
-        libbz2-dev \
+    cd build && \
-        liblua5.4-dev \
+    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
-        libtbb-dev \
+    cmake --build . && \
-        libxml2-dev \
+    cmake --install .
-        libzip-dev \
-        lua5.4 \
-        make \
-        pkg-config
 
 COPY . /src
 WORKDIR /src
@@ -44,24 +41,19 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
     rm -rf /src
 
 
-# Multistage build to reduce image size - https://docs.docker.com/build/building/multi-stage/#use-multi-stage-builds
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM debian:bookworm-slim AS runstage
+FROM debian:bookworm-slim as runstage
 
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
 
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends --no-install-suggests \
+    apt-get install -y --no-install-recommends \
-        expat \
+        libboost-program-options1.81.0 libboost-date-time1.81.0 libboost-iostreams1.81.0 libboost-thread1.81.0 \
-        libboost-date-time1.81.0 \
+        expat liblua5.4-0 && \
-        libboost-iostreams1.81.0 \
-        libboost-program-options1.81.0 \
-        libboost-thread1.81.0 \
-        liblua5.4-0 \
-        libtbb12 && \
     rm -rf /var/lib/apt/lists/* && \
-# Add /usr/local/lib to ldconfig to allow loading libraries from there
+# add /usr/local/lib to ldconfig to allow loading libraries from there
     ldconfig /usr/local/lib
 
 RUN /usr/local/bin/osrm-extract --help && \
@@ -73,4 +65,3 @@ RUN /usr/local/bin/osrm-extract --help && \
 WORKDIR /opt
 
 EXPOSE 5000
-

example/CMakeLists.txt

@@ -12,7 +12,7 @@ endif()
 
 project(osrm-example C CXX)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 

include/customizer/cell_customizer.hpp

@@ -100,9 +100,9 @@ class CellCustomizer
                 distances.front() =
                     inserted ? heap.GetData(destination).distance : INVALID_EDGE_DISTANCE;
 
-                weights.advance(1);
+                weights.advance_begin(1);
-                durations.advance(1);
+                durations.advance_begin(1);
-                distances.advance(1);
+                distances.advance_begin(1);
             }
             BOOST_ASSERT(weights.empty());
             BOOST_ASSERT(durations.empty());

include/engine/api/nearest_api.hpp

@@ -136,7 +136,7 @@ class NearestAPI final : public BaseAPI
             forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id);
 
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(forward_geometry[phantom_node.fwd_segment_position]);
+                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position));
             to_node = static_cast<std::uint64_t>(osm_node_id);
         }
 
@@ -146,14 +146,14 @@ class NearestAPI final : public BaseAPI
             const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
             const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id);
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(geometry[phantom_node.fwd_segment_position + 1]);
+                facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1));
             from_node = static_cast<std::uint64_t>(osm_node_id);
         }
         else if (phantom_node.forward_segment_id.enabled && phantom_node.fwd_segment_position > 0)
         {
             // In the case of one way, rely on forward segment only
             auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(forward_geometry[phantom_node.fwd_segment_position - 1]);
+                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position - 1));
             from_node = static_cast<std::uint64_t>(osm_node_id);
         }
 

include/engine/base64.hpp

@@ -13,6 +13,7 @@
 #include <boost/archive/iterators/base64_from_binary.hpp>
 #include <boost/archive/iterators/binary_from_base64.hpp>
 #include <boost/archive/iterators/transform_width.hpp>
+#include <boost/range/algorithm/copy.hpp>
 
 namespace osrm
 {

include/engine/datafacade/datafacade_base.hpp

@@ -29,11 +29,13 @@
 #include "util/typedefs.hpp"
 
 #include "osrm/coordinate.hpp"
+
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/any_range.hpp>
 #include <cstddef>
 
 #include <engine/bearing.hpp>
 #include <optional>
-#include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -48,21 +50,20 @@ class BaseDataFacade
     using RTreeLeaf = extractor::EdgeBasedNodeSegment;
 
     using NodeForwardRange =
-        std::ranges::subrange<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
+        boost::iterator_range<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
-    using NodeReverseRange = std::ranges::reverse_view<NodeForwardRange>;
+    using NodeReverseRange = boost::reversed_range<const NodeForwardRange>;
 
     using WeightForwardRange =
-        std::ranges::subrange<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
+        boost::iterator_range<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
-
+    using WeightReverseRange = boost::reversed_range<const WeightForwardRange>;
-    using WeightReverseRange = std::ranges::reverse_view<WeightForwardRange>;
 
     using DurationForwardRange =
-        std::ranges::subrange<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
+        boost::iterator_range<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
-    using DurationReverseRange = std::ranges::reverse_view<DurationForwardRange>;
+    using DurationReverseRange = boost::reversed_range<const DurationForwardRange>;
 
     using DatasourceForwardRange =
-        std::ranges::subrange<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
+        boost::iterator_range<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
-    using DatasourceReverseRange = std::ranges::reverse_view<DatasourceForwardRange>;
+    using DatasourceReverseRange = boost::reversed_range<const DatasourceForwardRange>;
 
     BaseDataFacade() {}
     virtual ~BaseDataFacade() {}

include/engine/geospatial_query.hpp

@@ -394,7 +394,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             alias_cast<EdgeDuration>(forward_durations[data.fwd_segment_position]);
         EdgeDistance forward_distance =
             to_alias<EdgeDistance>(util::coordinate_calculation::greatCircleDistance(
-                datafacade.GetCoordinateOfNode(forward_geometry[data.fwd_segment_position]),
+                datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position)),
                 point_on_segment));
 
         const auto reverse_weight_offset = alias_cast<EdgeWeight>(
@@ -426,7 +426,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         EdgeDistance reverse_distance =
             to_alias<EdgeDistance>(util::coordinate_calculation::greatCircleDistance(
                 point_on_segment,
-                datafacade.GetCoordinateOfNode(forward_geometry[data.fwd_segment_position + 1])));
+                datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position + 1))));
 
         ratio = std::min(1.0, std::max(0.0, ratio));
         if (data.forward_segment_id.id != SPECIAL_SEGMENTID)

include/engine/guidance/assemble_geometry.hpp

@@ -61,7 +61,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
     const auto source_geometry_id = facade.GetGeometryIndex(source_node_id).id;
     const auto source_geometry = facade.GetUncompressedForwardGeometry(source_geometry_id);
 
-    geometry.node_ids.push_back(source_geometry[source_segment_start_coordinate]);
+    geometry.node_ids.push_back(source_geometry(source_segment_start_coordinate));
 
     auto cumulative_distance = 0.;
     auto current_distance = 0.;
@@ -142,7 +142,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
             LegGeometry::Annotation{current_distance,
                                     duration,
                                     weight,
-                                    forward_datasources[target_node.fwd_segment_position]});
+                                    forward_datasources(target_node.fwd_segment_position)});
     }
     else
     {
@@ -154,7 +154,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
             from_alias<double>(reversed_target ? target_node.reverse_weight
                                                : target_node.forward_weight) /
                 facade.GetWeightMultiplier(),
-            forward_datasources[target_node.fwd_segment_position]});
+            forward_datasources(target_node.fwd_segment_position)});
     }
 
     geometry.segment_offsets.push_back(geometry.locations.size());
@@ -168,7 +168,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
     const auto target_segment_end_coordinate =
         target_node.fwd_segment_position + (reversed_target ? 0 : 1);
     const auto target_geometry = facade.GetUncompressedForwardGeometry(target_geometry_id);
-    geometry.node_ids.push_back(target_geometry[target_segment_end_coordinate]);
+    geometry.node_ids.push_back(target_geometry(target_segment_end_coordinate));
 
     BOOST_ASSERT(geometry.segment_distances.size() == geometry.segment_offsets.size() - 1);
     BOOST_ASSERT(geometry.locations.size() > geometry.segment_distances.size());

include/engine/guidance/route_step.hpp

@@ -14,7 +14,7 @@
 #include <string>
 #include <vector>
 
-#include <ranges>
+#include <boost/range/iterator_range.hpp>
 
 namespace osrm::engine::guidance
 {
@@ -220,14 +220,14 @@ inline auto RouteStep::LanesToTheLeft() const
 {
     const auto &description = intersections.front().lane_description;
     LaneID num_lanes_left = NumLanesToTheLeft();
-    return std::ranges::subrange(description.begin(), description.begin() + num_lanes_left);
+    return boost::make_iterator_range(description.begin(), description.begin() + num_lanes_left);
 }
 
 inline auto RouteStep::LanesToTheRight() const
 {
     const auto &description = intersections.front().lane_description;
     LaneID num_lanes_right = NumLanesToTheRight();
-    return std::ranges::subrange(description.end() - num_lanes_right, description.end());
+    return boost::make_iterator_range(description.end() - num_lanes_right, description.end());
 }
 
 } // namespace osrm::engine::guidance

include/extractor/class_data.hpp

@@ -6,8 +6,6 @@
 #include <algorithm>
 #include <cctype>
 #include <cstdint>
-#include <limits>
-#include <string>
 
 namespace osrm::extractor
 {

include/extractor/node_restriction_map.hpp

@@ -5,6 +5,8 @@
 #include "restriction_graph.hpp"
 #include "util/typedefs.hpp"
 
+#include <boost/range/adaptor/filtered.hpp>
+
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ -24,7 +26,7 @@ template <typename RestrictionFilter> class NodeRestrictionMap
     // Find all restrictions applicable to (from,via,*) turns
     auto Restrictions(NodeID from, NodeID via) const
     {
-        return getRange(from, via) | std::views::filter(index_filter);
+        return getRange(from, via) | boost::adaptors::filtered(index_filter);
     };
 
     // Find all restrictions applicable to (from,via,to) turns
@@ -32,7 +34,7 @@ template <typename RestrictionFilter> class NodeRestrictionMap
     {
         const auto turnFilter = [this, to](const auto &restriction)
         { return index_filter(restriction) && restriction->IsTurnRestricted(to); };
-        return getRange(from, via) | std::views::filter(turnFilter);
+        return getRange(from, via) | boost::adaptors::filtered(turnFilter);
     };
 
   private:

include/extractor/restriction_graph.hpp

@@ -6,7 +6,7 @@
 #include "util/node_based_graph.hpp"
 #include "util/std_hash.hpp"
 #include "util/typedefs.hpp"
-#include <ranges>
+
 #include <unordered_map>
 
 namespace osrm::extractor
@@ -102,9 +102,9 @@ struct RestrictionGraph
     friend restriction_graph_details::transferBuilder;
     friend RestrictionGraph constructRestrictionGraph(const std::vector<TurnRestriction> &);
 
-    using EdgeRange = std::ranges::subrange<std::vector<RestrictionEdge>::const_iterator>;
+    using EdgeRange = boost::iterator_range<std::vector<RestrictionEdge>::const_iterator>;
     using RestrictionRange =
-        std::ranges::subrange<std::vector<const TurnRestriction *>::const_iterator>;
+        boost::iterator_range<std::vector<const TurnRestriction *>::const_iterator>;
     using EdgeKey = std::pair<NodeID, NodeID>;
 
     // Helper functions for iterating over node restrictions and edges

include/extractor/segment_data_container.hpp

@@ -7,8 +7,11 @@
 
 #include "storage/shared_memory_ownership.hpp"
 #include "storage/tar_fwd.hpp"
+
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/iterator_range.hpp>
+
 #include <filesystem>
-#include <ranges>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -76,12 +79,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = nodes.begin() + index[id];
         const auto end = nodes.begin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseGeometry(const DirectionalGeometryID id)
     {
-        return GetForwardGeometry(id) | std::views::reverse;
+        return boost::adaptors::reverse(GetForwardGeometry(id));
     }
 
     auto GetForwardDurations(const DirectionalGeometryID id)
@@ -89,7 +92,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_durations.begin() + index[id] + 1;
         const auto end = fwd_durations.begin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDurations(const DirectionalGeometryID id)
@@ -97,7 +100,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_durations.begin() + index[id];
         const auto end = rev_durations.begin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardWeights(const DirectionalGeometryID id)
@@ -105,7 +108,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_weights.begin() + index[id] + 1;
         const auto end = fwd_weights.begin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseWeights(const DirectionalGeometryID id)
@@ -113,7 +116,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_weights.begin() + index[id];
         const auto end = rev_weights.begin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardDatasources(const DirectionalGeometryID id)
@@ -121,7 +124,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_datasources.begin() + index[id] + 1;
         const auto end = fwd_datasources.begin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDatasources(const DirectionalGeometryID id)
@@ -129,7 +132,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_datasources.begin() + index[id];
         const auto end = rev_datasources.begin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardGeometry(const DirectionalGeometryID id) const
@@ -137,12 +140,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = nodes.cbegin() + index[id];
         const auto end = nodes.cbegin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseGeometry(const DirectionalGeometryID id) const
     {
-        return GetForwardGeometry(id) | std::views::reverse;
+        return boost::adaptors::reverse(GetForwardGeometry(id));
     }
 
     auto GetForwardDurations(const DirectionalGeometryID id) const
@@ -150,7 +153,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_durations.cbegin() + index[id] + 1;
         const auto end = fwd_durations.cbegin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDurations(const DirectionalGeometryID id) const
@@ -158,7 +161,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_durations.cbegin() + index[id];
         const auto end = rev_durations.cbegin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardWeights(const DirectionalGeometryID id) const
@@ -166,7 +169,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_weights.cbegin() + index[id] + 1;
         const auto end = fwd_weights.cbegin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseWeights(const DirectionalGeometryID id) const
@@ -174,7 +177,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_weights.cbegin() + index[id];
         const auto end = rev_weights.cbegin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetForwardDatasources(const DirectionalGeometryID id) const
@@ -182,7 +185,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = fwd_datasources.cbegin() + index[id] + 1;
         const auto end = fwd_datasources.cbegin() + index[id + 1];
 
-        return std::ranges::subrange(begin, end);
+        return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDatasources(const DirectionalGeometryID id) const
@@ -190,7 +193,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
         const auto begin = rev_datasources.cbegin() + index[id];
         const auto end = rev_datasources.cbegin() + index[id + 1] - 1;
 
-        return std::ranges::subrange(begin, end) | std::views::reverse;
+        return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
 
     auto GetNumberOfGeometries() const { return index.size() - 1; }

include/nodejs/json_v8_renderer.hpp

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

include/partitioner/bisection_graph_view.hpp

@@ -5,7 +5,7 @@
 
 #include <boost/iterator/filter_iterator.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <ranges>
+#include <boost/range/iterator_range.hpp>
 
 #include <cstddef>
 #include <cstdint>
@@ -40,7 +40,7 @@ class BisectionGraphView
     // Iteration over all nodes (direct access into the node)
     ConstNodeIterator Begin() const;
     ConstNodeIterator End() const;
-    auto Nodes() const { return std::ranges::subrange(begin, end); }
+    auto Nodes() const { return boost::make_iterator_range(begin, end); }
 
     // Re-Construct the ID of a node from a reference
     NodeID GetID(const NodeT &node) const;

include/partitioner/cell_storage.hpp

@@ -14,7 +14,9 @@
 
 #include "customizer/cell_metric.hpp"
 
-#include <ranges>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/range/iterator_range.hpp>
+
 #include <tbb/parallel_sort.h>
 
 #include <algorithm>
@@ -126,19 +128,19 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
             friend class ::boost::iterator_core_access;
             ValuePtrT current;
-            std::size_t stride;
+            const std::size_t stride;
         };
 
         template <typename ValuePtr> auto GetOutRange(const ValuePtr ptr, const NodeID node) const
         {
             auto iter = std::find(source_boundary, source_boundary + num_source_nodes, node);
             if (iter == source_boundary + num_source_nodes)
-                return std::ranges::subrange(ptr, ptr);
+                return boost::make_iterator_range(ptr, ptr);
 
             auto row = std::distance(source_boundary, iter);
             auto begin = ptr + num_destination_nodes * row;
             auto end = begin + num_destination_nodes;
-            return std::ranges::subrange(begin, end);
+            return boost::make_iterator_range(begin, end);
         }
 
         template <typename ValuePtr> auto GetInRange(const ValuePtr ptr, const NodeID node) const
@@ -146,14 +148,14 @@ template <storage::Ownership Ownership> class CellStorageImpl
             auto iter =
                 std::find(destination_boundary, destination_boundary + num_destination_nodes, node);
             if (iter == destination_boundary + num_destination_nodes)
-                return std::ranges::subrange(ColumnIterator<ValuePtr>{},
+                return boost::make_iterator_range(ColumnIterator<ValuePtr>{},
-                                             ColumnIterator<ValuePtr>{});
+                                                  ColumnIterator<ValuePtr>{});
 
             auto column = std::distance(destination_boundary, iter);
             auto begin = ColumnIterator<ValuePtr>{ptr + column, num_destination_nodes};
             auto end = ColumnIterator<ValuePtr>{
                 ptr + column + num_source_nodes * num_destination_nodes, num_destination_nodes};
-            return std::ranges::subrange(begin, end);
+            return boost::make_iterator_range(begin, end);
         }
 
       public:
@@ -171,13 +173,13 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
         auto GetSourceNodes() const
         {
-            return std::ranges::subrange(source_boundary, source_boundary + num_source_nodes);
+            return boost::make_iterator_range(source_boundary, source_boundary + num_source_nodes);
         }
 
         auto GetDestinationNodes() const
         {
-            return std::ranges::subrange(destination_boundary,
+            return boost::make_iterator_range(destination_boundary,
-                                         destination_boundary + num_destination_nodes);
+                                              destination_boundary + num_destination_nodes);
         }
 
         CellImpl(const CellData &data,

include/partitioner/multi_level_partition.hpp

@@ -18,7 +18,7 @@
 #include <numeric>
 #include <vector>
 
-#include <ranges>
+#include <boost/range/adaptor/reversed.hpp>
 
 namespace osrm::partitioner
 {
@@ -281,7 +281,7 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
 
         // top down assign new cell ids
         LevelID level = partitions.size();
-        for (const auto &partition : std::ranges::reverse_view(partitions))
+        for (const auto &partition : boost::adaptors::reverse(partitions))
         {
             BOOST_ASSERT(permutation.size() > 0);
             CellID last_cell_id = partition[permutation.front()];

include/partitioner/partition_graph.hpp

@@ -8,7 +8,8 @@
 #include <vector>
 
 #include "util/typedefs.hpp"
-#include <ranges>
+#include <boost/range/iterator_range.hpp>
+
 namespace osrm::partitioner
 {
 
@@ -83,26 +84,26 @@ template <typename NodeEntryT, typename EdgeEntryT> class RemappableGraph
 
     auto Edges(const NodeID nid)
     {
-        return std::ranges::subrange(edges.begin() + nodes[nid].edges_begin,
+        return boost::make_iterator_range(edges.begin() + nodes[nid].edges_begin,
-                                     edges.begin() + nodes[nid].edges_end);
+                                          edges.begin() + nodes[nid].edges_end);
     }
 
     auto Edges(const NodeID nid) const
     {
-        return std::ranges::subrange(edges.begin() + nodes[nid].edges_begin,
+        return boost::make_iterator_range(edges.begin() + nodes[nid].edges_begin,
-                                     edges.begin() + nodes[nid].edges_end);
+                                          edges.begin() + nodes[nid].edges_end);
     }
 
     auto Edges(const NodeT &node)
     {
-        return std::ranges::subrange(edges.begin() + node.edges_begin,
+        return boost::make_iterator_range(edges.begin() + node.edges_begin,
-                                     edges.begin() + node.edges_end);
+                                          edges.begin() + node.edges_end);
     }
 
     auto Edges(const NodeT &node) const
     {
-        return std::ranges::subrange(edges.begin() + node.edges_begin,
+        return boost::make_iterator_range(edges.begin() + node.edges_begin,
-                                     edges.begin() + node.edges_end);
+                                          edges.begin() + node.edges_end);
     }
 
     auto BeginEdges(const NodeID nid) const { return edges.begin() + nodes[nid].edges_begin; }
@@ -117,8 +118,8 @@ template <typename NodeEntryT, typename EdgeEntryT> class RemappableGraph
     EdgeID EndEdgeID(const NodeID nid) const { return nodes[nid].edges_end; }
 
     // iterate over all nodes
-    auto Nodes() { return std::ranges::subrange(nodes.begin(), nodes.end()); }
+    auto Nodes() { return boost::make_iterator_range(nodes.begin(), nodes.end()); }
-    auto Nodes() const { return std::ranges::subrange(nodes.begin(), nodes.end()); }
+    auto Nodes() const { return boost::make_iterator_range(nodes.begin(), nodes.end()); }
 
     NodeID GetID(const NodeT &node) const
     {

include/util/bit_range.hpp

@@ -4,7 +4,7 @@
 #include "util/msb.hpp"
 #include <bit>
 #include <boost/iterator/iterator_facade.hpp>
-#include <ranges>
+#include <boost/range/iterator_range.hpp>
 
 namespace osrm::util
 {
@@ -58,7 +58,7 @@ class BitIterator : public boost::iterator_facade<BitIterator<DataT>,
 // Returns range over all 1 bits of value
 template <typename T> auto makeBitRange(const T value)
 {
-    return std::ranges::subrange(BitIterator<T>{value}, BitIterator<T>{});
+    return boost::make_iterator_range(BitIterator<T>{value}, BitIterator<T>{});
 }
 } // namespace osrm::util
 

include/util/json_container.hpp

@@ -104,7 +104,7 @@ using Value = std::variant<String, Number, Object, Array, True, False, Null>;
  */
 struct Object
 {
-    std::unordered_map<std::string_view, Value> values;
+    std::unordered_map<std::string, Value> values;
 };
 
 /**

include/util/json_deep_compare.hpp

@@ -44,13 +44,13 @@ struct Comparator
 
     bool operator()(const Object &lhs, const Object &rhs) const
     {
-        std::set<std::string_view> lhs_keys;
+        std::set<std::string> lhs_keys;
         for (const auto &key_value : lhs.values)
         {
             lhs_keys.insert(key_value.first);
         }
 
-        std::set<std::string_view> rhs_keys;
+        std::set<std::string> rhs_keys;
         for (const auto &key_value : rhs.values)
         {
             rhs_keys.insert(key_value.first);
@@ -60,7 +60,7 @@ struct Comparator
         {
             if (rhs_keys.find(key) == rhs_keys.end())
             {
-                reason = rhs_path + " doesn't have key \"" + std::string(key) + "\"";
+                reason = rhs_path + " doesn't have key \"" + key + "\"";
                 return false;
             }
         }
@@ -69,7 +69,7 @@ struct Comparator
         {
             if (lhs_keys.find(key) == lhs_keys.end())
             {
-                reason = lhs_path + " doesn't have key \"" + std::string(key) + "\"";
+                reason = lhs_path + " doesn't have key \"" + key + "\"";
                 return false;
             }
         }
@@ -81,11 +81,10 @@ struct Comparator
 
             const auto &rhs_child = rhs.values.find(key)->second;
             const auto &lhs_child = lhs.values.find(key)->second;
-            auto is_same = std::visit(Comparator(reason,
+            auto is_same =
-                                                 lhs_path + "." + std::string(key),
+                std::visit(Comparator(reason, lhs_path + "." + key, rhs_path + "." + key),
-                                                 rhs_path + "." + std::string(key)),
+                           lhs_child,
-                                      lhs_child,
+                           rhs_child);
-                                      rhs_child);
             if (!is_same)
             {
                 return false;

include/util/json_renderer.hpp

@@ -97,7 +97,7 @@ template <typename Out> struct Renderer
     void operator()(const Null &) { write<>("null"); }
 
   private:
-    void write(std::string_view str);
+    void write(const std::string &str);
     void write(const char *str, size_t size);
     void write(char ch);
 
@@ -110,7 +110,7 @@ template <typename Out> struct Renderer
     Out &out;
 };
 
-template <> void Renderer<std::vector<char>>::write(std::string_view str)
+template <> void Renderer<std::vector<char>>::write(const std::string &str)
 {
     out.insert(out.end(), str.begin(), str.end());
 }
@@ -122,7 +122,7 @@ template <> void Renderer<std::vector<char>>::write(const char *str, size_t size
 
 template <> void Renderer<std::vector<char>>::write(char ch) { out.push_back(ch); }
 
-template <> void Renderer<std::ostream>::write(std::string_view str) { out << str; }
+template <> void Renderer<std::ostream>::write(const std::string &str) { out << str; }
 
 template <> void Renderer<std::ostream>::write(const char *str, size_t size)
 {
@@ -131,7 +131,7 @@ template <> void Renderer<std::ostream>::write(const char *str, size_t size)
 
 template <> void Renderer<std::ostream>::write(char ch) { out << ch; }
 
-template <> void Renderer<std::string>::write(std::string_view str) { out += str; }
+template <> void Renderer<std::string>::write(const std::string &str) { out += str; }
 
 template <> void Renderer<std::string>::write(const char *str, size_t size)
 {

include/util/packed_vector.hpp

@@ -340,8 +340,6 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         {
         }
 
-        ReferenceT operator[](difference_type n) const { return container->operator[](index + n); }
-
       private:
         void increment() { ++index; }
         void decrement() { --index; }

include/util/vector_view.hpp

@@ -42,8 +42,6 @@ class VectorViewIterator : public boost::iterator_facade<VectorViewIterator<Data
     explicit VectorViewIterator() : m_value(nullptr) {}
     explicit VectorViewIterator(DataT *x) : m_value(x) {}
 
-    reference operator[](difference_type n) const { return m_value[n]; }
-
   private:
     void increment() { ++m_value; }
     void decrement() { --m_value; }

scripts/ci/run_benchmarks.sh

@@ -93,7 +93,7 @@ function run_benchmarks_for_folder {
             echo "Took: ${DIFF}s"
         done
     done
-
+    
     for ALGORITHM in ch mld; do
         for BENCH in nearest table trip route match; do
             echo "Running random $BENCH $ALGORITHM"

src/benchmarks/json_render.cpp

@@ -9,17 +9,12 @@
 #include <rapidjson/document.h>
 #include <sstream>
 #include <stdexcept>
-#include <unordered_set>
 
 using namespace osrm;
 
 namespace
 {
 
-// we use std::string_view as a key in the object, so since here we have dynamic keys we have to
-// "hold" them somewhere okay for tests...
-static std::unordered_set<std::string> gKeysHolder;
-
 void convert(const rapidjson::Value &value, json::Value &result)
 {
     if (value.IsString())
@@ -37,8 +32,7 @@ void convert(const rapidjson::Value &value, json::Value &result)
         {
             json::Value member;
             convert(itr->value, member);
-            auto keyItr = gKeysHolder.emplace(itr->name.GetString()).first;
+            object.values.emplace(itr->name.GetString(), std::move(member));
-            object.values.emplace(*keyItr, std::move(member));
         }
         result = std::move(object);
     }
@@ -128,7 +122,6 @@ int main(int argc, char **argv)
 
     if (std::string{out_vec.begin(), out_vec.end()} != out_str || out_str != out_ss_str)
     {
-        std::cerr << "Vector/string results are not equal\n";
         throw std::logic_error("Vector/stringstream/string results are not equal");
     }
     return EXIT_SUCCESS;

src/engine/guidance/post_processing.cpp

@@ -13,6 +13,7 @@
 
 #include <boost/assert.hpp>
 #include <boost/numeric/conversion/cast.hpp>
+#include <boost/range/iterator_range.hpp>
 
 #include <algorithm>
 #include <cmath>

src/engine/plugins/tile.cpp

@@ -482,10 +482,9 @@ void encodeVectorTile(const DataFacadeBase &facade,
                         reverse_duration_range[reverse_duration_range.size() -
                                                edge.fwd_segment_position - 1];
                     const auto forward_datasource_idx =
-                        forward_datasource_range[edge.fwd_segment_position];
+                        forward_datasource_range(edge.fwd_segment_position);
-                    const auto reverse_datasource_idx =
+                    const auto reverse_datasource_idx = reverse_datasource_range(
-                        reverse_datasource_range[reverse_datasource_range.size() -
+                        reverse_datasource_range.size() - edge.fwd_segment_position - 1);
-                                                 edge.fwd_segment_position - 1];
 
                     const auto is_startpoint = edge.is_startpoint;
 

src/engine/routing_algorithms/many_to_many_ch.cpp

@@ -2,7 +2,7 @@
 #include "engine/routing_algorithms/routing_base_ch.hpp"
 
 #include <boost/assert.hpp>
-#include <ranges>
+#include <boost/range/iterator_range_core.hpp>
 
 #include <limits>
 #include <memory>
@@ -106,7 +106,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                                                search_space_with_buckets.end(),
                                                heapNode.node,
                                                NodeBucket::Compare());
-    for (const auto &current_bucket : std::ranges::subrange(bucket_list.first, bucket_list.second))
+    for (const auto &current_bucket : boost::make_iterator_range(bucket_list))
     {
         // Get target id from bucket entry
         const auto column_index = current_bucket.column_index;

src/engine/routing_algorithms/many_to_many_mld.cpp

@@ -2,7 +2,7 @@
 #include "engine/routing_algorithms/routing_base_mld.hpp"
 
 #include <boost/assert.hpp>
-#include <ranges>
+#include <boost/range/iterator_range_core.hpp>
 
 #include <limits>
 #include <memory>
@@ -148,8 +148,8 @@ void relaxOutgoingEdges(
                     }
                 }
                 ++destination;
-                shortcut_durations.advance(1);
+                shortcut_durations.advance_begin(1);
-                shortcut_distances.advance(1);
+                shortcut_distances.advance_begin(1);
             }
             BOOST_ASSERT(shortcut_durations.empty());
             BOOST_ASSERT(shortcut_distances.empty());
@@ -169,8 +169,8 @@ void relaxOutgoingEdges(
                 if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
                     const auto to_weight = heapNode.weight + shortcut_weight;
-                    const auto to_duration = heapNode.data.duration + *shortcut_durations.begin();
+                    const auto to_duration = heapNode.data.duration + shortcut_durations.front();
-                    const auto to_distance = heapNode.data.distance + *shortcut_distances.begin();
+                    const auto to_distance = heapNode.data.distance + shortcut_distances.front();
                     const auto toHeapNode = query_heap.GetHeapNodeIfWasInserted(to);
                     if (!toHeapNode)
                     {
@@ -189,8 +189,8 @@ void relaxOutgoingEdges(
                     }
                 }
                 ++source;
-                shortcut_durations.advance(1);
+                shortcut_durations.advance_begin(1);
-                shortcut_distances.advance(1);
+                shortcut_distances.advance_begin(1);
             }
             BOOST_ASSERT(shortcut_durations.empty());
             BOOST_ASSERT(shortcut_distances.empty());
@@ -426,7 +426,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                                                search_space_with_buckets.end(),
                                                heapNode.node,
                                                NodeBucket::Compare());
-    for (const auto &current_bucket : std::ranges::subrange(bucket_list.first, bucket_list.second))
+    for (const auto &current_bucket : boost::make_iterator_range(bucket_list))
     {
         // Get target id from bucket entry
         const auto column_idx = current_bucket.column_index;

src/extractor/edge_based_graph_factory.cpp

@@ -968,8 +968,11 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                 buffer->continuous_data.push_back(edge_with_data);
 
                                 // get conditional restrictions that apply to this turn
-                                auto restrictions = conditional_node_restriction_map.Restrictions(
+                                const auto &restrictions =
-                                    incoming_edge.node, outgoing_edge.node, outgoing_edge_target);
+                                    conditional_node_restriction_map.Restrictions(
+                                        incoming_edge.node,
+                                        outgoing_edge.node,
+                                        outgoing_edge_target);
                                 for (const auto &restriction : restrictions)
                                 {
                                     buffer->conditionals.push_back(

src/extractor/intersection/intersection_analysis.cpp

@@ -424,11 +424,13 @@ double findEdgeLength(const IntersectionEdgeGeometries &geometries, const EdgeID
 }
 
 template <typename RestrictionsRange>
-bool isTurnRestricted(RestrictionsRange restrictions, const NodeID to)
+bool isTurnRestricted(const RestrictionsRange &restrictions, const NodeID to)
 {
     // Check if any of the restrictions would prevent a turn to 'to'
-    return std::ranges::any_of(
+    return std::any_of(restrictions.begin(),
-        restrictions, [&to](const auto &restriction) { return restriction->IsTurnRestricted(to); });
+                       restrictions.end(),
+                       [&to](const auto &restriction)
+                       { return restriction->IsTurnRestricted(to); });
 }
 
 bool isTurnAllowed(const util::NodeBasedDynamicGraph &graph,

src/extractor/restriction_graph.cpp

@@ -5,6 +5,8 @@
 #include "util/timing_util.hpp"
 #include <util/for_each_pair.hpp>
 
+#include <boost/range/algorithm/copy.hpp>
+
 namespace osrm::extractor
 {
 
@@ -274,16 +276,16 @@ RestrictionGraph constructRestrictionGraph(const std::vector<TurnRestriction> &t
 RestrictionGraph::RestrictionRange RestrictionGraph::GetRestrictions(RestrictionID id) const
 {
     const auto &node = nodes[id];
-    return std::ranges::subrange(restrictions.begin() + node.restrictions_begin_idx,
+    return boost::make_iterator_range(restrictions.begin() + node.restrictions_begin_idx,
-                                 restrictions.begin() + node.restrictions_begin_idx +
+                                      restrictions.begin() + node.restrictions_begin_idx +
-                                     node.num_restrictions);
+                                          node.num_restrictions);
 }
 
 RestrictionGraph::EdgeRange RestrictionGraph::GetEdges(RestrictionID id) const
 {
     const auto &node = nodes[id];
-    return std::ranges::subrange(edges.begin() + node.edges_begin_idx,
+    return boost::make_iterator_range(edges.begin() + node.edges_begin_idx,
-                                 edges.begin() + node.edges_begin_idx + node.num_edges);
+                                      edges.begin() + node.edges_begin_idx + node.num_edges);
 }
 
 } // namespace osrm::extractor

src/partitioner/bisection_to_partition.cpp

@@ -124,7 +124,7 @@ bisectionToPartition(const std::vector<BisectionID> &node_to_bisection_id,
     std::vector<std::uint32_t> num_cells(max_cell_sizes.size());
 
     int level_idx = max_cell_sizes.size() - 1;
-    for (auto max_cell_size : std::ranges::reverse_view(max_cell_sizes))
+    for (auto max_cell_size : boost::adaptors::reverse(max_cell_sizes))
     {
         BOOST_ASSERT(level_idx >= 0);
         partitionLevel(node_to_bisection_id, max_cell_size, permutation, cells);

src/updater/updater.cpp

@@ -252,11 +252,11 @@ updateSegmentData(const UpdaterConfig &config,
 
                 // In this case we want it oriented from in forward directions
                 auto rev_weights_range =
-                    segment_data.GetReverseWeights(geometry_id) | std::views::reverse;
+                    boost::adaptors::reverse(segment_data.GetReverseWeights(geometry_id));
                 auto rev_durations_range =
-                    segment_data.GetReverseDurations(geometry_id) | std::views::reverse;
+                    boost::adaptors::reverse(segment_data.GetReverseDurations(geometry_id));
                 auto rev_datasources_range =
-                    segment_data.GetReverseDatasources(geometry_id) | std::views::reverse;
+                    boost::adaptors::reverse(segment_data.GetReverseDatasources(geometry_id));
                 bool rev_was_updated = false;
 
                 for (const auto segment_offset :
@@ -337,11 +337,11 @@ updateSegmentData(const UpdaterConfig &config,
             auto new_fwd_durations_range = segment_data.GetForwardDurations(geometry_id);
             auto new_fwd_datasources_range = segment_data.GetForwardDatasources(geometry_id);
             auto new_rev_durations_range =
-                segment_data.GetReverseDurations(geometry_id) | std::views::reverse;
+                boost::adaptors::reverse(segment_data.GetReverseDurations(geometry_id));
             auto new_rev_datasources_range = segment_data.GetReverseDatasources(geometry_id);
             auto old_fwd_durations_range = segment_data_backup->GetForwardDurations(geometry_id);
             auto old_rev_durations_range =
-                segment_data_backup->GetReverseDurations(geometry_id) | std::views::reverse;
+                boost::adaptors::reverse(segment_data_backup->GetReverseDurations(geometry_id));
 
             for (const auto segment_offset :
                  util::irange<std::size_t>(0, new_fwd_durations_range.size()))

third_party/sol2/include/sol/sol.hpp

@@ -6752,8 +6752,7 @@ namespace sol {
 			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
 
 			*this = nullopt;
-			new (static_cast<void*>(this)) optional(std::in_place, std::forward<Args>(args)...);
+			this->construct(std::forward<Args>(args)...);
-			return **this;
 		}
 
 		/// Swaps this optional with the other.

unit_tests/CMakeLists.txt

@@ -126,7 +126,6 @@ add_executable(util-tests
 	${UtilTestsSources}
         $<TARGET_OBJECTS:UTIL> $<TARGET_OBJECTS:MICROTAR>)
 
-
 if(NOT WIN32 AND NOT Boost_USE_STATIC_LIBS)
   add_definitions(-DBOOST_TEST_DYN_LINK)
 endif()

unit_tests/engine/offline_facade.cpp

@@ -4,7 +4,6 @@
 #include "util/integer_range.hpp"
 
 #include <boost/test/unit_test.hpp>
-#include <ranges>
 
 namespace osrm::engine
 {
@@ -72,17 +71,20 @@ struct ExternalCellStorage
     {
         auto GetOutWeight(NodeID /*node*/) const
         {
-            return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0);
+            return boost::make_iterator_range((EdgeWeight *)0, (EdgeWeight *)0);
         }
 
         auto GetInWeight(NodeID /*node*/) const
         {
-            return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0);
+            return boost::make_iterator_range((EdgeWeight *)0, (EdgeWeight *)0);
         }
 
-        auto GetSourceNodes() const { return std::ranges::subrange((NodeID *)0, (NodeID *)0); }
+        auto GetSourceNodes() const { return boost::make_iterator_range((NodeID *)0, (NodeID *)0); }
 
-        auto GetDestinationNodes() const { return std::ranges::subrange((NodeID *)0, (NodeID *)0); }
+        auto GetDestinationNodes() const
+        {
+            return boost::make_iterator_range((NodeID *)0, (NodeID *)0);
+        }
     };
 
     using Cell = CellImpl;

unit_tests/mocks/mock_datafacade.hpp

@@ -54,7 +54,7 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     {
         static NodeID data[] = {0, 1, 2, 3};
         static extractor::SegmentDataView::SegmentNodeVector nodes(data, 4);
-        return std::ranges::subrange(nodes.cbegin(), nodes.cend());
+        return boost::make_iterator_range(nodes.cbegin(), nodes.cend());
     }
     NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const override
     {

unit_tests/util/packed_vector.cpp

@@ -3,11 +3,14 @@
 
 #include "common/range_tools.hpp"
 
-#include <algorithm>
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/any_range.hpp>
+#include <boost/range/iterator_range.hpp>
 #include <boost/test/unit_test.hpp>
+
+#include <algorithm>
 #include <numeric>
 #include <random>
-#include <ranges>
 
 BOOST_AUTO_TEST_SUITE(packed_vector_test)
 
@@ -81,22 +84,22 @@ BOOST_AUTO_TEST_CASE(packed_vector_iterator_test)
     }
     BOOST_CHECK_EQUAL(vec_idx, packed_vec.size());
 
-    auto range = std::ranges::subrange(packed_vec.cbegin(), packed_vec.cend());
+    auto range = boost::make_iterator_range(packed_vec.cbegin(), packed_vec.cend());
     BOOST_CHECK_EQUAL(range.size(), packed_vec.size());
     for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
     {
         BOOST_CHECK_EQUAL(packed_vec[idx], range[idx]);
     }
 
-    auto reverse_range =
+    auto reverse_range = boost::adaptors::reverse(
-        std::ranges::subrange(packed_vec.cbegin(), packed_vec.cend()) | std::views::reverse;
+        boost::make_iterator_range(packed_vec.cbegin(), packed_vec.cend()));
     BOOST_CHECK_EQUAL(reverse_range.size(), packed_vec.size());
     for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
     {
         BOOST_CHECK_EQUAL(packed_vec[packed_vec.size() - 1 - idx], reverse_range[idx]);
     }
 
-    auto mut_range = std::ranges::subrange(packed_vec.begin(), packed_vec.end());
+    auto mut_range = boost::make_iterator_range(packed_vec.begin(), packed_vec.end());
     BOOST_CHECK_EQUAL(range.size(), packed_vec.size());
     for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
     {
@@ -104,7 +107,7 @@ BOOST_AUTO_TEST_CASE(packed_vector_iterator_test)
     }
 
     auto mut_reverse_range =
-        std::ranges::subrange(packed_vec.begin(), packed_vec.end()) | std::views::reverse;
+        boost::adaptors::reverse(boost::make_iterator_range(packed_vec.begin(), packed_vec.end()));
     BOOST_CHECK_EQUAL(reverse_range.size(), packed_vec.size());
     for (auto idx : util::irange<std::size_t>(0, packed_vec.size()))
     {
@@ -202,4 +205,73 @@ BOOST_AUTO_TEST_CASE(packed_vector_33bit_continious)
     }
 }
 
+BOOST_AUTO_TEST_CASE(packed_weights_container_with_type_erasure)
+{
+    using Vector = PackedVector<SegmentWeight, SEGMENT_WEIGHT_BITS>;
+    using WeightsAnyRange = boost::any_range<SegmentWeight,
+                                             boost::random_access_traversal_tag,
+                                             const typename Vector::internal_reference,
+                                             std::ptrdiff_t>;
+
+    PackedVector<SegmentWeight, SEGMENT_WEIGHT_BITS> vector(7);
+
+    std::iota(vector.begin(), vector.end(), SegmentWeight{0});
+
+    auto forward = boost::make_iterator_range(vector.begin() + 1, vector.begin() + 6);
+    auto forward_any = WeightsAnyRange(forward.begin(), forward.end());
+
+    CHECK_EQUAL_RANGE(forward,
+                      SegmentWeight{1},
+                      SegmentWeight{2},
+                      SegmentWeight{3},
+                      SegmentWeight{4},
+                      SegmentWeight{5});
+    CHECK_EQUAL_RANGE(forward_any,
+                      SegmentWeight{1},
+                      SegmentWeight{2},
+                      SegmentWeight{3},
+                      SegmentWeight{4},
+                      SegmentWeight{5});
+
+    auto reverse = boost::adaptors::reverse(forward);
+    auto reverse_any = WeightsAnyRange(reverse);
+    CHECK_EQUAL_RANGE(reverse,
+                      SegmentWeight{5},
+                      SegmentWeight{4},
+                      SegmentWeight{3},
+                      SegmentWeight{2},
+                      SegmentWeight{1});
+    CHECK_EQUAL_RANGE(reverse_any,
+                      SegmentWeight{5},
+                      SegmentWeight{4},
+                      SegmentWeight{3},
+                      SegmentWeight{2},
+                      SegmentWeight{1});
+}
+
+BOOST_AUTO_TEST_CASE(packed_weights_view_with_type_erasure)
+{
+    using View = PackedVectorView<SegmentWeight, SEGMENT_WEIGHT_BITS>;
+    using PackedDataWord = std::uint64_t; // PackedVectorView<>::WordT
+    using WeightsAnyRange = boost::any_range<SegmentWeight,
+                                             boost::random_access_traversal_tag,
+                                             const typename View::internal_reference,
+                                             std::ptrdiff_t>;
+
+    PackedDataWord data[] = {0x200000400000, 0xc, 0};
+    View view(vector_view<PackedDataWord>(data, 3), 7);
+
+    auto forward = boost::make_iterator_range(view.begin() + 1, view.begin() + 4);
+    auto forward_any = WeightsAnyRange(forward.begin(), forward.end());
+
+    CHECK_EQUAL_RANGE(forward, SegmentWeight{1}, SegmentWeight{2}, SegmentWeight{3});
+    CHECK_EQUAL_RANGE(forward_any, SegmentWeight{1}, SegmentWeight{2}, SegmentWeight{3});
+
+    auto reverse = boost::adaptors::reverse(forward);
+    auto reverse_any = WeightsAnyRange(reverse);
+
+    CHECK_EQUAL_RANGE(reverse, SegmentWeight{3}, SegmentWeight{2}, SegmentWeight{1});
+    CHECK_EQUAL_RANGE(reverse_any, SegmentWeight{3}, SegmentWeight{2}, SegmentWeight{1});
+}
+
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/util/vector_view.cpp

@@ -1,6 +1,8 @@
 #include "util/vector_view.hpp"
 #include "util/typedefs.hpp"
 
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/iterator_range.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <algorithm>